From 4e820677ee1b6cce52505da7ff042eb8a9520ff7 Mon Sep 17 00:00:00 2001 From: acqn Date: Mon, 1 Jan 2024 15:03:45 +0800 Subject: [PATCH 1/3] ED_AddrExpr() and ED_IndExpr() need no return values. --- src/cc65/exprdesc.c | 6 ++---- src/cc65/exprdesc.h | 4 ++-- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/src/cc65/exprdesc.c b/src/cc65/exprdesc.c index a1af0bb8b..a21e56623 100644 --- a/src/cc65/exprdesc.c +++ b/src/cc65/exprdesc.c @@ -418,7 +418,7 @@ ExprDesc* ED_FinalizeRValLoad (ExprDesc* Expr) -ExprDesc* ED_AddrExpr (ExprDesc* Expr) +void ED_AddrExpr (ExprDesc* Expr) /* Take address of Expr. The result is always an rvalue */ { switch (Expr->Flags & E_MASK_LOC) { @@ -447,12 +447,11 @@ ExprDesc* ED_AddrExpr (ExprDesc* Expr) } break; } - return Expr; } -ExprDesc* ED_IndExpr (ExprDesc* Expr) +void ED_IndExpr (ExprDesc* Expr) /* Dereference Expr */ { switch (Expr->Flags & E_MASK_LOC) { @@ -486,7 +485,6 @@ ExprDesc* ED_IndExpr (ExprDesc* Expr) } break; } - return Expr; } diff --git a/src/cc65/exprdesc.h b/src/cc65/exprdesc.h index 93a8604c9..148485764 100644 --- a/src/cc65/exprdesc.h +++ b/src/cc65/exprdesc.h @@ -637,10 +637,10 @@ INLINE void ED_MarkExprAsRVal (ExprDesc* Expr) # define ED_MarkExprAsRVal(Expr) do { (Expr)->Flags &= ~E_RTYPE_LVAL; } while (0) #endif -ExprDesc* ED_AddrExpr (ExprDesc* Expr); +void ED_AddrExpr (ExprDesc* Expr); /* Take address of Expr */ -ExprDesc* ED_IndExpr (ExprDesc* Expr); +void ED_IndExpr (ExprDesc* Expr); /* Dereference Expr */ #if defined(HAVE_INLINE) From 88246f852d73bc52e4ac37ea1927e3d9e9c70c3d Mon Sep 17 00:00:00 2001 From: acqn Date: Mon, 1 Jan 2024 15:04:50 +0800 Subject: [PATCH 2/3] Removed RefineFuncDesc() as an unnecessary wrapper. --- src/cc65/symtab.c | 2 +- src/cc65/typeconv.c | 36 ++++-------------------------------- src/cc65/typeconv.h | 3 --- 3 files changed, 5 insertions(+), 36 deletions(-) diff --git a/src/cc65/symtab.c b/src/cc65/symtab.c index 3018c910d..c2c6bab27 100644 --- a/src/cc65/symtab.c +++ b/src/cc65/symtab.c @@ -741,7 +741,7 @@ static int HandleSymRedefinition (SymEntry* Sym, const Type* T, unsigned Flags) /* Refine the existing composite prototype with this new ** one. */ - RefineFuncDesc (Sym->Type, T); + TypeComposition (Sym->Type, T); } } diff --git a/src/cc65/typeconv.c b/src/cc65/typeconv.c index 76658502d..25b693511 100644 --- a/src/cc65/typeconv.c +++ b/src/cc65/typeconv.c @@ -427,10 +427,6 @@ void TypeComposition (Type* lhs, const Type* rhs) ** type or this fails with a critical check. */ { - FuncDesc* F1; - FuncDesc* F2; - long LeftCount, RightCount; - /* Compose two types */ while (lhs->C != T_END) { @@ -445,8 +441,8 @@ void TypeComposition (Type* lhs, const Type* rhs) /* Check for special type elements */ if (IsTypeFunc (lhs)) { /* Compose the function descriptors */ - F1 = GetFuncDesc (lhs); - F2 = GetFuncDesc (rhs); + FuncDesc* F1 = GetFuncDesc (lhs); + FuncDesc* F2 = GetFuncDesc (rhs); /* If F1 has an empty parameter list (which does also mean, it is ** not a function definition, because the flag is reset in this @@ -470,8 +466,8 @@ void TypeComposition (Type* lhs, const Type* rhs) } } else if (IsTypeArray (lhs)) { /* Check member count */ - LeftCount = GetElementCount (lhs); - RightCount = GetElementCount (rhs); + long LeftCount = GetElementCount (lhs); + long RightCount = GetElementCount (rhs); /* Set composite type if it is requested */ if (LeftCount != UNSPECIFIED) { @@ -485,28 +481,4 @@ void TypeComposition (Type* lhs, const Type* rhs) ++lhs; ++rhs; } - - return; -} - - - -FuncDesc* RefineFuncDesc (Type* OldType, const Type* NewType) -/* Refine the existing function descriptor with a new one */ -{ - FuncDesc* Old = GetFuncDesc (OldType); - FuncDesc* New = GetFuncDesc (NewType); - - CHECK (Old != 0 && New != 0); - - if ((New->Flags & FD_EMPTY) == 0) { - if ((Old->Flags & FD_EMPTY) == 0) { - TypeComposition (OldType, NewType); - } else { - TypeCopy (OldType, NewType); - Old->Flags &= ~FD_EMPTY; - } - } - - return Old; } diff --git a/src/cc65/typeconv.h b/src/cc65/typeconv.h index 839c5e43e..1d79a446c 100644 --- a/src/cc65/typeconv.h +++ b/src/cc65/typeconv.h @@ -63,9 +63,6 @@ void TypeComposition (Type* lhs, const Type* rhs); ** type or this fails with a critical check. */ -FuncDesc* RefineFuncDesc (Type* OldType, const Type* NewType); -/* Refine the existing function descriptor with a new one */ - /* End of typeconv.h */ From acbd87b5764005b7798ae9b3f29c8a7b9e3eaf6b Mon Sep 17 00:00:00 2001 From: acqn Date: Mon, 1 Jan 2024 15:27:57 +0800 Subject: [PATCH 3/3] Renamed GetUnqualTypeCode() to GetUnderlyingTypeCode() for consistency with GetUnderlyingType(). --- src/cc65/datatype.c | 12 ++++++------ src/cc65/datatype.h | 14 +++++++------- src/cc65/expr.c | 6 +++--- src/cc65/initdata.c | 4 ++-- src/cc65/typecmp.c | 8 ++++---- src/cc65/typeconv.c | 2 +- 6 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/cc65/datatype.c b/src/cc65/datatype.c index 9e0652526..46f62e922 100644 --- a/src/cc65/datatype.c +++ b/src/cc65/datatype.c @@ -216,7 +216,7 @@ unsigned BitSizeOf (const Type* T) unsigned SizeOf (const Type* T) /* Compute size (in bytes) of object represented by type array */ { - switch (GetUnqualTypeCode (T)) { + switch (GetUnderlyingTypeCode (T)) { case T_VOID: /* A void variable is a cc65 extension. @@ -368,7 +368,7 @@ static unsigned GetMinimalTypeSizeByBitWidth (unsigned BitWidth) -TypeCode GetUnqualTypeCode (const Type* Type) +TypeCode GetUnderlyingTypeCode (const Type* Type) /* Get the type code of the unqualified underlying type of Type. ** Return GetUnqualRawTypeCode (Type) if Type is not scalar. */ @@ -725,7 +725,7 @@ const Type* ArithmeticConvert (const Type* lhst, const Type* rhst) const Type* GetSignedType (const Type* T) /* Get signed counterpart of the integral type */ { - switch (GetUnqualTypeCode (T) & T_MASK_RANK) { + switch (GetUnderlyingTypeCode (T) & T_MASK_RANK) { case T_RANK_CHAR: return type_schar; @@ -739,7 +739,7 @@ const Type* GetSignedType (const Type* T) return type_long; default: - Internal ("Unknown type code: %lX", GetUnqualTypeCode (T)); + Internal ("Unknown type code: %lX", GetUnderlyingTypeCode (T)); return T; } } @@ -749,7 +749,7 @@ const Type* GetSignedType (const Type* T) const Type* GetUnsignedType (const Type* T) /* Get unsigned counterpart of the integral type */ { - switch (GetUnqualTypeCode (T) & T_MASK_RANK) { + switch (GetUnderlyingTypeCode (T) & T_MASK_RANK) { case T_RANK_CHAR: return type_uchar; @@ -763,7 +763,7 @@ const Type* GetUnsignedType (const Type* T) return type_ulong; default: - Internal ("Unknown type code: %lX", GetUnqualTypeCode (T)); + Internal ("Unknown type code: %lX", GetUnderlyingTypeCode (T)); return T; } } diff --git a/src/cc65/datatype.h b/src/cc65/datatype.h index 4f4b6f25e..dbe0eedaa 100644 --- a/src/cc65/datatype.h +++ b/src/cc65/datatype.h @@ -328,7 +328,7 @@ INLINE TypeCode GetQualifier (const Type* T) # define GetQualifier(T) ((T)->C & T_MASK_QUAL) #endif -TypeCode GetUnqualTypeCode (const Type* Type); +TypeCode GetUnderlyingTypeCode (const Type* Type); /* Get the type code of the unqualified underlying type of Type. ** Return GetUnqualRawTypeCode (Type) if Type is not scalar. */ @@ -359,30 +359,30 @@ INLINE TypeCode GetTypeClass (const Type* T) INLINE TypeCode GetTypeRank (const Type* T) /* Get the type rank of a type */ { - return (GetUnqualTypeCode (T) & T_MASK_RANK); + return (GetUnderlyingTypeCode (T) & T_MASK_RANK); } #else -# define GetTypeRank(T) (GetUnqualTypeCode (T) & T_MASK_RANK) +# define GetTypeRank(T) (GetUnderlyingTypeCode (T) & T_MASK_RANK) #endif #if defined(HAVE_INLINE) INLINE TypeCode GetSignedness (const Type* T) /* Get the signedness of a type */ { - return (GetUnqualTypeCode (T) & T_MASK_SIGN); + return (GetUnderlyingTypeCode (T) & T_MASK_SIGN); } #else -# define GetSignedness(T) (GetUnqualTypeCode (T) & T_MASK_SIGN) +# define GetSignedness(T) (GetUnderlyingTypeCode (T) & T_MASK_SIGN) #endif #if defined(HAVE_INLINE) INLINE TypeCode GetSizeModifier (const Type* T) /* Get the size modifier of a type */ { - return (GetUnqualTypeCode (T) & T_MASK_SIZE); + return (GetUnderlyingTypeCode (T) & T_MASK_SIZE); } #else -# define GetSizeModifier(T) (GetUnqualTypeCode (T) & T_MASK_SIZE) +# define GetSizeModifier(T) (GetUnderlyingTypeCode (T) & T_MASK_SIZE) #endif #if defined(HAVE_INLINE) diff --git a/src/cc65/expr.c b/src/cc65/expr.c index cfddfa24e..0f3a6e110 100644 --- a/src/cc65/expr.c +++ b/src/cc65/expr.c @@ -129,7 +129,7 @@ unsigned CG_TypeOf (const Type* T) { unsigned CG_Type; - switch (GetUnqualTypeCode (T)) { + switch (GetUnderlyingTypeCode (T)) { case T_SCHAR: return CF_CHAR; @@ -188,7 +188,7 @@ unsigned CG_TypeOf (const Type* T) unsigned CG_CallFlags (const Type* T) /* Get the code generator flags for calling the function */ { - if (GetUnqualTypeCode (T) == T_FUNC) { + if (GetUnderlyingTypeCode (T) == T_FUNC) { return (T->A.F->Flags & FD_VARIADIC) ? 0 : CF_FIXARGC; } else { Error ("Illegal function type %04lX", T->C); @@ -291,7 +291,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 (GetUnqualTypeCode (Expr->Type)) { + switch (GetUnderlyingTypeCode (Expr->Type)) { case T_INT: case T_SHORT: if (WarnOverflow && ((Expr->IVal < -0x8000) || (Expr->IVal > 0x7FFF))) { diff --git a/src/cc65/initdata.c b/src/cc65/initdata.c index 5401e577c..82cebefc2 100644 --- a/src/cc65/initdata.c +++ b/src/cc65/initdata.c @@ -679,7 +679,7 @@ static unsigned ParseVoidInit (Type* T) Size = 0; do { ExprDesc Expr = NoCodeConstExpr (hie1); - switch (GetUnqualTypeCode (&Expr.Type[0])) { + switch (GetUnderlyingTypeCode (&Expr.Type[0])) { case T_SCHAR: case T_UCHAR: @@ -747,7 +747,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 (GetUnqualTypeCode (T)) { + switch (GetUnderlyingTypeCode (T)) { case T_SCHAR: case T_UCHAR: diff --git a/src/cc65/typecmp.c b/src/cc65/typecmp.c index e8b790a69..a09c80304 100644 --- a/src/cc65/typecmp.c +++ b/src/cc65/typecmp.c @@ -259,8 +259,8 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) } /* Get the ranks of the left and right hands */ - LeftRank = (GetUnqualTypeCode (lhs) & T_MASK_RANK); - RightRank = (GetUnqualTypeCode (rhs) & T_MASK_RANK); + LeftRank = (GetUnderlyingTypeCode (lhs) & T_MASK_RANK); + RightRank = (GetUnderlyingTypeCode (rhs) & T_MASK_RANK); /* Bit-fields are considered compatible if they have the same ** signedness, bit-offset and bit-width. @@ -344,10 +344,10 @@ static void DoCompare (const Type* lhs, const Type* rhs, typecmp_t* Result) case T_RANK_PTR: ++Result->Indirections; if (Result->Indirections == 1) { - if ((GetUnqualTypeCode (lhs + 1) & T_MASK_RANK) == T_RANK_VOID) { + if ((GetUnderlyingTypeCode (lhs + 1) & T_MASK_RANK) == T_RANK_VOID) { Result->F |= TCF_VOID_PTR_ON_LEFT; } - if ((GetUnqualTypeCode (rhs + 1) & T_MASK_RANK) == T_RANK_VOID) { + if ((GetUnderlyingTypeCode (rhs + 1) & T_MASK_RANK) == T_RANK_VOID) { Result->F |= TCF_VOID_PTR_ON_RIGHT; } } else { diff --git a/src/cc65/typeconv.c b/src/cc65/typeconv.c index 25b693511..6e9fad69a 100644 --- a/src/cc65/typeconv.c +++ b/src/cc65/typeconv.c @@ -436,7 +436,7 @@ void TypeComposition (Type* lhs, const Type* rhs) } /* Check for sanity */ - CHECK (GetUnqualTypeCode (lhs) == GetUnqualTypeCode (rhs)); + CHECK (GetUnderlyingTypeCode (lhs) == GetUnderlyingTypeCode (rhs)); /* Check for special type elements */ if (IsTypeFunc (lhs)) {