From a4a1230c62d8920950b3c2ab0f751a47cd1f0840 Mon Sep 17 00:00:00 2001 From: acqn Date: Wed, 12 Oct 2022 13:10:17 +0800 Subject: [PATCH] Renamed some C type facility and fixed a few comments. Added some new C type code facility. Removed some unused type predicates. --- src/cc65/assignment.c | 2 +- src/cc65/codeseg.c | 2 +- src/cc65/datatype.c | 231 +++++++++++++++--------------- src/cc65/datatype.h | 324 ++++++++++++++++++++---------------------- src/cc65/declare.c | 16 +-- src/cc65/expr.c | 12 +- src/cc65/function.c | 4 +- src/cc65/initdata.c | 8 +- src/cc65/stdfunc.c | 12 +- src/cc65/swstmt.c | 2 +- src/cc65/symtab.c | 4 +- src/cc65/typecmp.c | 63 ++++---- src/cc65/typeconv.c | 2 +- 13 files changed, 330 insertions(+), 352 deletions(-) diff --git a/src/cc65/assignment.c b/src/cc65/assignment.c index 54ab28d4e..30e2f0fca 100644 --- a/src/cc65/assignment.c +++ b/src/cc65/assignment.c @@ -607,7 +607,7 @@ void OpAssign (const GenDesc* Gen, ExprDesc* Expr, const char* Op) Expr2.Flags |= Expr->Flags & E_MASK_KEEP_SUBEXPR; /* Only "=" accept struct/union */ - if (IsClassStruct (ltype) ? Gen != 0 : !IsClassScalar (ltype)) { + if (IsClassStruct (ltype) ? Gen != 0 : !IsScalarType (ltype)) { Error ("Invalid left operand for binary operator '%s'", Op); /* Continue. Wrong code will be generated, but the compiler won't ** break, so this is the best error recovery. diff --git a/src/cc65/codeseg.c b/src/cc65/codeseg.c index e621147ab..9f1bf4cc5 100644 --- a/src/cc65/codeseg.c +++ b/src/cc65/codeseg.c @@ -521,7 +521,7 @@ CodeSeg* NewCodeSeg (const char* SegName, SymEntry* Func) /* If we have a function given, get the return type of the function. ** Assume ANY return type besides void will use the A and X registers. */ - if (S->Func && !IsTypeVoid ((RetType = GetFuncReturn (Func->Type)))) { + if (S->Func && !IsTypeVoid ((RetType = GetFuncReturnType (Func->Type)))) { if (SizeOf (RetType) == SizeOf (type_long)) { S->ExitRegs = REG_EAX; } else { diff --git a/src/cc65/datatype.c b/src/cc65/datatype.c index 023aefaf7..6907ee099 100644 --- a/src/cc65/datatype.c +++ b/src/cc65/datatype.c @@ -150,7 +150,7 @@ void TypeFree (Type* T) int SignExtendChar (int C) -/* Do correct sign extension of a character */ +/* Do correct sign extension of a character to an int */ { if (IS_Get (&SignedChars) && (C & 0x80) != 0) { return C | ~0xFF; @@ -214,7 +214,7 @@ unsigned BitSizeOf (const Type* T) unsigned SizeOf (const Type* T) /* Compute size (in bytes) of object represented by type array */ { - switch (GetUnderlyingTypeCode (T)) { + switch (GetUnqualTypeCode (T)) { case T_VOID: /* A void variable is a cc65 extension. @@ -347,7 +347,7 @@ unsigned CheckedPSizeOf (const Type* T) -static unsigned GetBitFieldMinimalTypeSize (unsigned BitWidth) +static unsigned GetMinimalTypeSizeByBitWidth (unsigned BitWidth) /* Return the size of the smallest integer type that may have BitWidth bits */ { /* Since all integer types supported in cc65 for bit-fields have sizes that @@ -366,14 +366,14 @@ static unsigned GetBitFieldMinimalTypeSize (unsigned BitWidth) -TypeCode GetUnderlyingTypeCode (const Type* Type) -/* Get the type code of the unqualified underlying type of TCode. -** Return UnqualTypeCode (Type) if Type is not scalar. +TypeCode GetUnqualTypeCode (const Type* Type) +/* Get the type code of the unqualified underlying type of Type. +** Return GetUnqualRawTypeCode (Type) if Type is not scalar. */ { - TypeCode Underlying = UnqualifiedType (Type->C); + TypeCode Underlying = GetUnqualRawTypeCode (Type); - if (IsISOChar (Type)) { + if (IsDeclTypeChar (Type)) { return IS_Get (&SignedChars) ? T_SCHAR : T_UCHAR; @@ -382,7 +382,7 @@ TypeCode GetUnderlyingTypeCode (const Type* Type) /* This should not happen, but just in case */ if (Type->A.S == 0) { - Internal ("Enum tag type error in GetUnderlyingTypeCode"); + Internal ("Enum tag type error in GetUnqualTypeCode"); } /* Inspect the underlying type of the enum */ @@ -390,24 +390,24 @@ TypeCode GetUnderlyingTypeCode (const Type* Type) /* Incomplete enum type is used */ return Underlying; } - TCode = UnqualifiedType (Type->A.S->V.E.Type->C); + TCode = GetUnqualRawTypeCode (Type->A.S->V.E.Type); /* Replace the type code with integer */ - Underlying = (TCode & ~T_MASK_TYPE); + Underlying = (TCode & ~T_MASK_RANK); switch (TCode & T_MASK_SIZE) { - case T_SIZE_INT: Underlying |= T_TYPE_INT; break; - case T_SIZE_LONG: Underlying |= T_TYPE_LONG; break; - case T_SIZE_SHORT: Underlying |= T_TYPE_SHORT; break; - case T_SIZE_CHAR: Underlying |= T_TYPE_CHAR; break; - case T_SIZE_LONGLONG: Underlying |= T_TYPE_LONGLONG; break; - default: Underlying |= T_TYPE_INT; break; + case T_SIZE_INT: Underlying |= T_RANK_INT; break; + case T_SIZE_LONG: Underlying |= T_RANK_LONG; break; + case T_SIZE_SHORT: Underlying |= T_RANK_SHORT; break; + case T_SIZE_CHAR: Underlying |= T_RANK_CHAR; break; + case T_SIZE_LONGLONG: Underlying |= T_RANK_LONGLONG; break; + default: Underlying |= T_RANK_INT; break; } } else if (IsTypeBitField (Type)) { /* We consider the smallest type that can represent all values of the ** bit-field, instead of the type used in the declaration, the truly ** underlying of the bit-field. */ - switch (GetBitFieldMinimalTypeSize (Type->A.B.Width)) { + switch (GetMinimalTypeSizeByBitWidth (Type->A.B.Width)) { case SIZEOF_CHAR: Underlying = T_CHAR; break; case SIZEOF_INT: Underlying = T_INT; break; case SIZEOF_LONG: Underlying = T_LONG; break; @@ -494,7 +494,7 @@ Type* NewPointerTo (const Type* T) -Type* NewBitFieldType (const Type* T, unsigned BitOffs, unsigned BitWidth) +Type* NewBitFieldOf (const Type* T, unsigned BitOffs, unsigned BitWidth) /* Return a type string that is "T : BitWidth" aligned on BitOffs. The type ** string is allocated on the heap and may be freed after use. */ @@ -560,20 +560,6 @@ const Type* Indirect (const Type* T) -Type* IndirectModifiable (Type* T) -/* Do one indirection for the given type, that is, return the type where the -** given type points to. -*/ -{ - /* We are expecting a pointer expression */ - CHECK (IsClassPtr (T)); - - /* Skip the pointer or array token itself */ - return T + 1; -} - - - Type* ArrayToPtr (const Type* T) /* Convert an array to a pointer to it's first element */ { @@ -648,12 +634,12 @@ const Type* IntPromotion (const Type* T) return IsSignUnsigned (T) ? type_ulong : type_long; } return T->A.B.Width == INT_BITS && IsSignUnsigned (T) ? type_uint : type_int; - } else if (IsTypeChar (T)) { + } else if (IsRankChar (T)) { /* An integer can represent all values from either signed or unsigned char, so convert ** chars to int. */ return type_int; - } else if (IsTypeShort (T)) { + } else if (IsRankShort (T)) { /* An integer cannot represent all values from unsigned short, so convert unsigned short ** to unsigned int. */ @@ -690,8 +676,8 @@ const Type* ArithmeticConvert (const Type* lhst, const Type* rhst) /* If either operand has type unsigned long int, the other operand is converted to ** unsigned long int. */ - if ((IsTypeLong (lhst) && IsSignUnsigned (lhst)) || - (IsTypeLong (rhst) && IsSignUnsigned (rhst))) { + if ((IsRankLong (lhst) && IsSignUnsigned (lhst)) || + (IsRankLong (rhst) && IsSignUnsigned (rhst))) { return type_ulong; } @@ -700,74 +686,74 @@ const Type* ArithmeticConvert (const Type* lhst, const Type* rhst) ** is converted to long int ; if a long int cannot represent all the values of an unsigned int, ** both operands are converted to unsigned long int. */ - if ((IsTypeLong (lhst) && IsTypeInt (rhst) && IsSignUnsigned (rhst)) || - (IsTypeLong (rhst) && IsTypeInt (lhst) && IsSignUnsigned (lhst))) { + if ((IsRankLong (lhst) && IsRankInt (rhst) && IsSignUnsigned (rhst)) || + (IsRankLong (rhst) && IsRankInt (lhst) && IsSignUnsigned (lhst))) { /* long can represent all unsigneds, so we are in the first sub-case. */ return type_long; } /* Otherwise, if either operand has type long int, the other operand is converted to long int. */ - if (IsTypeLong (lhst) || IsTypeLong (rhst)) { + if (IsRankLong (lhst) || IsRankLong (rhst)) { return type_long; } /* Otherwise, if either operand has type unsigned int, the other operand is converted to ** unsigned int. */ - if ((IsTypeInt (lhst) && IsSignUnsigned (lhst)) || - (IsTypeInt (rhst) && IsSignUnsigned (rhst))) { + if ((IsRankInt (lhst) && IsSignUnsigned (lhst)) || + (IsRankInt (rhst) && IsSignUnsigned (rhst))) { return type_uint; } /* Otherwise, both operands have type int. */ - CHECK (IsTypeInt (lhst)); + CHECK (IsRankInt (lhst)); CHECK (IsSignSigned (lhst)); - CHECK (IsTypeInt (rhst)); + CHECK (IsRankInt (rhst)); CHECK (IsSignSigned (rhst)); return type_int; } -const Type* SignedType (const Type* T) +const Type* GetSignedType (const Type* T) /* Get signed counterpart of the integral type */ { - switch (GetUnderlyingTypeCode (T) & T_MASK_TYPE) { - case T_TYPE_CHAR: + switch (GetUnqualTypeCode (T) & T_MASK_RANK) { + case T_RANK_CHAR: return type_schar; - case T_TYPE_INT: - case T_TYPE_SHORT: + case T_RANK_INT: + case T_RANK_SHORT: return type_int; - case T_TYPE_LONG: + case T_RANK_LONG: return type_long; default: - Internal ("Unknown type code: %lX", GetUnderlyingTypeCode (T)); + Internal ("Unknown type code: %lX", GetUnqualTypeCode (T)); return T; } } -const Type* UnsignedType (const Type* T) +const Type* GetUnsignedType (const Type* T) /* Get unsigned counterpart of the integral type */ { - switch (GetUnderlyingTypeCode (T) & T_MASK_TYPE) { - case T_TYPE_CHAR: + switch (GetUnqualTypeCode (T) & T_MASK_RANK) { + case T_RANK_CHAR: return type_uchar; - case T_TYPE_INT: - case T_TYPE_SHORT: + case T_RANK_INT: + case T_RANK_SHORT: return type_uint; - case T_TYPE_LONG: + case T_RANK_LONG: return type_ulong; default: - Internal ("Unknown type code: %lX", GetUnderlyingTypeCode (T)); + Internal ("Unknown type code: %lX", GetUnqualTypeCode (T)); return T; } } @@ -777,12 +763,12 @@ const Type* UnsignedType (const Type* T) const Type* GetUnderlyingType (const Type* Type) /* Get the underlying type of an enum or other integer class type */ { - if (IsISOChar (Type)) { + if (IsDeclTypeChar (Type)) { return IS_Get (&SignedChars) ? type_schar : type_uchar; } else if (IsTypeEnum (Type)) { /* This should not happen, but just in case */ if (Type->A.S == 0) { - Internal ("Enum tag type error in GetUnderlyingTypeCode"); + Internal ("Enum tag type error in GetUnderlyingType"); } /* If incomplete enum type is used, just return its raw type */ @@ -794,7 +780,7 @@ const Type* GetUnderlyingType (const Type* Type) ** bit-field, instead of the type used in the declaration, the truly ** underlying of the bit-field. */ - switch (GetBitFieldMinimalTypeSize (Type->A.B.Width)) { + switch (GetMinimalTypeSizeByBitWidth (Type->A.B.Width)) { case SIZEOF_CHAR: Type = IsSignSigned (Type) ? type_schar : type_uchar; break; case SIZEOF_INT: Type = IsSignSigned (Type) ? type_int : type_uint; break; case SIZEOF_LONG: Type = IsSignSigned (Type) ? type_long : type_ulong; break; @@ -808,7 +794,7 @@ const Type* GetUnderlyingType (const Type* Type) const Type* GetStructReplacementType (const Type* SType) -/* Get a replacement type for passing a struct/union in the primary register */ +/* Get a replacement type for passing a struct/union by value in the primary */ { const Type* NewType; /* If the size is less than or equal to that of a long, we will copy the @@ -837,7 +823,7 @@ const Type* GetBitFieldChunkType (const Type* Type) return GetUnderlyingType (Type); } - ChunkSize = GetBitFieldMinimalTypeSize (Type->A.B.Offs + Type->A.B.Width); + ChunkSize = GetMinimalTypeSizeByBitWidth (Type->A.B.Offs + Type->A.B.Width); if (ChunkSize < SizeOf (Type + 1)) { /* The end of the bit-field is offset by some bits so that it requires ** more bytes to be accessed as a whole than its underlying type does. @@ -875,50 +861,50 @@ int IsTypeFragBitField (const Type* T) -int IsClassObject (const Type* T) +int IsObjectType (const Type* T) /* Return true if this is a fully described object type */ { - return !IsTypeFunc (T) && !IsClassIncomplete (T); + return !IsTypeFunc (T) && !IsIncompleteType (T); } -int IsClassIncomplete (const Type* T) +int IsIncompleteType (const Type* T) /* Return true if this is an object type lacking size info */ { if (IsTypeArray (T)) { - return GetElementCount (T) == UNSPECIFIED || IsClassIncomplete (T + 1); + return GetElementCount (T) == UNSPECIFIED || IsIncompleteType (T + 1); } return IsTypeVoid (T) || IsIncompleteESUType (T); } -int IsClassArithmetic (const Type* T) -/* Return true if this is an integer or real floating type */ +int IsArithmeticType (const Type* T) +/* Return true if this is an integer or floating type */ { return IsClassInt (T) || IsClassFloat (T); } -int IsClassBasic (const Type* T) -/* Return true if this is a char, integer or floating type */ +int IsBasicType (const Type* T) +/* Return true if this is a character, integer or floating type */ { - return IsClassChar (T) || IsClassInt (T) || IsClassFloat (T); + return IsDeclRankChar (T) || IsClassInt (T) || IsClassFloat (T); } -int IsClassScalar (const Type* T) +int IsScalarType (const Type* T) /* Return true if this is an arithmetic or pointer type */ { - return IsClassArithmetic (T) || IsTypePtr (T); + return IsArithmeticType (T) || IsTypePtr (T); } -int IsClassDerived (const Type* T) +int IsDerivedType (const Type* T) /* Return true if this is an array, struct, union, function or pointer type */ { return IsTypeArray (T) || IsClassStruct (T) || IsClassFunc (T) || IsTypePtr (T); @@ -926,7 +912,7 @@ int IsClassDerived (const Type* T) -int IsClassAggregate (const Type* T) +int IsAggregateType (const Type* T) /* Return true if this is an array or struct type */ { return IsTypeArray (T) || IsTypeStruct (T); @@ -937,7 +923,7 @@ int IsClassAggregate (const Type* T) int IsRelationType (const Type* T) /* Return true if this is an arithmetic, array or pointer type */ { - return IsClassArithmetic (T) || IsClassPtr (T); + return IsArithmeticType (T) || IsClassPtr (T); } @@ -945,7 +931,7 @@ int IsRelationType (const Type* T) int IsCastType (const Type* T) /* Return true if this type can be used for casting */ { - return IsClassScalar (T) || IsTypeVoid (T); + return IsScalarType (T) || IsTypeVoid (T); } @@ -987,7 +973,7 @@ int HasUnknownSize (const Type* T) -int TypeHasAttr (const Type* T) +int TypeHasAttrData (const Type* T) /* Return true if the given type has attribute data */ { return IsClassStruct (T) || IsTypeArray (T) || IsClassFunc (T); @@ -1044,7 +1030,7 @@ int IsFastcallFunc (const Type* T) ** Check fails if the type is not a function or a pointer to function. */ { - if (UnqualifiedType (T->C) == T_PTR) { + if (GetUnqualRawTypeCode (T) == T_PTR) { /* Pointer to function */ ++T; } @@ -1056,7 +1042,7 @@ int IsFastcallFunc (const Type* T) FuncDesc* GetFuncDesc (const Type* T) /* Get the FuncDesc pointer from a function or pointer-to-function type */ { - if (UnqualifiedType (T->C) == T_PTR) { + if (GetUnqualRawTypeCode (T) == T_PTR) { /* Pointer to function */ ++T; } @@ -1073,7 +1059,7 @@ FuncDesc* GetFuncDesc (const Type* T) void SetFuncDesc (Type* T, FuncDesc* F) /* Set the FuncDesc pointer in a function or pointer-to-function type */ { - if (UnqualifiedType (T->C) == T_PTR) { + if (GetUnqualRawTypeCode (T) == T_PTR) { /* Pointer to function */ ++T; } @@ -1087,10 +1073,10 @@ void SetFuncDesc (Type* T, FuncDesc* F) -const Type* GetFuncReturn (const Type* T) +const Type* GetFuncReturnType (const Type* T) /* Return a pointer to the return type of a function or pointer-to-function type */ { - if (UnqualifiedType (T->C) == T_PTR) { + if (GetUnqualRawTypeCode (T) == T_PTR) { /* Pointer to function */ ++T; } @@ -1104,10 +1090,10 @@ const Type* GetFuncReturn (const Type* T) -Type* GetFuncReturnModifiable (Type* T) +Type* GetFuncReturnTypeModifiable (Type* T) /* Return a non-const pointer to the return type of a function or pointer-to-function type */ { - if (UnqualifiedType (T->C) == T_PTR) { + if (GetUnqualRawTypeCode (T) == T_PTR) { /* Pointer to function */ ++T; } @@ -1164,7 +1150,16 @@ void SetElementCount (Type* T, long Count) const Type* GetElementType (const Type* T) -/* Return the element type of the given array type. */ +/* Return the element type of the given array type */ +{ + CHECK (IsTypeArray (T)); + return T + 1; +} + + + +Type* GetElementTypeModifiable (Type* T) +/* Return the element type of the given array type */ { CHECK (IsTypeArray (T)); return T + 1; @@ -1228,48 +1223,48 @@ const char* GetBasicTypeName (const Type* T) ** Return "type" for unknown basic types. */ { - switch (GetRawType (T)) { - case T_TYPE_ENUM: return "enum"; - case T_TYPE_BITFIELD: return "bit-field"; - case T_TYPE_FLOAT: return "float"; - case T_TYPE_DOUBLE: return "double"; - case T_TYPE_VOID: return "void"; - case T_TYPE_STRUCT: return "struct"; - case T_TYPE_UNION: return "union"; - case T_TYPE_ARRAY: return "array"; - case T_TYPE_PTR: return "pointer"; - case T_TYPE_FUNC: return "function"; - case T_TYPE_NONE: /* FALLTHROUGH */ + switch (GetRawTypeRank (T)) { + case T_RANK_ENUM: return "enum"; + case T_RANK_BITFIELD: return "bit-field"; + case T_RANK_FLOAT: return "float"; + case T_RANK_DOUBLE: return "double"; + case T_RANK_VOID: return "void"; + case T_RANK_STRUCT: return "struct"; + case T_RANK_UNION: return "union"; + case T_RANK_ARRAY: return "array"; + case T_RANK_PTR: return "pointer"; + case T_RANK_FUNC: return "function"; + case T_RANK_NONE: /* FALLTHROUGH */ default: break; } if (IsClassInt (T)) { if (IsRawSignSigned (T)) { - switch (GetRawType (T)) { - case T_TYPE_CHAR: return "signed char"; - case T_TYPE_SHORT: return "short"; - case T_TYPE_INT: return "int"; - case T_TYPE_LONG: return "long"; - case T_TYPE_LONGLONG: return "long long"; + switch (GetRawTypeRank (T)) { + case T_RANK_CHAR: return "signed char"; + case T_RANK_SHORT: return "short"; + case T_RANK_INT: return "int"; + case T_RANK_LONG: return "long"; + case T_RANK_LONGLONG: return "long long"; default: return "signed integer"; } } else if (IsRawSignUnsigned (T)) { - switch (GetRawType (T)) { - case T_TYPE_CHAR: return "unsigned char"; - case T_TYPE_SHORT: return "unsigned short"; - case T_TYPE_INT: return "unsigned int"; - case T_TYPE_LONG: return "unsigned long"; - case T_TYPE_LONGLONG: return "unsigned long long"; + switch (GetRawTypeRank (T)) { + case T_RANK_CHAR: return "unsigned char"; + case T_RANK_SHORT: return "unsigned short"; + case T_RANK_INT: return "unsigned int"; + case T_RANK_LONG: return "unsigned long"; + case T_RANK_LONGLONG: return "unsigned long long"; default: return "unsigned integer"; } } else { - switch (GetRawType (T)) { - case T_TYPE_CHAR: return "char"; - case T_TYPE_SHORT: return "short"; - case T_TYPE_INT: return "int"; - case T_TYPE_LONG: return "long"; - case T_TYPE_LONGLONG: return "long long"; + switch (GetRawTypeRank (T)) { + case T_RANK_CHAR: return "char"; + case T_RANK_SHORT: return "short"; + case T_RANK_INT: return "int"; + case T_RANK_LONG: return "long"; + case T_RANK_LONGLONG: return "long long"; default: return "integer"; } @@ -1600,7 +1595,7 @@ void PrintFuncSig (FILE* F, const char* Name, const Type* T) SB_Done (&ParamList); /* Complete with the return type */ - GetFullTypeNameWestEast (&West, &East, GetFuncReturn (T)); + GetFullTypeNameWestEast (&West, &East, GetFuncReturnType (T)); SB_Append (&West, &East); SB_Terminate (&West); diff --git a/src/cc65/datatype.h b/src/cc65/datatype.h index 4a20422fb..eebd3abd8 100644 --- a/src/cc65/datatype.h +++ b/src/cc65/datatype.h @@ -71,24 +71,24 @@ struct SymEntry; enum { T_END = 0x000000, - /* Basic types */ - T_TYPE_NONE = 0x000000, - T_TYPE_CHAR = 0x000001, - T_TYPE_SHORT = 0x000002, - T_TYPE_INT = 0x000003, - T_TYPE_LONG = 0x000004, - T_TYPE_LONGLONG = 0x000005, - T_TYPE_ENUM = 0x000008, - T_TYPE_BITFIELD = 0x000009, - T_TYPE_FLOAT = 0x00000A, - T_TYPE_DOUBLE = 0x00000B, - T_TYPE_VOID = 0x000010, - T_TYPE_STRUCT = 0x000011, - T_TYPE_UNION = 0x000012, - T_TYPE_ARRAY = 0x000018, - T_TYPE_PTR = 0x000019, - T_TYPE_FUNC = 0x00001A, - T_MASK_TYPE = 0x00001F, + /* Basic type ranks */ + T_RANK_NONE = 0x000000, + T_RANK_CHAR = 0x000001, + T_RANK_SHORT = 0x000002, + T_RANK_INT = 0x000003, + T_RANK_LONG = 0x000004, + T_RANK_LONGLONG = 0x000005, + T_RANK_ENUM = 0x000008, + T_RANK_BITFIELD = 0x000009, + T_RANK_FLOAT = 0x00000A, + T_RANK_DOUBLE = 0x00000B, + T_RANK_VOID = 0x000010, + T_RANK_STRUCT = 0x000011, + T_RANK_UNION = 0x000012, + T_RANK_ARRAY = 0x000018, + T_RANK_PTR = 0x000019, + T_RANK_FUNC = 0x00001A, + T_MASK_RANK = 0x00001F, /* Type classes */ T_CLASS_NONE = 0x000000, @@ -129,28 +129,28 @@ enum { T_MASK_QUAL = 0x7F0000, /* Types */ - T_CHAR = T_TYPE_CHAR | T_CLASS_INT | T_SIGN_NONE | T_SIZE_CHAR, - T_SCHAR = T_TYPE_CHAR | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_CHAR, - T_UCHAR = T_TYPE_CHAR | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_CHAR, - T_SHORT = T_TYPE_SHORT | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_SHORT, - T_USHORT = T_TYPE_SHORT | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_SHORT, - T_INT = T_TYPE_INT | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_INT, - T_UINT = T_TYPE_INT | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_INT, - T_LONG = T_TYPE_LONG | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_LONG, - T_ULONG = T_TYPE_LONG | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_LONG, - T_LONGLONG = T_TYPE_LONGLONG | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_LONGLONG, - T_ULONGLONG = T_TYPE_LONGLONG | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_LONGLONG, - T_ENUM = T_TYPE_ENUM | T_CLASS_INT | T_SIGN_NONE | T_SIZE_NONE, - T_SBITFIELD = T_TYPE_BITFIELD | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_NONE, - T_UBITFIELD = T_TYPE_BITFIELD | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_NONE, - T_FLOAT = T_TYPE_FLOAT | T_CLASS_FLOAT | T_SIGN_NONE | T_SIZE_NONE, - T_DOUBLE = T_TYPE_DOUBLE | T_CLASS_FLOAT | T_SIGN_NONE | T_SIZE_NONE, - T_VOID = T_TYPE_VOID | T_CLASS_NONE | T_SIGN_NONE | T_SIZE_NONE, - T_STRUCT = T_TYPE_STRUCT | T_CLASS_STRUCT | T_SIGN_NONE | T_SIZE_NONE, - T_UNION = T_TYPE_UNION | T_CLASS_STRUCT | T_SIGN_NONE | T_SIZE_NONE, - T_ARRAY = T_TYPE_ARRAY | T_CLASS_PTR | T_SIGN_NONE | T_SIZE_NONE, - T_PTR = T_TYPE_PTR | T_CLASS_PTR | T_SIGN_NONE | T_SIZE_NONE, - T_FUNC = T_TYPE_FUNC | T_CLASS_FUNC | T_SIGN_NONE | T_SIZE_NONE, + T_CHAR = T_RANK_CHAR | T_CLASS_INT | T_SIGN_NONE | T_SIZE_CHAR, + T_SCHAR = T_RANK_CHAR | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_CHAR, + T_UCHAR = T_RANK_CHAR | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_CHAR, + T_SHORT = T_RANK_SHORT | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_SHORT, + T_USHORT = T_RANK_SHORT | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_SHORT, + T_INT = T_RANK_INT | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_INT, + T_UINT = T_RANK_INT | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_INT, + T_LONG = T_RANK_LONG | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_LONG, + T_ULONG = T_RANK_LONG | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_LONG, + T_LONGLONG = T_RANK_LONGLONG | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_LONGLONG, + T_ULONGLONG = T_RANK_LONGLONG | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_LONGLONG, + T_ENUM = T_RANK_ENUM | T_CLASS_INT | T_SIGN_NONE | T_SIZE_NONE, + T_SBITFIELD = T_RANK_BITFIELD | T_CLASS_INT | T_SIGN_SIGNED | T_SIZE_NONE, + T_UBITFIELD = T_RANK_BITFIELD | T_CLASS_INT | T_SIGN_UNSIGNED | T_SIZE_NONE, + T_FLOAT = T_RANK_FLOAT | T_CLASS_FLOAT | T_SIGN_NONE | T_SIZE_NONE, + T_DOUBLE = T_RANK_DOUBLE | T_CLASS_FLOAT | T_SIGN_NONE | T_SIZE_NONE, + T_VOID = T_RANK_VOID | T_CLASS_NONE | T_SIGN_NONE | T_SIZE_NONE, + T_STRUCT = T_RANK_STRUCT | T_CLASS_STRUCT | T_SIGN_NONE | T_SIZE_NONE, + T_UNION = T_RANK_UNION | T_CLASS_STRUCT | T_SIGN_NONE | T_SIZE_NONE, + T_ARRAY = T_RANK_ARRAY | T_CLASS_PTR | T_SIGN_NONE | T_SIZE_NONE, + T_PTR = T_RANK_PTR | T_CLASS_PTR | T_SIGN_NONE | T_SIZE_NONE, + T_FUNC = T_RANK_FUNC | T_CLASS_FUNC | T_SIGN_NONE | T_SIZE_NONE, /* More types for convenience */ T_C_CHAR = T_CHAR | T_QUAL_CONST, @@ -316,7 +316,9 @@ unsigned CheckedPSizeOf (const Type* T); #if defined(HAVE_INLINE) INLINE TypeCode GetQualifier (const Type* T) -/* Get the qualifier from the given type string */ +/* Get the qualifier from the given type. This doesn't have a "raw" version +** since an underlying type can never be qualified. +*/ { return (T->C & T_MASK_QUAL); } @@ -324,66 +326,78 @@ INLINE TypeCode GetQualifier (const Type* T) # define GetQualifier(T) ((T)->C & T_MASK_QUAL) #endif -TypeCode GetUnderlyingTypeCode (const Type* Type); -/* Get the type code of the unqualified underlying type of TCode. -** Return TCode if it is not scalar. +TypeCode GetUnqualTypeCode (const Type* Type); +/* Get the type code of the unqualified underlying type of Type. +** Return GetUnqualRawTypeCode (Type) if Type is not scalar. */ #if defined(HAVE_INLINE) -INLINE TypeCode UnqualifiedType (TypeCode T) -/* Return the unqualified type code */ +INLINE TypeCode GetUnqualRawTypeCode (const Type* T) +/* Return the unqualified raw type code */ { - return (T & ~T_MASK_QUAL); + return (T->C & ~T_MASK_QUAL); } #else -# define UnqualifiedType(T) ((T) & ~T_MASK_QUAL) +# define GetUnqualRawTypeCode(T) ((T)->C & ~T_MASK_QUAL) #endif #if defined(HAVE_INLINE) -INLINE TypeCode GetClass (const Type* T) -/* Get the class of a type string */ +INLINE TypeCode GetTypeClass (const Type* T) +/* Get the class of a type. This doesn't have a "raw" version since an +** underlying type can never be in a different class. +*/ { return (T->C & T_MASK_CLASS); } #else -# define GetClass(T) ((T)->C & T_MASK_CLASS) +# define GetTypeClass(T) ((T)->C & T_MASK_CLASS) +#endif + +#if defined(HAVE_INLINE) +INLINE TypeCode GetTypeRank (const Type* T) +/* Get the type rank of a type */ +{ + return (GetUnqualTypeCode (T) & T_MASK_RANK); +} +#else +# define GetTypeRank(T) (GetUnqualTypeCode (T) & T_MASK_RANK) #endif #if defined(HAVE_INLINE) INLINE TypeCode GetSignedness (const Type* T) /* Get the signedness of a type */ { - return (GetUnderlyingTypeCode (T) & T_MASK_SIGN); + return (GetUnqualTypeCode (T) & T_MASK_SIGN); } #else -# define GetSignedness(T) (GetUnderlyingTypeCode (T) & T_MASK_SIGN) +# define GetSignedness(T) (GetUnqualTypeCode (T) & T_MASK_SIGN) #endif #if defined(HAVE_INLINE) INLINE TypeCode GetSizeModifier (const Type* T) /* Get the size modifier of a type */ { - return (GetUnderlyingTypeCode (T) & T_MASK_SIZE); + return (GetUnqualTypeCode (T) & T_MASK_SIZE); } #else -# define GetSizeModifier(T) (GetUnderlyingTypeCode (T) & T_MASK_SIZE) +# define GetSizeModifier(T) (GetUnqualTypeCode (T) & T_MASK_SIZE) #endif #if defined(HAVE_INLINE) -INLINE TypeCode GetRawType (const Type* T) -/* Get the raw type */ +INLINE TypeCode GetRawTypeRank (const Type* T) +/* Get the raw type rank of a type */ { - return (T->C & T_MASK_TYPE); + return (T->C & T_MASK_RANK); } #else -# define GetRawType(T) ((T)->C & T_MASK_TYPE) +# define GetRawTypeRank(T) ((T)->C & T_MASK_RANK) #endif #if defined(HAVE_INLINE) INLINE TypeCode GetRawSignedness (const Type* T) /* Get the raw signedness of a type */ { - return ((T)->C & T_MASK_SIGN); + return (T->C & T_MASK_SIGN); } #else # define GetRawSignedness(T) ((T)->C & T_MASK_SIGN) @@ -391,7 +405,7 @@ INLINE TypeCode GetRawSignedness (const Type* T) #if defined(HAVE_INLINE) INLINE TypeCode GetRawSizeModifier (const Type* T) -/* Get the size modifier of a raw type */ +/* Get the raw size modifier of a type */ { return (T->C & T_MASK_SIZE); } @@ -418,7 +432,7 @@ Type* NewPointerTo (const Type* T); ** on the heap and may be freed after use. */ -Type* NewBitFieldType (const Type* T, unsigned BitOffs, unsigned BitWidth); +Type* NewBitFieldOf (const Type* T, unsigned BitOffs, unsigned BitWidth); /* Return a type string that is "T : BitWidth" aligned on BitOffs. The type ** string is allocated on the heap and may be freed after use. */ @@ -433,11 +447,6 @@ const Type* Indirect (const Type* T); ** given type points to. */ -Type* IndirectModifiable (Type* T); -/* Do one indirection for the given type, that is, return the type where the -** given type points to. -*/ - Type* ArrayToPtr (const Type* T); /* Convert an array to a pointer to it's first element */ @@ -461,17 +470,17 @@ const Type* IntPromotion (const Type* T); const Type* ArithmeticConvert (const Type* lhst, const Type* rhst); /* Perform the usual arithmetic conversions for binary operators. */ -const Type* SignedType (const Type* T); +const Type* GetSignedType (const Type* T); /* Get signed counterpart of the integral type */ -const Type* UnsignedType (const Type* T); +const Type* GetUnsignedType (const Type* T); /* Get unsigned counterpart of the integral type */ const Type* GetUnderlyingType (const Type* Type); /* Get the underlying type of an enum or other integer class type */ const Type* GetStructReplacementType (const Type* SType); -/* Get a replacement type for passing a struct/union in the primary register */ +/* Get a replacement type for passing a struct/union by value in the primary */ const Type* GetBitFieldChunkType (const Type* Type); /* Get the type needed to operate on the byte chunk containing the bit-field */ @@ -485,155 +494,127 @@ const Type* GetBitFieldChunkType (const Type* Type); #if defined(HAVE_INLINE) -INLINE int IsTypeChar (const Type* T) -/* Return true if this is a char type */ +INLINE int IsRankChar (const Type* T) +/* Return true if this is a character type */ { - return (GetRawType (GetUnderlyingType (T)) == T_TYPE_CHAR); + return (GetTypeRank (T) == T_RANK_CHAR); } #else -# define IsTypeChar(T) (GetRawType (GetUnderlyingType (T)) == T_TYPE_CHAR) +# define IsRankChar(T) (GetTypeRank (T) == T_RANK_CHAR) #endif #if defined(HAVE_INLINE) -INLINE int IsTypeShort (const Type* T) +INLINE int IsRankShort (const Type* T) /* Return true if this is a short type (signed or unsigned) */ { - return (GetRawType (GetUnderlyingType (T)) == T_TYPE_SHORT); + return (GetTypeRank (T) == T_RANK_SHORT); } #else -# define IsTypeShort(T) (GetRawType (GetUnderlyingType (T)) == T_TYPE_SHORT) +# define IsRankShort(T) (GetTypeRank (T) == T_RANK_SHORT) #endif #if defined(HAVE_INLINE) -INLINE int IsTypeInt (const Type* T) +INLINE int IsRankInt (const Type* T) /* Return true if this is an int type (signed or unsigned) */ { - return (GetRawType (GetUnderlyingType (T)) == T_TYPE_INT); + return (GetTypeRank (T) == T_RANK_INT); } #else -# define IsTypeInt(T) (GetRawType (GetUnderlyingType (T)) == T_TYPE_INT) +# define IsRankInt(T) (GetTypeRank (T) == T_RANK_INT) #endif #if defined(HAVE_INLINE) -INLINE int IsTypeLong (const Type* T) +INLINE int IsRankLong (const Type* T) /* Return true if this is a long int type (signed or unsigned) */ { - return (GetRawType (GetUnderlyingType (T)) == T_TYPE_LONG); + return (GetTypeRank (T) == T_RANK_LONG); } #else -# define IsTypeLong(T) (GetRawType (GetUnderlyingType (T)) == T_TYPE_LONG) +# define IsRankLong(T) (GetTypeRank (T) == T_RANK_LONG) #endif #if defined(HAVE_INLINE) -INLINE int IsISOChar (const Type* T) -/* Return true if this is a narrow character type (without signed/unsigned) */ -{ - return (UnqualifiedType (T->C) == T_CHAR); -} -#else -# define IsISOChar(T) (UnqualifiedType ((T)->C) == T_CHAR) -#endif - -#if defined(HAVE_INLINE) -INLINE int IsClassChar (const Type* T) -/* Return true if this is a narrow character type (including signed/unsigned). -** For now this is the same as IsRawTypeChar(T). +INLINE int IsDeclTypeChar (const Type* T) +/* Return true if this is declared as a char type (without signed/unsigned). +** This function is to exclude enums whose underlying type is char. */ { - return (GetRawType (T) == T_TYPE_CHAR); + return (GetUnqualRawTypeCode (T) == T_CHAR); } #else -# define IsClassChar(T) (GetRawType (T) == T_TYPE_CHAR) +# define IsDeclTypeChar(T) (GetUnqualRawTypeCode (T) == T_CHAR) #endif #if defined(HAVE_INLINE) -INLINE int IsRawTypeChar (const Type* T) -/* Return true if this is a char raw type (including signed/unsigned) */ +INLINE int IsDeclRankChar (const Type* T) +/* Return true if this is declared as a character type (including signed/unsigned). +** This function is to exclude enums whose underlying types are character types. +*/ { - return (GetRawType (T) == T_TYPE_CHAR); + return (GetRawTypeRank (T) == T_RANK_CHAR); } #else -# define IsRawTypeChar(T) (GetRawType (T) == T_TYPE_CHAR) -#endif - -#if defined(HAVE_INLINE) -INLINE int IsRawTypeInt (const Type* T) -/* Return true if this is an int raw type (signed or unsigned) */ -{ - return (GetRawType (T) == T_TYPE_INT); -} -#else -# define IsRawTypeInt(T) (GetRawType (T) == T_TYPE_INT) -#endif - -#if defined(HAVE_INLINE) -INLINE int IsRawTypeLong (const Type* T) -/* Return true if this is a long raw type (signed or unsigned) */ -{ - return (GetRawType (T) == T_TYPE_LONG); -} -#else -# define IsRawTypeLong(T) (GetRawType (T) == T_TYPE_LONG) +# define IsDeclRankChar(T) (GetRawTypeRank (T) == T_RANK_CHAR) #endif #if defined(HAVE_INLINE) INLINE int IsTypeFloat (const Type* T) /* Return true if this is a float type */ { - return (GetRawType (T) == T_TYPE_FLOAT); + return (GetRawTypeRank (T) == T_RANK_FLOAT); } #else -# define IsTypeFloat(T) (GetRawType (T) == T_TYPE_FLOAT) +# define IsTypeFloat(T) (GetRawTypeRank (T) == T_RANK_FLOAT) #endif #if defined(HAVE_INLINE) INLINE int IsTypeDouble (const Type* T) /* Return true if this is a double type */ { - return (GetRawType (T) == T_TYPE_DOUBLE); + return (GetRawTypeRank (T) == T_RANK_DOUBLE); } #else -# define IsTypeDouble(T) (GetRawType (T) == T_TYPE_DOUBLE) +# define IsTypeDouble(T) (GetRawTypeRank (T) == T_RANK_DOUBLE) #endif #if defined(HAVE_INLINE) INLINE int IsTypePtr (const Type* T) /* Return true if this is a pointer type */ { - return (GetRawType (T) == T_TYPE_PTR); + return (GetRawTypeRank (T) == T_RANK_PTR); } #else -# define IsTypePtr(T) (GetRawType (T) == T_TYPE_PTR) +# define IsTypePtr(T) (GetRawTypeRank (T) == T_RANK_PTR) #endif #if defined(HAVE_INLINE) INLINE int IsTypeEnum (const Type* T) /* Return true if this is an enum type */ { - return (GetRawType (T) == T_TYPE_ENUM); + return (GetRawTypeRank (T) == T_RANK_ENUM); } #else -# define IsTypeEnum(T) (GetRawType (T) == T_TYPE_ENUM) +# define IsTypeEnum(T) (GetRawTypeRank (T) == T_RANK_ENUM) #endif #if defined(HAVE_INLINE) INLINE int IsTypeSignedBitField (const Type* T) /* Return true if this is a signed bit-field */ { - return (UnqualifiedType (T->C) == T_SBITFIELD); + return (GetUnqualRawTypeCode (T) == T_SBITFIELD); } #else -# define IsTypeSignedBitField(T) (UnqualifiedType ((T)->C) == T_SBITFIELD) +# define IsTypeSignedBitField(T) (GetUnqualRawTypeCode (T) == T_SBITFIELD) #endif #if defined(HAVE_INLINE) INLINE int IsTypeUnsignedBitField (const Type* T) /* Return true if this is an unsigned bit-field */ { - return (UnqualifiedType (T->C) == T_UBITFIELD); + return (GetUnqualRawTypeCode (T) == T_UBITFIELD); } #else -# define IsTypeUnsignedBitField(T) (UnqualifiedType ((T)->C) == T_UBITFIELD) +# define IsTypeUnsignedBitField(T) (GetUnqualRawTypeCode (T) == T_UBITFIELD) #endif #if defined(HAVE_INLINE) @@ -653,55 +634,55 @@ int IsTypeFragBitField (const Type* T); INLINE int IsTypeStruct (const Type* T) /* Return true if this is a struct type */ { - return (GetRawType (T) == T_TYPE_STRUCT); + return (GetRawTypeRank (T) == T_RANK_STRUCT); } #else -# define IsTypeStruct(T) (GetRawType (T) == T_TYPE_STRUCT) +# define IsTypeStruct(T) (GetRawTypeRank (T) == T_RANK_STRUCT) #endif #if defined(HAVE_INLINE) INLINE int IsTypeUnion (const Type* T) /* Return true if this is a union type */ { - return (GetRawType (T) == T_TYPE_UNION); + return (GetRawTypeRank (T) == T_RANK_UNION); } #else -# define IsTypeUnion(T) (GetRawType (T) == T_TYPE_UNION) +# define IsTypeUnion(T) (GetRawTypeRank (T) == T_RANK_UNION) #endif #if defined(HAVE_INLINE) INLINE int IsTypeArray (const Type* T) /* Return true if this is an array type */ { - return (GetRawType (T) == T_TYPE_ARRAY); + return (GetRawTypeRank (T) == T_RANK_ARRAY); } #else -# define IsTypeArray(T) (GetRawType (T) == T_TYPE_ARRAY) +# define IsTypeArray(T) (GetRawTypeRank (T) == T_RANK_ARRAY) #endif #if defined(HAVE_INLINE) INLINE int IsTypeVoid (const Type* T) /* Return true if this is a void type */ { - return (GetRawType (T) == T_TYPE_VOID); + return (GetRawTypeRank (T) == T_RANK_VOID); } #else -# define IsTypeVoid(T) (GetRawType (T) == T_TYPE_VOID) +# define IsTypeVoid(T) (GetRawTypeRank (T) == T_RANK_VOID) #endif #if defined(HAVE_INLINE) INLINE int IsTypeFunc (const Type* T) -/* Return true if this is a function class */ +/* Return true if this is a function type */ { - return (GetRawType (T) == T_TYPE_FUNC); + return (GetRawTypeRank (T) == T_RANK_FUNC); } #else -# define IsTypeFunc(T) (GetRawType (T) == T_TYPE_FUNC) +# define IsTypeFunc(T) (GetRawTypeRank (T) == T_RANK_FUNC) #endif #if defined(HAVE_INLINE) INLINE int IsTypeFuncPtr (const Type* T) -/* Return true if this is a function pointer */ +/* Return true if this is a function pointer type */ { return (IsTypePtr (T) && IsTypeFunc (T+1)); } @@ -713,71 +694,71 @@ INLINE int IsTypeFuncPtr (const Type* T) INLINE int IsClassInt (const Type* T) /* Return true if this is an integer type */ { - return (GetClass (T) == T_CLASS_INT); + return (GetTypeClass (T) == T_CLASS_INT); } #else -# define IsClassInt(T) (GetClass (T) == T_CLASS_INT) +# define IsClassInt(T) (GetTypeClass (T) == T_CLASS_INT) #endif #if defined(HAVE_INLINE) INLINE int IsClassFloat (const Type* T) -/* Return true if this is a float type */ +/* Return true if this is a floating type */ { - return (GetClass (T) == T_CLASS_FLOAT); + return (GetTypeClass (T) == T_CLASS_FLOAT); } #else -# define IsClassFloat(T) (GetClass (T) == T_CLASS_FLOAT) +# define IsClassFloat(T) (GetTypeClass (T) == T_CLASS_FLOAT) #endif #if defined(HAVE_INLINE) INLINE int IsClassPtr (const Type* T) -/* Return true if this is a pointer type */ +/* Return true if this is a pointer or array type */ { - return (GetClass (T) == T_CLASS_PTR); + return (GetTypeClass (T) == T_CLASS_PTR); } #else -# define IsClassPtr(T) (GetClass (T) == T_CLASS_PTR) +# define IsClassPtr(T) (GetTypeClass (T) == T_CLASS_PTR) #endif #if defined(HAVE_INLINE) INLINE int IsClassStruct (const Type* T) /* Return true if this is a struct or union type */ { - return (GetClass (T) == T_CLASS_STRUCT); + return (GetTypeClass (T) == T_CLASS_STRUCT); } #else -# define IsClassStruct(T) (GetClass (T) == T_CLASS_STRUCT) +# define IsClassStruct(T) (GetTypeClass (T) == T_CLASS_STRUCT) #endif #if defined(HAVE_INLINE) INLINE int IsClassFunc (const Type* T) /* Return true if this is a function type */ { - return (GetClass (T) == T_CLASS_FUNC); + return (GetTypeClass (T) == T_CLASS_FUNC); } #else -# define IsClassFunc(T) (GetClass (T) == T_CLASS_FUNC) +# define IsClassFunc(T) (GetTypeClass (T) == T_CLASS_FUNC) #endif -int IsClassObject (const Type* T); +int IsObjectType (const Type* T); /* Return true if this is a fully described object type */ -int IsClassIncomplete (const Type* T); +int IsIncompleteType (const Type* T); /* Return true if this is an object type lacking size info */ -int IsClassArithmetic (const Type* T); -/* Return true if this is an integer or real floating type */ +int IsArithmeticType (const Type* T); +/* Return true if this is an integer or floating type */ -int IsClassBasic (const Type* T); +int IsBasicType (const Type* T); /* Return true if this is a char, integer or floating type */ -int IsClassScalar (const Type* T); +int IsScalarType (const Type* T); /* Return true if this is an arithmetic or pointer type */ -int IsClassDerived (const Type* T); +int IsDerivedType (const Type* T); /* Return true if this is an array, struct, union, function or pointer type */ -int IsClassAggregate (const Type* T); +int IsAggregateType (const Type* T); /* Return true if this is an array or struct type */ int IsRelationType (const Type* T); @@ -798,7 +779,7 @@ int IsEmptiableObjectType (const Type* T); int HasUnknownSize (const Type* T); /* Return true if this is an incomplete ESU type or an array of unknown size */ -int TypeHasAttr (const Type* T); +int TypeHasAttrData (const Type* T); /* Return true if the given type has attribute data */ #if defined(HAVE_INLINE) @@ -978,10 +959,10 @@ FuncDesc* GetFuncDesc (const Type* T) attribute ((const)); void SetFuncDesc (Type* T, FuncDesc* F); /* Set the FuncDesc pointer in a function or pointer-to-function type */ -const Type* GetFuncReturn (const Type* T) attribute ((const)); +const Type* GetFuncReturnType (const Type* T) attribute ((const)); /* Return a pointer to the return type of a function or pointer-to-function type */ -Type* GetFuncReturnModifiable (Type* T) attribute ((const)); +Type* GetFuncReturnTypeModifiable (Type* T) attribute ((const)); /* Return a non-const pointer to the return type of a function or pointer-to-function type */ const FuncDesc* GetFuncDefinitionDesc (const Type* T) attribute ((const)); @@ -1006,7 +987,10 @@ void SetElementCount (Type* T, long Count); */ const Type* GetElementType (const Type* T); -/* Return the element type of the given array type. */ +/* Return the element type of the given array type */ + +Type* GetElementTypeModifiable (Type* T); +/* Return the element type of the given array type */ const Type* GetBaseElementType (const Type* T); /* Return the base element type of a given type. If T is not an array, this diff --git a/src/cc65/declare.c b/src/cc65/declare.c index 459ffa103..59eb555c4 100644 --- a/src/cc65/declare.c +++ b/src/cc65/declare.c @@ -406,7 +406,7 @@ static void FixQualifiers (Type* DataType) if (IsTypeArray (T)) { /* Extract any type qualifiers */ Q |= GetQualifier (T); - T->C = UnqualifiedType (T->C); + T->C = GetUnqualRawTypeCode (T); } else { /* Add extracted type qualifiers here */ T->C |= Q; @@ -646,7 +646,7 @@ static SymEntry* ParseEnumSpec (const char* Name, unsigned* DSFlags) /* Enumerate by adding one to the previous value */ EnumVal = (long)(((unsigned long)EnumVal + 1UL) & 0xFFFFFFFFUL); - if (UnqualifiedType (MemberType->C) == T_ULONG && EnumVal == 0) { + if (GetUnqualRawTypeCode (MemberType) == T_ULONG && EnumVal == 0) { /* Error since the new value cannot be represented in the ** largest unsigned integer type supported by cc65 for enum. */ @@ -688,7 +688,7 @@ static SymEntry* ParseEnumSpec (const char* Name, unsigned* DSFlags) if (PrevErrorCount == ErrorCount && IsIncremented && (!IsSigned || EnumVal >= 0) && - NewType->C != UnqualifiedType (MemberType->C)) { + NewType->C != GetUnqualRawTypeCode (MemberType)) { /* The possible overflow here can only be when EnumVal > 0 */ Warning ("Enumerator '%s' (value = %lu) implies type '%s'", Ident, @@ -959,7 +959,7 @@ static SymEntry* ParseUnionSpec (const char* Name, unsigned* DSFlags) } /* Check for incomplete types including 'void' */ - if (IsClassIncomplete (Decl.Type)) { + if (IsIncompleteType (Decl.Type)) { Error ("Field '%s' has incomplete type '%s'", Decl.Ident, GetFullTypeName (Decl.Type)); @@ -1159,7 +1159,7 @@ static SymEntry* ParseStructSpec (const char* Name, unsigned* DSFlags) } /* Check for incomplete types including 'void' */ - if (IsClassIncomplete (Decl.Type)) { + if (IsIncompleteType (Decl.Type)) { Error ("Field '%s' has incomplete type '%s'", Decl.Ident, GetFullTypeName (Decl.Type)); @@ -2036,7 +2036,7 @@ void ParseDecl (const DeclSpec* Spec, Declarator* D, declmode_t Mode) if (IsTypeFunc (D->Type) || IsTypeFuncPtr (D->Type)) { /* A function. Check the return type */ - Type* RetType = GetFuncReturnModifiable (D->Type); + Type* RetType = GetFuncReturnTypeModifiable (D->Type); /* Functions may not return functions or arrays */ if (IsTypeFunc (RetType)) { @@ -2048,13 +2048,13 @@ void ParseDecl (const DeclSpec* Spec, Declarator* D, declmode_t Mode) /* The return type must not be qualified */ if (GetQualifier (RetType) != T_QUAL_NONE && RetType[1].C == T_END) { - if (GetRawType (RetType) == T_TYPE_VOID) { + if (GetRawTypeRank (RetType) == T_RANK_VOID) { /* A qualified void type is always an error */ Error ("function definition has qualified void return type"); } else { /* For others, qualifiers are ignored */ Warning ("type qualifiers ignored on function return type"); - RetType[0].C = UnqualifiedType (RetType[0].C); + RetType[0].C = GetUnqualRawTypeCode (RetType); } } diff --git a/src/cc65/expr.c b/src/cc65/expr.c index 78a4c516a..691010b0a 100644 --- a/src/cc65/expr.c +++ b/src/cc65/expr.c @@ -128,7 +128,7 @@ unsigned TypeOf (const Type* T) { unsigned NewType; - switch (GetUnderlyingTypeCode (T)) { + switch (GetUnqualTypeCode (T)) { case T_SCHAR: return CF_CHAR; @@ -187,7 +187,7 @@ unsigned TypeOf (const Type* T) unsigned FuncTypeOf (const Type* T) /* Get the code generator flag for calling the function */ { - if (GetUnderlyingTypeCode (T) == T_FUNC) { + if (GetUnqualTypeCode (T) == T_FUNC) { return (T->A.F->Flags & FD_VARIADIC) ? 0 : CF_FIXARGC; } else { Error ("Illegal function type %04lX", T->C); @@ -290,7 +290,7 @@ static unsigned typeadjust (ExprDesc* lhs, const ExprDesc* rhs, int NoPush) void LimitExprValue (ExprDesc* Expr, int WarnOverflow) /* Limit the constant value of the expression to the range of its type */ { - switch (GetUnderlyingTypeCode (Expr->Type)) { + switch (GetUnqualTypeCode (Expr->Type)) { case T_INT: case T_SHORT: if (WarnOverflow && ((Expr->IVal < -0x8000) || (Expr->IVal > 0x7FFF))) { @@ -1146,7 +1146,7 @@ static void FunctionCall (ExprDesc* Expr) /* The function result is an rvalue in the primary register */ ED_FinalizeRValLoad (Expr); - ReturnType = GetFuncReturn (Expr->Type); + ReturnType = GetFuncReturnType (Expr->Type); /* Handle struct/union specially */ if (IsClassStruct (ReturnType)) { @@ -2568,7 +2568,7 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */ } /* Determine the type of the operation. */ - if (IsTypeChar (Expr->Type) && rconst && (!LeftSigned || RightSigned)) { + if (IsRankChar (Expr->Type) && rconst && (!LeftSigned || RightSigned)) { /* Left side is unsigned char, right side is constant. ** Determine the minimum and maximum values @@ -2651,7 +2651,7 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */ flags |= CF_UNSIGNED; } - } else if (IsTypeChar (Expr->Type) && IsTypeChar (Expr2.Type) && + } else if (IsRankChar (Expr->Type) && IsRankChar (Expr2.Type) && GetSignedness (Expr->Type) == GetSignedness (Expr2.Type)) { /* Both are chars with the same signedness. We can encode the diff --git a/src/cc65/function.c b/src/cc65/function.c index 737b068a3..39f04843f 100644 --- a/src/cc65/function.c +++ b/src/cc65/function.c @@ -81,7 +81,7 @@ static Function* NewFunction (struct SymEntry* Sym, FuncDesc* D) /* Initialize the fields */ F->FuncEntry = Sym; - F->ReturnType = GetFuncReturn (Sym->Type); + F->ReturnType = GetFuncReturnType (Sym->Type); F->Desc = D; F->Reserved = 0; F->RetLab = 0; @@ -540,7 +540,7 @@ void NewFunc (SymEntry* Func, FuncDesc* D) /* Determine if this is a main function in a C99 environment that ** returns an int. */ - if (IsRawTypeInt (F_GetReturnType (CurrentFunc)) && + if (GetUnqualRawTypeCode (ReturnType) == T_INT && IS_Get (&Standard) == STD_C99) { C99MainFunc = 1; } diff --git a/src/cc65/initdata.c b/src/cc65/initdata.c index 2b151e59e..619fe4897 100644 --- a/src/cc65/initdata.c +++ b/src/cc65/initdata.c @@ -330,12 +330,12 @@ static unsigned ParseArrayInit (Type* T, int* Braces, int AllowFlexibleMembers) int HasCurly = 0; /* Get the array data */ - Type* ElementType = IndirectModifiable (T); + Type* ElementType = GetElementTypeModifiable (T); unsigned ElementSize = SizeOf (ElementType); long ElementCount = GetElementCount (T); /* Special handling for a character array initialized by a literal */ - if (IsClassChar (ElementType) && + if (IsDeclRankChar (ElementType) && (CurTok.Tok == TOK_SCONST || CurTok.Tok == TOK_WCSCONST || (CurTok.Tok == TOK_LCURLY && (NextTok.Tok == TOK_SCONST || NextTok.Tok == TOK_WCSCONST)))) { @@ -669,7 +669,7 @@ static unsigned ParseVoidInit (Type* T) Size = 0; do { ExprDesc Expr = NoCodeConstExpr (hie1); - switch (GetUnderlyingTypeCode (&Expr.Type[0])) { + switch (GetUnqualTypeCode (&Expr.Type[0])) { case T_SCHAR: case T_UCHAR: @@ -737,7 +737,7 @@ static unsigned ParseVoidInit (Type* T) static unsigned ParseInitInternal (Type* T, int *Braces, int AllowFlexibleMembers) /* Parse initialization of variables. Return the number of data bytes. */ { - switch (GetUnderlyingTypeCode (T)) { + switch (GetUnqualTypeCode (T)) { case T_SCHAR: case T_UCHAR: diff --git a/src/cc65/stdfunc.c b/src/cc65/stdfunc.c index fc19ce7f0..d22c73dcf 100644 --- a/src/cc65/stdfunc.c +++ b/src/cc65/stdfunc.c @@ -531,7 +531,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* The function result is an rvalue in the primary register */ ED_FinalizeRValLoad (Expr); - Expr->Type = GetFuncReturn (Expr->Type); + Expr->Type = GetFuncReturnType (Expr->Type); /* Bail out, no need for further processing */ goto ExitPoint; @@ -540,7 +540,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* The function result is an rvalue in the primary register */ ED_FinalizeRValLoad (Expr); - Expr->Type = GetFuncReturn (Expr->Type); + Expr->Type = GetFuncReturnType (Expr->Type); ExitPoint: /* We expect the closing brace */ @@ -757,7 +757,7 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* The function result is an rvalue in the primary register */ ED_FinalizeRValLoad (Expr); - Expr->Type = GetFuncReturn (Expr->Type); + Expr->Type = GetFuncReturnType (Expr->Type); /* Bail out, no need for further processing */ goto ExitPoint; @@ -766,7 +766,7 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* The function result is an rvalue in the primary register */ ED_FinalizeRValLoad (Expr); - Expr->Type = GetFuncReturn (Expr->Type); + Expr->Type = GetFuncReturnType (Expr->Type); ExitPoint: /* We expect the closing brace */ @@ -968,7 +968,7 @@ static void StdFunc_strcmp (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* The function result is an rvalue in the primary register */ ED_FinalizeRValLoad (Expr); - Expr->Type = GetFuncReturn (Expr->Type); + Expr->Type = GetFuncReturnType (Expr->Type); /* We expect the closing brace */ ConsumeRParen (); @@ -1165,7 +1165,7 @@ static void StdFunc_strcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* The function result is an rvalue in the primary register */ ED_FinalizeRValLoad (Expr); - Expr->Type = GetFuncReturn (Expr->Type); + Expr->Type = GetFuncReturnType (Expr->Type); ExitPoint: /* We expect the closing brace */ diff --git a/src/cc65/swstmt.c b/src/cc65/swstmt.c index 00555ffc3..0466ddf4a 100644 --- a/src/cc65/swstmt.c +++ b/src/cc65/swstmt.c @@ -133,7 +133,7 @@ void SwitchStatement (void) /* Setup the control structure, save the old and activate the new one */ SwitchData.Nodes = NewCollection (); - SwitchData.ExprType = GetUnderlyingTypeCode (&SwitchExpr.Type[0]); + SwitchData.ExprType = GetUnqualTypeCode (&SwitchExpr.Type[0]); SwitchData.Depth = SizeOf (SwitchExpr.Type); SwitchData.DefaultLabel = 0; OldSwitch = Switch; diff --git a/src/cc65/symtab.c b/src/cc65/symtab.c index 961f36046..72a2ac007 100644 --- a/src/cc65/symtab.c +++ b/src/cc65/symtab.c @@ -1007,7 +1007,7 @@ SymEntry* AddBitField (const char* Name, const Type* T, unsigned Offs, Entry = NewSymEntry (Name, SC_BITFIELD); /* Set the symbol attributes. Bit-fields are always integral types. */ - Entry->Type = NewBitFieldType (T, BitOffs, BitWidth); + Entry->Type = NewBitFieldOf (T, BitOffs, BitWidth); Entry->V.Offs = Offs; if (!SignednessSpecified) { @@ -1019,7 +1019,7 @@ SymEntry* AddBitField (const char* Name, const Type* T, unsigned Offs, ** `char -> unsigned char` adjustment that is performed with other integral types. */ CHECK ((Entry->Type->C & T_MASK_SIGN) == T_SIGN_SIGNED || - IsTypeChar (Entry->Type)); + IsRankChar (Entry->Type)); Entry->Type[0].C &= ~T_MASK_SIGN; Entry->Type[0].C |= T_SIGN_UNSIGNED; Entry->Type[1].C &= ~T_MASK_SIGN; diff --git a/src/cc65/typecmp.c b/src/cc65/typecmp.c index 1a108159f..c3239652f 100644 --- a/src/cc65/typecmp.c +++ b/src/cc65/typecmp.c @@ -244,7 +244,7 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) SymEntry* Sym2; FuncDesc* F1; FuncDesc* F2; - TypeCode LeftType, RightType; + TypeCode LeftRank, RightRank; long LeftCount, RightCount; @@ -262,9 +262,23 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) return; } - /* Get the left and right types */ - LeftType = (GetUnderlyingTypeCode (lhs) & T_MASK_TYPE); - RightType = (GetUnderlyingTypeCode (rhs) & T_MASK_TYPE); + /* Get the ranks of the left and right hands */ + LeftRank = (GetUnqualTypeCode (lhs) & T_MASK_RANK); + RightRank = (GetUnqualTypeCode (rhs) & T_MASK_RANK); + + /* If one side is a pointer and the other side is an array, both are + ** compatible. + */ + if (Result->Indirections == 0) { + if (LeftRank == T_RANK_PTR && RightRank == T_RANK_ARRAY) { + RightRank = T_RANK_PTR; + SetResult (Result, TC_PTR_DECAY); + } + if (LeftRank == T_RANK_ARRAY && RightRank == T_RANK_PTR) { + LeftRank = T_RANK_PTR; + SetResult (Result, TC_STRICT_COMPATIBLE); + } + } /* Bit-fields are considered compatible if they have the same ** signedness, bit-offset and bit-width. @@ -275,29 +289,14 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) lhs->A.B.Offs != rhs->A.B.Offs || lhs->A.B.Width != rhs->A.B.Width) { SetResult (Result, TC_INCOMPATIBLE); - return; } - if (LeftType != RightType) { + if (LeftRank != RightRank) { SetResult (Result, TC_STRICT_COMPATIBLE); } } - /* If one side is a pointer and the other side is an array, both are - ** compatible. - */ - if (Result->Indirections == 0) { - if (LeftType == T_TYPE_PTR && RightType == T_TYPE_ARRAY) { - RightType = T_TYPE_PTR; - SetResult (Result, TC_PTR_DECAY); - } - if (LeftType == T_TYPE_ARRAY && RightType == T_TYPE_PTR) { - LeftType = T_TYPE_PTR; - SetResult (Result, TC_STRICT_COMPATIBLE); - } - } - - /* If the underlying types are not identical, the types are incompatible */ - if (LeftType != RightType) { + /* If the ranks are different, the types are incompatible */ + if (LeftRank != RightRank) { SetResult (Result, TC_INCOMPATIBLE); return; } @@ -337,8 +336,8 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) } /* 'char' is neither 'signed char' nor 'unsigned char' */ - if ((IsISOChar (lhs) && !IsISOChar (rhs)) || - (!IsISOChar (lhs) && IsISOChar (rhs))) { + if ((IsDeclTypeChar (lhs) && !IsDeclTypeChar (rhs)) || + (!IsDeclTypeChar (lhs) && IsDeclTypeChar (rhs))) { SetResult (Result, TC_SIGN_DIFF); } @@ -350,14 +349,14 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) } /* Check for special type elements */ - switch (LeftType) { - case T_TYPE_PTR: + switch (LeftRank) { + case T_RANK_PTR: ++Result->Indirections; if (Result->Indirections == 1) { - if ((GetUnderlyingTypeCode (lhs + 1) & T_MASK_TYPE) == T_TYPE_VOID) { + if ((GetUnqualTypeCode (lhs + 1) & T_MASK_RANK) == T_RANK_VOID) { Result->F |= TCF_VOID_PTR_ON_LEFT; } - if ((GetUnderlyingTypeCode (rhs + 1) & T_MASK_TYPE) == T_TYPE_VOID) { + if ((GetUnqualTypeCode (rhs + 1) & T_MASK_RANK) == T_RANK_VOID) { Result->F |= TCF_VOID_PTR_ON_RIGHT; } } else { @@ -365,7 +364,7 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) } break; - case T_TYPE_FUNC: + case T_RANK_FUNC: /* Compare the function descriptors */ F1 = GetFuncDesc (lhs); F2 = GetFuncDesc (rhs); @@ -399,7 +398,7 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) /* Keep on and compare the return type */ break; - case T_TYPE_ARRAY: + case T_RANK_ARRAY: /* Check member count */ LeftCount = GetElementCount (lhs); RightCount = GetElementCount (rhs); @@ -420,8 +419,8 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) } break; - case T_TYPE_STRUCT: - case T_TYPE_UNION: + case T_RANK_STRUCT: + case T_RANK_UNION: /* Compare the tag types */ Sym1 = GetESUTagSym (lhs); Sym2 = GetESUTagSym (rhs); diff --git a/src/cc65/typeconv.c b/src/cc65/typeconv.c index c72b2c5eb..18a9f4dfa 100644 --- a/src/cc65/typeconv.c +++ b/src/cc65/typeconv.c @@ -430,7 +430,7 @@ void TypeComposition (Type* lhs, const Type* rhs) } /* Check for sanity */ - CHECK (GetUnderlyingTypeCode (lhs) == GetUnderlyingTypeCode (rhs)); + CHECK (GetUnqualTypeCode (lhs) == GetUnqualTypeCode (rhs)); /* Check for special type elements */ if (IsTypeFunc (lhs)) {