X-Git-Url: http://andersk.mit.edu/gitweb/splint.git/blobdiff_plain/155af98de2d41917730964947d990b7fb70ddc01..a6bfbad8f5ae6b3544a2c767e449ee095aad8978:/src/ctype.c diff --git a/src/ctype.c b/src/ctype.c index c4cae38..7fc16c4 100644 --- a/src/ctype.c +++ b/src/ctype.c @@ -154,8 +154,9 @@ 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 ] */ + /* 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)))); } @@ -235,7 +236,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 @@ -315,9 +317,59 @@ ctype_makePointer (ctype c) } } -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 @@ -326,6 +378,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); @@ -333,7 +387,9 @@ ctype_makeArray (ctype c) return (cnew); } else - return clp; + { + return clp; + } } /* @@ -626,6 +682,20 @@ ctype ctype_expectFunction (ctype c) 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 */ @@ -1069,7 +1139,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); @@ -1098,6 +1172,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) { @@ -1218,7 +1313,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; } @@ -1409,7 +1512,6 @@ ctype_makeConj (ctype c1, ctype c2) { ; } - return (cttable_addComplex (ctbase_makeConj (c1, c2, FALSE))); } @@ -1703,13 +1805,6 @@ bool ctype_isIncompleteArray (ctype c) 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) { @@ -1725,7 +1820,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)) { @@ -1748,6 +1843,10 @@ ctype_unparse (ctype c) { return cstring_makeLiteralTemp ("-"); } + else if (ctype_isAnytype (c)) + { + return cstring_makeLiteralTemp (""); + } else if (ctype_isUnknown (c)) { return cstring_makeLiteralTemp ("?"); @@ -1899,13 +1998,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 @@ -2113,6 +2213,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) { @@ -2470,7 +2580,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; } @@ -2651,20 +2766,28 @@ ctype_getCtentry (ctype 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 ",