X-Git-Url: http://andersk.mit.edu/gitweb/splint.git/blobdiff_plain/e8b844784e728912783e5a314b8af870a36010f9..ed62d3fbeda6bb085991cdd683ceacfc57f7afbe:/src/ctype.c diff --git a/src/ctype.c b/src/ctype.c index 31aacd0..8ed249f 100644 --- a/src/ctype.c +++ b/src/ctype.c @@ -1,6 +1,6 @@ /* ** Splint - annotation-assisted static program checker -** Copyright (C) 1994-2002 University of Virginia, +** Copyright (C) 1994-2003 University of Virginia, ** Massachusetts Institute of Technology ** ** This program is free software; you can redistribute it and/or modify it @@ -154,9 +154,21 @@ ctype_createUser (typeId u) 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 ] */ - return (cttable_addFullSafe (ctentry_makeNew (CTK_PLAIN, ctbase_createAbstract (u)))); + /* 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)))); +} + +ctype +ctype_createNumAbstract (typeId u) +{ + /* 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_createNumAbstract (u)))); } int @@ -235,7 +247,8 @@ ctype_realishType (ctype c) bool ctype_isUA (ctype c) { - return (!ctype_isUnknown (c) && ctbase_isUA (ctype_getCtbase (c))); + return (!ctype_isUnknown (c) + && ctbase_isUA (ctype_getCtbase (c))); } bool @@ -254,6 +267,16 @@ ctype_isAbstract (ctype c) || ctype_isAbstract (ctype_getConjB (c)))))); } +bool +ctype_isNumAbstract (ctype c) +{ + return (!ctype_isUnknown (c) + && ((ctype_isPlain (c) && ctbase_isNumAbstract (ctype_getCtbaseSafe (c))) || + (ctype_isConj (c) && + (ctype_isNumAbstract (ctype_getConjA (c)) + || ctype_isNumAbstract (ctype_getConjB (c)))))); +} + bool ctype_isImmutableAbstract (ctype t) { @@ -269,6 +292,15 @@ ctype_isRealAbstract (ctype c) ctype_isRealAbstract (ctype_getConjB (c))))); } +bool +ctype_isRealNumAbstract (ctype c) +{ + return (ctype_isNumAbstract (ctype_realType (c)) || + (ctype_isConj (c) && + (ctype_isRealNumAbstract (ctype_getConjA (c)) || + ctype_isRealNumAbstract (ctype_getConjB (c))))); +} + /* ** primitive creators */ @@ -315,30 +347,58 @@ ctype_makePointer (ctype c) } } -ctype ctype_makeFixedArray (ctype c, long size) +ctype ctype_makeFixedArray (ctype c, size_t size) { ctype res; res = cttable_addDerived (CTK_ARRAY, ctbase_makeFixedArray (c, size), c); return res; } -ctype ctype_makeInnerFixedArray (ctype c, long size) +ctype ctype_makeInnerFixedArray (ctype c, size_t size) { ctype res; if (ctype_isFixedArray (c)) { ctype cb = ctype_baseArrayPtr (c); - long osize = ctype_getArraySize (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_makeFixedArray (ctype_makeInnerFixedArray (cb, size), - osize); + 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; } @@ -348,6 +408,8 @@ ctype_makeArray (ctype c) 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); @@ -355,7 +417,9 @@ ctype_makeArray (ctype c) return (cnew); } else - return clp; + { + return clp; + } } /* @@ -1028,7 +1092,7 @@ static bool { ctype cbr = ctype_getConjA (*c); - /*drl bee: si*/ if ((*pred) (cbr)) + if ((*pred) (cbr)) { if ((*pred) (ctype_getConjB (*c))) { @@ -1105,7 +1169,11 @@ ctype_makeConjAux (ctype c1, ctype c2, bool isExplicit) 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); @@ -1134,6 +1202,27 @@ static ctype ivb = ctype_unknown; /* int | void * | bool */ 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) { @@ -1254,7 +1343,15 @@ ctype_makeConj (ctype c1, ctype c2) 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; } @@ -1445,7 +1542,6 @@ ctype_makeConj (ctype c1, ctype c2) { ; } - return (cttable_addComplex (ctbase_makeConj (c1, c2, FALSE))); } @@ -1754,7 +1850,7 @@ ctype_typeId (ctype c) cstring ctype_unparseDeclaration (ctype c, /*@only@*/ cstring name) { - llassert (! (ctype_isElips (c) || ctype_isMissingParamsMarker (c))); + llassert (!(ctype_isElips (c) || ctype_isMissingParamsMarker (c))); if (ctype_isUnknown (c)) { @@ -1777,6 +1873,10 @@ ctype_unparse (ctype c) { return cstring_makeLiteralTemp ("-"); } + else if (ctype_isAnytype (c)) + { + return cstring_makeLiteralTemp (""); + } else if (ctype_isUnknown (c)) { return cstring_makeLiteralTemp ("?"); @@ -1854,8 +1954,7 @@ ctype_dump (ctype c) if (ctype_isUA (c)) { - cstring tname = usymtab_getTypeEntryName - (usymtab_convertId (ctype_typeId (c))); + cstring tname = usymtab_getTypeEntryName (usymtab_convertTypeId (ctype_typeId (c))); if (cstring_equal (tname, context_getBoolName ())) { @@ -1900,6 +1999,7 @@ ctype_getBaseType (ctype c) case CT_ENUMLIST: case CT_BOOL: case CT_ABST: + case CT_NUMABST: case CT_FCN: case CT_STRUCT: case CT_UNION: @@ -1928,13 +2028,14 @@ ctype_getBaseType (ctype c) } 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 @@ -2142,6 +2243,16 @@ ctype_createForwardUnion (cstring n) 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) { @@ -2184,7 +2295,10 @@ bool ctype_isRefCounted (ctype t) bool ctype_isVisiblySharable (ctype t) { - if (ctype_isUnknown (t)) return TRUE; + if (ctype_isUnknown (t)) + { + return TRUE; + } if (ctype_isConj (t)) { @@ -2200,7 +2314,14 @@ bool ctype_isVisiblySharable (ctype t) if (rt == t) { - return TRUE; + if (ctype_isNumAbstract (t)) + { + return FALSE; + } + else + { + return TRUE; + } } else { @@ -2499,7 +2620,12 @@ ctype ctype_combine (ctype dominant, ctype modifier) 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; } @@ -2693,9 +2819,9 @@ bool ctype_isFixedArray (ctype c) /* 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; + size_t size; ctbase ctb; @@ -2710,3 +2836,14 @@ long int ctype_getArraySize (ctype c) return size; } +ctype ctype_biggerType (ctype c1, ctype c2) +{ + if (ctbase_isBigger (ctype_getCtbaseSafe (c2), ctype_getCtbaseSafe (c1)) ) + { + return c2; + } + else + { + return c1; + } +}