X-Git-Url: http://andersk.mit.edu/gitweb/splint.git/blobdiff_plain/11db3170da99e22aa0acea76debd6c7b590a629c..e015e0876e6dea76409cc6f82753dd4f185ae950:/src/ctype.c diff --git a/src/ctype.c b/src/ctype.c index 0c5778c..7fc16c4 100644 --- a/src/ctype.c +++ b/src/ctype.c @@ -1,6 +1,6 @@ /* ** Splint - annotation-assisted static program checker -** Copyright (C) 1994-2001 University of Virginia, +** Copyright (C) 1994-2002 University of Virginia, ** Massachusetts Institute of Technology ** ** This program is free software; you can redistribute it and/or modify it @@ -17,8 +17,8 @@ ** 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 */ /* @@ -28,7 +28,7 @@ ** They should probably be separated soon. */ -# include "lclintMacros.nf" +# include "splintMacros.nf" # include "basic.h" # include "structNames.h" @@ -52,12 +52,12 @@ static ctype ctype_getConjB (ctype p_c) /*@*/ ; 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) @@ -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)))); } @@ -194,7 +195,7 @@ ctype_realType (ctype c) bool ctype_isSimple (ctype c) { - return (!(ctype_isPointer (c) + return (! (ctype_isPointer (c) || ctype_isArray (c) || ctype_isFunction (c))); } @@ -224,7 +225,7 @@ ctype_realishType (ctype c) else { ctype r = uentry_getRealType (usymtab_getTypeEntry - (ctype_typeId (c))); + (ctype_typeId (c))); return (r); } } @@ -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) +{ + 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) { - return (cttable_addDerived (CTK_ARRAY, ctbase_makeFixedArray (c, size), 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; + } } /* @@ -381,6 +437,56 @@ ctype_baseArrayPtr (ctype c) } } +/* +** wchar_t * +*/ + +ctype +ctype_makeWideString () +{ + static ctype res = ctype_unknown; + + if (ctype_isUnknown (res)) + { + ctype wchart; + + if (usymtab_existsType (cstring_makeLiteralTemp ("wchar_t"))) + { + wchart = uentry_getAbstractType (usymtab_lookup (cstring_makeLiteralTemp ("wchar_t"))); + } + else + { + wchart = ctype_char; + } + + res = ctype_makePointer (wchart); + } + + return res; +} + +bool +ctype_isWideString (ctype c) +{ + if (ctype_isPointer (c)) + { + ctype ct = ctype_baseArrayPtr (c); + + if (usymtab_existsType (cstring_makeLiteralTemp ("wchar_t"))) + { + return (ct == uentry_getAbstractType (usymtab_lookup (cstring_makeLiteralTemp ("wchar_t")))); + } + else + { + return FALSE; + } + } + else + { + return FALSE; + } +} + ctype ctype_getReturnType (ctype c) { @@ -576,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 */ @@ -938,11 +1058,11 @@ ctype_isDirectInt (ctype c) 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))) { @@ -1019,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); @@ -1048,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) { @@ -1168,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; } @@ -1260,7 +1413,7 @@ ctype_makeConj (ctype c1, ctype c2) if (iv == ctype_unknown) { iv = cttable_addComplex - (ctbase_makeConj (ctype_int, + (ctbase_makeConj (ctype_int, ctype_voidPointer, FALSE)); } @@ -1359,7 +1512,6 @@ ctype_makeConj (ctype c1, ctype c2) { ; } - return (cttable_addComplex (ctbase_makeConj (c1, c2, FALSE))); } @@ -1653,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) { @@ -1698,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 ("?"); @@ -1776,7 +1925,7 @@ ctype_dump (ctype c) if (ctype_isUA (c)) { cstring tname = usymtab_getTypeEntryName - (usymtab_convertId (ctype_typeId (c))); + (usymtab_convertId (ctype_typeId (c))); if (cstring_equal (tname, context_getBoolName ())) { @@ -1849,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 @@ -2063,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) { @@ -2420,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; } @@ -2601,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 ",