** 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: info@splint.org
+** To report a bug: splint-bug@splint.org
** For more information: http://www.splint.org
*/
/*
** They should probably be separated soon.
*/
-# include "lclintMacros.nf"
+# include "splintMacros.nf"
# include "basic.h"
# include "structNames.h"
static bool ctype_isComplex (ctype c)
{
- return (ctentry_isComplex (ctype_getCtentry(c)));
+ return (ctentry_isComplex (ctype_getCtentry (c)));
}
static bool ctype_isPlain (ctype c)
{
- return (ctentry_isPlain (ctype_getCtentry(c)));
+ return (ctentry_isPlain (ctype_getCtentry (c)));
}
static bool ctype_isBroken (ctype c)
ctype
ctype_createAbstract (typeId u)
{
- /* requires: ctype_createAbstract (u) is never called more than once for any u. */
- /* [ tested by cttable_addFullSafe, not really required ] */
+ /* requires: ctype_createAbstract (u) is never called more than once for any u. */
+ /* [ tested by cttable_addFullSafe, not really required ] */
+
return (cttable_addFullSafe (ctentry_makeNew (CTK_PLAIN, ctbase_createAbstract (u))));
}
bool
ctype_isSimple (ctype c)
{
- return (!(ctype_isPointer (c)
+ return (! (ctype_isPointer (c)
|| ctype_isArray (c)
|| ctype_isFunction (c)));
}
else
{
ctype r = uentry_getRealType (usymtab_getTypeEntry
- (ctype_typeId (c)));
+ (ctype_typeId (c)));
return (r);
}
}
bool
ctype_isUA (ctype c)
{
- return (!ctype_isUnknown (c) && ctbase_isUA (ctype_getCtbase (c)));
+ return (!ctype_isUnknown (c)
+ && ctbase_isUA (ctype_getCtbase (c)));
}
bool
}
}
-ctype ctype_makeFixedArray (ctype c, long size)
+ctype ctype_makeFixedArray (ctype c, size_t size)
{
- return (cttable_addDerived (CTK_ARRAY, ctbase_makeFixedArray (c, size), c));
+ ctype res;
+ res = cttable_addDerived (CTK_ARRAY, ctbase_makeFixedArray (c, size), c);
+ return res;
+}
+
+ctype ctype_makeInnerFixedArray (ctype c, size_t size)
+{
+ ctype res;
+
+ if (ctype_isFixedArray (c))
+ {
+ ctype cb = ctype_baseArrayPtr (c);
+ size_t osize = ctype_getArraySize (c);
+
+ res = ctype_makeFixedArray (ctype_makeInnerFixedArray (cb, size), osize);
+ }
+ else if (ctype_isArray (c))
+ {
+ ctype cb = ctype_baseArrayPtr (c);
+
+ res = ctype_makeArray (ctype_makeInnerFixedArray (cb, size));
+ }
+ else
+ {
+ res = ctype_makeFixedArray (c, size);
+ }
+
+ DPRINTF (("Make inner fixed array: %s", ctype_unparse (res)));
+ return res;
+}
+
+ctype ctype_makeInnerArray (ctype c)
+{
+ ctype res;
+
+ DPRINTF (("Make inner array: %s", ctype_unparse (c)));
+
+ if (ctype_isFixedArray (c))
+ {
+ ctype cb = ctype_baseArrayPtr (c);
+ size_t osize = ctype_getArraySize (c);
+
+ res = ctype_makeFixedArray (ctype_makeInnerArray (cb), osize);
+ }
+ else
+ {
+ res = ctype_makeArray (c);
+ }
+
+ DPRINTF (("Make inner array: %s", ctype_unparse (res)));
+ return res;
}
ctype
ctentry cte = ctype_getCtentry (c);
ctype clp = ctentry_getArray (cte);
+ DPRINTF (("Make array: %s", ctype_unparse (c)));
+
if /*@+enumint@*/ (clp == CTK_DNE) /*@=enumint@*/
{
ctype cnew = cttable_addDerived (CTK_ARRAY, ctbase_makeArray (c), c);
return (cnew);
}
else
- return clp;
+ {
+ return clp;
+ }
}
/*
return (cttable_addComplex (ctbase_expectFunction (c)));
}
+ctype ctype_dontExpectFunction (ctype c)
+{
+ ctbase ctb = ctype_getCtbase (c);
+
+ /* what about this?
+ if (!ctype_isAP (c))
+ {
+ c = ctype_makePointer (c);
+ }
+ */
+
+ return (ctbase_getExpectFunction (ctb));
+}
+
/*
** makeRealFunction: function returning base
*/
static bool
ctype_isForcePred (ctype * c, bool (pred) (ctype))
{
- if (ctype_isConj (*c))
+ /*drl bee: pbr */ if (ctype_isConj (*c))
{
ctype cbr = ctype_getConjA (*c);
- if ((*pred) (cbr))
+ /*drl bee: si*/ if ((*pred) (cbr))
{
if ((*pred) (ctype_getConjB (*c)))
{
ctype
ctype_makeExplicitConj (ctype c1, ctype c2)
{
- if (ctype_isFunction (c1) && !ctype_isFunction (c2))
+ if (ctype_isAnytype (c1) || ctype_isAnytype (c2))
+ {
+ return ctype_makeAnytype ();
+ }
+ else if (ctype_isFunction (c1) && !ctype_isFunction (c2))
{
ctype ret = ctype_makeExplicitConj (ctype_getReturnType (c1), c2);
static ctype ivbf = ctype_unknown; /* int | void * | bool | float */
static ctype cuc = ctype_unknown; /* char | unsigned char */
+static ctype cany = ctype_unknown;
+
+ctype
+ctype_makeAnytype ()
+{
+ if (cany == ctype_unknown)
+ {
+ cany = ctype_makeConj (ctype_unknown, ctype_dne);
+ llassert (ctype_isAnytype (cany));
+ }
+
+ DPRINTF (("make anytype: %s", ctype_unparse (cany)));
+ return cany;
+}
+
+bool
+ctype_isAnytype (ctype c)
+{
+ return (c == cany);
+}
+
static void
ctype_recordConj (ctype c)
{
DPRINTF (("Make conj: %s / %s", ctype_unparse (c1), ctype_unparse (c2)));
- if (ctype_isUnknown (c1))
+ if (ctype_isAnytype (c1))
+ {
+ return c1;
+ }
+ else if (ctype_isAnytype (c2))
+ {
+ return c2;
+ }
+ else if (ctype_isUnknown (c1))
{
return c2;
}
if (iv == ctype_unknown)
{
iv = cttable_addComplex
- (ctbase_makeConj (ctype_int,
+ (ctbase_makeConj (ctype_int,
ctype_voidPointer,
FALSE));
}
{
;
}
-
return (cttable_addComplex (ctbase_makeConj (c1, c2, FALSE)));
}
return (ctype_isArray (c) && !ctype_isFixedArray (c));
}
-bool ctype_isFixedArray (ctype c)
-{
- if (ctype_isElips (c)) return FALSE;
-
- return (ctbase_isFixedArray (ctype_getCtbaseSafe (c)));
-}
-
bool
ctype_isArrayPtr (ctype c)
{
{
return cstring_makeLiteralTemp ("-");
}
+ else if (ctype_isAnytype (c))
+ {
+ return cstring_makeLiteralTemp ("<any>");
+ }
else if (ctype_isUnknown (c))
{
return cstring_makeLiteralTemp ("?");
if (ctype_isUA (c))
{
cstring tname = usymtab_getTypeEntryName
- (usymtab_convertId (ctype_typeId (c)));
+ (usymtab_convertId (ctype_typeId (c)));
if (cstring_equal (tname, context_getBoolName ()))
{
}
ctype
-ctype_adjustPointers (int np, ctype c)
+ctype_adjustPointers (pointers p, ctype c)
{
-
+ int np = pointers_depth (p);
+
if (ctype_isFunction (c))
{
c = ctype_makeParamsFunction
- (ctype_adjustPointers (np, ctype_getReturnType (c)),
+ (ctype_adjustPointers (p, ctype_getReturnType (c)),
uentryList_copy (ctype_argsFunction (c)));
}
else
return (ct);
}
+ctype
+ctype_createForwardEnum (cstring n)
+{
+ uentry ue = uentry_makeEnumTag (n, ctype_unknown, fileloc_undefined);
+ ctype ct = usymtab_supForwardTypeEntry (ue);
+
+ cstring_free (n);
+ return (ct);
+}
+
ctype
ctype_removePointers (ctype c)
{
ctype ctype_resolve (ctype c)
{
- if (ctype_isUnknown (c)) return ctype_int;
+ if (ctype_isUnknown (c) && !ctype_isAnytype (c))
+ {
+ DPRINTF (("Resolving to int: %s", ctype_unparse (c)));
+ return ctype_int;
+ }
+
return c;
}
/*@=enumint@*/
}
+
+bool ctype_isFixedArray (ctype c)
+{
+ if (ctype_isElips (c)) return FALSE;
+
+ return (ctbase_isFixedArray (ctype_getCtbaseSafe (c)));
+}
+
+
/*drl 11/28/2000 */
/* requires that the type is an fixed array */
/* return the size of the array */
-long int ctype_getArraySize (ctype c)
+size_t ctype_getArraySize (ctype c)
{
- long int size;
- ctentry cte = ctype_getCtentry (c);
+ size_t size;
+
ctbase ctb;
llassert (ctype_isFixedArray (c));
- llassert ((ctentry_getKind (cte) == CTK_COMPLEX) || (ctentry_getKind(cte) == CTK_ARRAY));
- ctb = cte->ctbase;
+ ctb = ctype_getCtbaseSafe(c);
size = ctbase_getArraySize (ctb);
DPRINTF ((message ("ctype_getArraySize: got fixed array size of %s / %d ",