cc65/src/cc65/datatype.c

/*****************************************************************************/
/*                                                                           */
/*                                datatype.c                                 */
/*                                                                           */
/*               Type string handling for the cc65 C compiler                */
/*                                                                           */
/*                                                                           */
/*                                                                           */
/* (C) 1998-2015, Ullrich von Bassewitz                                      */
/*                Roemerstrasse 52                                           */
/*                D-70794 Filderstadt                                        */
/* EMail:         uz@cc65.org                                                */
/*                                                                           */
/*                                                                           */
/* This software is provided 'as-is', without any expressed or implied       */
/* warranty.  In no event will the authors be held liable for any damages    */
/* arising from the use of this software.                                    */
/*                                                                           */
/* Permission is granted to anyone to use this software for any purpose,     */
/* including commercial applications, and to alter it and redistribute it    */
/* freely, subject to the following restrictions:                            */
/*                                                                           */
/* 1. The origin of this software must not be misrepresented; you must not   */
/*    claim that you wrote the original software. If you use this software   */
/*    in a product, an acknowledgment in the product documentation would be  */
/*    appreciated but is not required.                                       */
/* 2. Altered source versions must be plainly marked as such, and must not   */
/*    be misrepresented as being the original software.                      */
/* 3. This notice may not be removed or altered from any source              */
/*    distribution.                                                          */
/*                                                                           */
/*****************************************************************************/



#include <string.h>

/* common */
#include "addrsize.h"
#include "check.h"
#include "mmodel.h"
#include "xmalloc.h"

/* cc65 */
#include "codegen.h"
#include "datatype.h"
#include "error.h"
#include "fp.h"
#include "funcdesc.h"
#include "global.h"
#include "symtab.h"



/*****************************************************************************/
/*                                   Data                                    */
/*****************************************************************************/



/* Predefined type strings */
const Type type_char[]      = { TYPE(T_CHAR),   TYPE(T_END) };
const Type type_schar[]     = { TYPE(T_SCHAR),  TYPE(T_END) };
const Type type_uchar[]     = { TYPE(T_UCHAR),  TYPE(T_END) };
const Type type_int[]       = { TYPE(T_INT),    TYPE(T_END) };
const Type type_uint[]      = { TYPE(T_UINT),   TYPE(T_END) };
const Type type_long[]      = { TYPE(T_LONG),   TYPE(T_END) };
const Type type_ulong[]     = { TYPE(T_ULONG),  TYPE(T_END) };
const Type type_bool[]      = { TYPE(T_INT),    TYPE(T_END) };
const Type type_void[]      = { TYPE(T_VOID),   TYPE(T_END) };
const Type type_size_t[]    = { TYPE(T_SIZE_T), TYPE(T_END) };
const Type type_float[]     = { TYPE(T_FLOAT),  TYPE(T_END) };
const Type type_double[]    = { TYPE(T_DOUBLE), TYPE(T_END) };

/* More predefined type strings */
const Type type_char_p[]    = { TYPE(T_PTR),    TYPE(T_CHAR),   TYPE(T_END) };
const Type type_c_char_p[]  = { TYPE(T_PTR),    TYPE(T_C_CHAR), TYPE(T_END) };
const Type type_void_p[]    = { TYPE(T_PTR),    TYPE(T_VOID),   TYPE(T_END) };
const Type type_c_void_p[]  = { TYPE(T_PTR),    TYPE(T_C_VOID), TYPE(T_END) };



/*****************************************************************************/
/*                                   Code                                    */
/*****************************************************************************/



static struct StrBuf* GetFullTypeNameWestEast (struct StrBuf* West, struct StrBuf* East, const Type* T)
/* Return the name string of the given type split into a western part and an
** eastern part.
*/
{
    struct StrBuf Buf = AUTO_STRBUF_INITIALIZER;

    if (IsTypeArray (T)) {

        long Count = GetElementCount (T);
        if (!SB_IsEmpty (East)) {
            if (Count > 0) {
                SB_Printf (&Buf, "[%ld]", Count);
            } else {
                SB_Printf (&Buf, "[]");
            }
            SB_Append (East, &Buf);
            SB_Terminate (East);

        } else {
            if (Count > 0) {
                SB_Printf (East, "[%ld]", Count);
            } else {
                SB_Printf (East, "[]");
            }

            if (!SB_IsEmpty (West)) {
                /* Add parentheses to West */
                SB_Printf (&Buf, "(%s)", SB_GetConstBuf (West));
                SB_Copy (West, &Buf);
                SB_Terminate (West);
            }
        }

        /* Get element type */
        GetFullTypeNameWestEast (West, East, T + 1);

    } else if (IsTypeFunc (T)) {

        FuncDesc* D             = GetFuncDesc (T);
        struct StrBuf ParamList = AUTO_STRBUF_INITIALIZER;

        /* First argument */
        SymEntry* Param = D->SymTab->SymHead;
        unsigned I;
        for (I = 0; I < D->ParamCount; ++I) {
            CHECK (Param != 0 && (Param->Flags & SC_PARAM) != 0);
            if (I > 0) {
                SB_AppendStr (&ParamList, ", ");
            }
            SB_AppendStr (&ParamList, SB_GetConstBuf (GetFullTypeNameBuf (&Buf, Param->Type)));
            SB_Clear (&Buf);
            /* Next argument */
            Param = Param->NextSym;
        }
        if ((D->Flags & FD_VARIADIC) == 0) {
            if (D->ParamCount == 0 && (D->Flags & FD_EMPTY) == 0) {
                SB_AppendStr (&ParamList, "void");
            }
        } else {
            if (D->ParamCount > 0) {
                SB_AppendStr (&ParamList, ", ...");
            } else {
                SB_AppendStr (&ParamList, "...");
            }
        }
        SB_Terminate (&ParamList);

        /* Join the existing West and East together */
        if (!SB_IsEmpty (East)) {
            SB_Append (West, East);
            SB_Terminate (West);
            SB_Clear (East);
        }

        if (SB_IsEmpty (West)) {
            /* Just use the param list */
            SB_Printf (West, "(%s)", SB_GetConstBuf (&ParamList));
        } else {
            /* Append the param list to the existing West */
            SB_Printf (&Buf, "(%s)(%s)", SB_GetConstBuf (West), SB_GetConstBuf (&ParamList));
            SB_Printf (West, "%s", SB_GetConstBuf (&Buf));
        }
        SB_Done (&ParamList);

        /* Return type */
        GetFullTypeNameWestEast (West, East, T + 1);

    } else if (IsTypePtr (T)) {

        int QualCount = 0;

        SB_Printf (&Buf, "*");

        /* Add qualifiers */
        if ((GetQualifier (T) & ~T_QUAL_NEAR) != T_QUAL_NONE) {
            QualCount = GetQualifierTypeCodeNameBuf (&Buf, T->C, T_QUAL_NEAR);
        }

        if (!SB_IsEmpty (West)) {
            if (QualCount > 0) {
                SB_AppendChar (&Buf, ' ');
            }
            SB_Append (&Buf, West);
        }

        SB_Copy (West, &Buf);
        SB_Terminate (West);

        /* Get indirection type */
        GetFullTypeNameWestEast (West, East, T + 1);

    } else {

        /* Add qualifiers */
        if ((GetQualifier (T) & ~T_QUAL_NEAR) != 0) {
            if (GetQualifierTypeCodeNameBuf (&Buf, T->C, T_QUAL_NEAR) > 0) {
                SB_AppendChar (&Buf, ' ');
            }
        }

        if (!IsTypeBitField (T)) {
            SB_AppendStr (&Buf, GetSymTypeName (T));
        } else {
            SB_AppendStr (&Buf, GetBasicTypeName (T + 1));
        }

        if (!SB_IsEmpty (West)) {
            SB_AppendChar (&Buf, ' ');
            SB_Append (&Buf, West);
        }

        SB_Copy (West, &Buf);
        SB_Terminate (West);
    }

    SB_Done (&Buf);
    return West;
}



const char* GetBasicTypeName (const Type* T)
/* Return a const name string of the basic type.
** 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 */
    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";
            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";
            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";
            default:
                return "integer";
            }
        }
    }
    return "type";
}



const char* GetFullTypeName (const Type* T)
/* Return the full name string of the given type */
{
    struct StrBuf* Buf = NewDiagnosticStrBuf ();
    GetFullTypeNameBuf (Buf, T);

    return SB_GetConstBuf (Buf);
}



struct StrBuf* GetFullTypeNameBuf (struct StrBuf* S, const Type* T)
/* Return the full name string of the given type */
{
    struct StrBuf East = AUTO_STRBUF_INITIALIZER;
    GetFullTypeNameWestEast (S, &East, T);

    /* Join West and East */
    SB_Append (S, &East);
    SB_Terminate (S);
    SB_Done (&East);

    return S;
}



int GetQualifierTypeCodeNameBuf (struct StrBuf* S, TypeCode Qual, TypeCode IgnoredQual)
/* Return the names of the qualifiers of the type.
** Qualifiers to be ignored can be specified with the IgnoredQual flags.
** Return the count of added qualifier names.
*/
{
    int Count = 0;

    Qual &= T_MASK_QUAL & ~IgnoredQual;
    if (Qual & T_QUAL_CONST) {
        if (!SB_IsEmpty (S)) {
            SB_AppendChar (S, ' ');
        }
        SB_AppendStr (S, "const");
        ++Count;
    }
    if (Qual & T_QUAL_VOLATILE) {
        if (Count > 0) {
            SB_AppendChar (S, ' ');
        }
        SB_AppendStr (S, "volatile");
        ++Count;
    }
    if (Qual & T_QUAL_RESTRICT) {
        if (Count > 0) {
            SB_AppendChar (S, ' ');
        }
        SB_AppendStr (S, "restrict");
        ++Count;
    }
    if (Qual & T_QUAL_NEAR) {
        if (Count > 0) {
            SB_AppendChar (S, ' ');
        }
        SB_AppendStr (S, "__near__");
        ++Count;
    }
    if (Qual & T_QUAL_FAR) {
        SB_AppendStr (S, "__far__");
        ++Count;
    }
    if (Qual & T_QUAL_FASTCALL) {
        if (Count > 0) {
            SB_AppendChar (S, ' ');
        }
        SB_AppendStr (S, "__fastcall__");
        ++Count;
    }
    if (Qual & T_QUAL_CDECL) {
        if (Count > 0) {
            SB_AppendChar (S, ' ');
        }
        SB_AppendStr (S, "__cdecl__");
        ++Count;
    }

    if (Count > 0) {
        SB_Terminate (S);
    }

    return Count;
}



unsigned TypeLen (const Type* T)
/* Return the length of the type string */
{
    const Type* Start = T;
    while (T->C != T_END) {
        ++T;
    }
    return T - Start;
}



Type* TypeCopy (Type* Dest, const Type* Src)
/* Copy a type string */
{
    Type* Orig = Dest;
    while (1) {
        *Dest = *Src;
        if (Src->C == T_END) {
            break;
        }
        Src++;
        Dest++;
    }
    return Orig;
}



Type* TypeDup (const Type* T)
/* Create a copy of the given type on the heap */
{
    unsigned Len = (TypeLen (T) + 1) * sizeof (Type);
    return memcpy (xmalloc (Len), T, Len);
}



Type* TypeAlloc (unsigned Len)
/* Allocate memory for a type string of length Len. Len *must* include the
** trailing T_END.
*/
{
    return xmalloc (Len * sizeof (Type));
}



void TypeFree (Type* T)
/* Free a type string */
{
    xfree (T);
}



int SignExtendChar (int C)
/* Do correct sign extension of a character */
{
    if (IS_Get (&SignedChars) && (C & 0x80) != 0) {
        return C | ~0xFF;
    } else {
        return C & 0xFF;
    }
}



Type* GetCharArrayType (unsigned Len)
/* Return the type for a char array of the given length */
{
    /* Allocate memory for the type string */
    Type* T = TypeAlloc (3);    /* array/char/terminator */

    /* Fill the type string */
    T[0].C   = T_ARRAY;
    T[0].A.L = Len;             /* Array length is in the L attribute */
    T[1].C   = T_CHAR;
    T[2].C   = T_END;

    /* Return the new type */
    return T;
}



Type* GetImplicitFuncType (void)
/* Return a type string for an inplicitly declared function */
{
    /* Get a new function descriptor */
    FuncDesc* F = NewFuncDesc ();

    /* Allocate memory for the type string */
    Type* T = TypeAlloc (3);    /* func/returns int/terminator */

    /* Prepare the function descriptor */
    F->Flags  = FD_EMPTY;
    F->SymTab = &EmptySymTab;
    F->TagTab = &EmptySymTab;

    /* Fill the type string */
    T[0].C   = T_FUNC | CodeAddrSizeQualifier ();
    T[0].A.F = F;
    T[1].C   = T_INT;
    T[2].C   = T_END;

    /* Return the new type */
    return T;
}



const Type* GetStructReplacementType (const Type* SType)
/* Get a replacement type for passing a struct/union in the primary register */
{
    const Type* NewType;
    /* If the size is less than or equal to that of a long, we will copy the
    ** struct using the primary register, otherwise we will use memcpy.
    */
    switch (SizeOf (SType)) {
        case 1:     NewType = type_uchar;   break;
        case 2:     NewType = type_uint;    break;
        case 3:     /* FALLTHROUGH */
        case 4:     NewType = type_ulong;   break;
        default:    NewType = SType;        break;
    }

    return NewType;
}



long GetIntegerTypeMin (const Type* Type)
/* Get the smallest possible value of the integer type.
** The type must have a known size.
*/
{
    if (SizeOf (Type) == 0) {
        Internal ("Incomplete type used in GetIntegerTypeMin");
    }

    if (IsSignSigned (Type)) {
        /* The smallest possible signed value of N-byte integer is -pow(2, 8*N-1) */
        return (long)((unsigned long)(-1L) << (CHAR_BITS * SizeOf (Type) - 1U));
    } else {
        return 0;
    }
}



unsigned long GetIntegerTypeMax (const Type* Type)
/* Get the largest possible value of the integer type.
** The type must have a known size.
*/
{
    if (SizeOf (Type) == 0) {
        Internal ("Incomplete type used in GetIntegerTypeMax");
    }

    if (IsSignSigned (Type)) {
        /* Min signed value of N-byte integer is pow(2, 8*N-1) - 1 */
        return (1UL << (CHAR_BITS * SizeOf (Type) - 1U)) - 1UL;
    } else {
        /* Max signed value of N-byte integer is pow(2, 8*N) - 1. However,
        ** workaround is needed as in ISO C it is UB if the shift count is
        ** equal to the bit width of the left operand type.
        */
        return (1UL << 1U << (CHAR_BITS * SizeOf (Type) - 1U)) - 1UL;
    }
}



static unsigned GetBitFieldMinimalTypeSize (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
    ** are powers of 2, we can just use this bit-twiddling trick.
    */
    unsigned V = (int)(BitWidth - 1U) / (int)CHAR_BITS;
    V |= V >> 1;
    V |= V >> 2;
    V |= V >> 4;
    V |= V >> 8;
    V |= V >> 16;

    /* Return the result size */
    return V + 1U;
}


static unsigned TypeOfBySize (unsigned Size)
/* Get the code generator replacement type of the object by its size */
{
    unsigned NewType;
    /* If the size is less than or equal to that of a a long, we will copy
    ** the struct using the primary register, otherwise we use memcpy.
    */
    switch (Size) {
        case 1:     NewType = CF_CHAR;  break;
        case 2:     NewType = CF_INT;   break;
        case 3:     /* FALLTHROUGH */
        case 4:     NewType = CF_LONG;  break;
        default:    NewType = CF_NONE;  break;
    }

    return NewType;
}



const Type* GetUnderlyingType (const Type* Type)
/* Get the underlying type of an enum or other integer class type */
{
    if (IsISOChar (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");
        }

        /* If incomplete enum type is used, just return its raw type */
        if (Type->A.S->V.E.Type != 0) {
            return Type->A.S->V.E.Type;
        }
    } 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)) {
            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;
            default:          Type = IsSignSigned (Type) ? type_int   : type_uint;  break;
        }
    }

    return Type;
}



TypeCode GetUnderlyingTypeCode (const Type* Type)
/* Get the type code of the unqualified underlying type of TCode.
** Return UnqualifiedType (TCode) if TCode is not scalar.
*/
{
    TypeCode Underlying = UnqualifiedType (Type->C);

    if (IsISOChar (Type)) {

        return IS_Get (&SignedChars) ? T_SCHAR : T_UCHAR;

    } else if (IsTypeEnum (Type)) {
        TypeCode TCode;

        /* This should not happen, but just in case */
        if (Type->A.S == 0) {
            Internal ("Enum tag type error in GetUnderlyingTypeCode");
        }

        /* Inspect the underlying type of the enum */
        if (Type->A.S->V.E.Type == 0) {
            /* Incomplete enum type is used */
            return Underlying;
        }
        TCode = UnqualifiedType (Type->A.S->V.E.Type->C);

        /* Replace the type code with integer */
        Underlying = (TCode & ~T_MASK_TYPE);
        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;
        }
    } 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)) {
            case SIZEOF_CHAR:     Underlying = T_CHAR;      break;
            case SIZEOF_INT:      Underlying = T_INT;       break;
            case SIZEOF_LONG:     Underlying = T_LONG;      break;
            case SIZEOF_LONGLONG: Underlying = T_LONGLONG;  break;
            default:              Underlying = T_INT;       break;
        }
        Underlying &= ~T_MASK_SIGN;
        Underlying |= Type->C & T_MASK_SIGN;
    }

    return Underlying;
}



const Type* GetBitFieldChunkType (const Type* Type)
/* Get the type needed to operate on the byte chunk containing the bit-field */
{
    unsigned ChunkSize;
    if ((Type->A.B.Width - 1U) / CHAR_BITS ==
        (Type->A.B.Offs + Type->A.B.Width - 1U) / CHAR_BITS) {
        /* T bit-field fits within its underlying type */
        return GetUnderlyingType (Type);
    }

    ChunkSize = GetBitFieldMinimalTypeSize (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.
        ** Note: In cc65 the bit offset is always less than CHAR_BITS.
        */
        switch (ChunkSize) {
            case SIZEOF_CHAR: return IsSignSigned (Type) ? type_schar : type_uchar;
            case SIZEOF_INT:  return IsSignSigned (Type) ? type_int   : type_uint;
            case SIZEOF_LONG: return IsSignSigned (Type) ? type_long  : type_ulong;
            default:          return IsSignSigned (Type) ? type_int   : type_uint;
        }
    }

    /* We can always use the declarartion integer type as the chunk type.
    ** Note: A bit-field will not occupy bits located in bytes more than that
    ** of its declaration type in cc65. So this is OK.
    */
    return Type + 1;
}



unsigned SizeOf (const Type* T)
/* Compute size of object represented by type array. */
{
    switch (GetUnderlyingTypeCode (T)) {

        case T_VOID:
            /* A void variable is a cc65 extension.
            ** Get its size (in bytes).
            */
            return T->A.U;

        /* Beware: There's a chance that this triggers problems in other parts
        ** of the compiler. The solution is to fix the callers, because calling
        ** SizeOf() with a function type as argument is bad.
        */
        case T_FUNC:
            return 0;   /* Size of function is unknown */

        case T_SCHAR:
        case T_UCHAR:
            return SIZEOF_CHAR;

        case T_SHORT:
        case T_USHORT:
            return SIZEOF_SHORT;

        case T_INT:
        case T_UINT:
            return SIZEOF_INT;

        case T_PTR:
            return SIZEOF_PTR;

        case T_LONG:
        case T_ULONG:
            return SIZEOF_LONG;

        case T_LONGLONG:
        case T_ULONGLONG:
            return SIZEOF_LONGLONG;

        case T_FLOAT:
            return SIZEOF_FLOAT;

        case T_DOUBLE:
            return SIZEOF_DOUBLE;

        case T_STRUCT:
        case T_UNION:
            return T->A.S->V.S.Size;

        case T_ARRAY:
            if (T->A.L == UNSPECIFIED) {
                /* Array with unspecified size */
                return 0;
            } else {
                return T->A.U * SizeOf (T + 1);
            }

        case T_ENUM:
            /* Incomplete enum type */
            return 0;

        default:

            Internal ("Unknown type in SizeOf: %04lX", T->C);
            return 0;

    }
}



unsigned PSizeOf (const Type* T)
/* Compute size of pointer object. */
{
    /* We are expecting a pointer expression */
    CHECK (IsClassPtr (T));

    /* Skip the pointer or array token itself */
    return SizeOf (T + 1);
}



unsigned CheckedSizeOf (const Type* T)
/* Return the size of a data type. If the size is zero, emit an error and
** return some valid size instead (so the rest of the compiler doesn't have
** to work with invalid sizes).
*/
{
    unsigned Size = SizeOf (T);
    if (Size == 0) {
        if (HasUnknownSize (T + 1)) {
            Error ("Size of type '%s' is unknown", GetFullTypeName (T));
        } else {
            Error ("Size of type '%s' is 0", GetFullTypeName (T));
        }
        Size = SIZEOF_CHAR;     /* Don't return zero */
    }
    return Size;
}



unsigned CheckedPSizeOf (const Type* T)
/* Return the size of a data type that is pointed to by a pointer. If the
** size is zero, emit an error and return some valid size instead (so the
** rest of the compiler doesn't have to work with invalid sizes).
*/
{
    unsigned Size = PSizeOf (T);
    if (Size == 0) {
        if (HasUnknownSize (T + 1)) {
            Error ("Pointer to type '%s' of unknown size", GetFullTypeName (T + 1));
        } else {
            Error ("Pointer to type '%s' of 0 size", GetFullTypeName (T + 1));
        }
        Size = SIZEOF_CHAR;     /* Don't return zero */
    }
    return Size;
}



unsigned TypeOf (const Type* T)
/* Get the code generator base type of the object */
{
    unsigned NewType;

    switch (GetUnderlyingTypeCode (T)) {

        case T_SCHAR:
            return CF_CHAR;

        case T_UCHAR:
            return CF_CHAR | CF_UNSIGNED;

        case T_SHORT:
        case T_INT:
            return CF_INT;

        case T_USHORT:
        case T_UINT:
        case T_PTR:
        case T_ARRAY:
            return CF_INT | CF_UNSIGNED;

        case T_LONG:
            return CF_LONG;

        case T_ULONG:
            return CF_LONG | CF_UNSIGNED;

        case T_FLOAT:
        case T_DOUBLE:
            /* These two are identical in the backend */
            return CF_FLOAT;

        case T_FUNC:
            /* Treat this as a function pointer */
            return CF_INT | CF_UNSIGNED;

        case T_STRUCT:
        case T_UNION:
            NewType = TypeOfBySize (SizeOf (T));
            if (NewType != CF_NONE) {
                return NewType;
            }
            /* Address of ... */
            return CF_INT | CF_UNSIGNED;

        case T_VOID:
        case T_ENUM:
            /* Incomplete enum type */
            Error ("Incomplete type '%s'", GetFullTypeName (T));
            return CF_INT;

        default:
            Error ("Illegal type %04lX", T->C);
            return CF_INT;
    }
}



unsigned FuncTypeOf (const Type* T)
/* Get the code generator flag for calling the function */
{
    if (GetUnderlyingTypeCode (T) == T_FUNC) {
        return (T->A.F->Flags & FD_VARIADIC) ? 0 : CF_FIXARGC;
    } else {
        Error ("Illegal function type %04lX", T->C);
        return 0;
    }
}



const Type* Indirect (const 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* 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* NewPointerTo (const Type* T)
/* Return a type string that is "pointer to T". The type string is allocated
** on the heap and may be freed after use.
*/
{
    /* Get the size of the type string including the terminator */
    unsigned Size = TypeLen (T) + 1;

    /* Allocate the new type string */
    Type* P = TypeAlloc (Size + 1);

    /* Create the return type... */
    P[0].C = T_PTR | (T[0].C & T_QUAL_ADDRSIZE);
    memcpy (P+1, T, Size * sizeof (Type));

    /* ...and return it */
    return P;
}



const Type* AddressOf (const Type* T)
/* Return a type string that is "address of T". The type string is allocated
** on the heap and may be freed after use.
*/
{
    /* Get the size of the type string including the terminator */
    unsigned Size = TypeLen (T) + 1;

    /* Allocate the new type string */
    Type* P = TypeAlloc (Size + 1);

    /* Create the return type... */
    P[0].C = T_PTR | (T[0].C & T_QUAL_ADDRSIZE) | T_QUAL_CONST;
    memcpy (P+1, T, Size * sizeof (Type));

    /* ...and return it */
    return P;
}



Type* ArrayToPtr (const Type* T)
/* Convert an array to a pointer to it's first element */
{
    /* Return pointer to first element */
    return NewPointerTo (GetElementType (T));
}



const Type* PtrConversion (const Type* T)
/* If the type is a function, convert it to pointer to function. If the
** expression is an array, convert it to pointer to first element. Otherwise
** return T.
*/
{
    if (IsTypeFunc (T)) {
        return AddressOf (T);
    } else if (IsTypeArray (T)) {
        return AddressOf (GetElementType (T));
    } else {
        return T;
    }
}



const Type* StdConversion (const Type* T)
/* If the type is a function, convert it to pointer to function. If the
** expression is an array, convert it to pointer to first element. If the
** type is an integer, do integeral promotion. Otherwise return T.
*/
{
    if (IsTypeFunc (T)) {
        return AddressOf (T);
    } else if (IsTypeArray (T)) {
        return AddressOf (GetElementType (T));
    } else if (IsClassInt (T)) {
        return IntPromotion (T);
    } else {
        return T;
    }
}



const Type* IntPromotion (const Type* T)
/* Apply the integer promotions to T and return the result. The returned type
** string may be T if there is no need to change it.
*/
{
    /* We must have an int to apply int promotions */
    PRECONDITION (IsClassInt (T));

    /* https://port70.net/~nsz/c/c89/c89-draft.html#3.2.1.1
    ** A char, a short int, or an int bit-field, or their signed or unsigned varieties, or
    ** an object that has enumeration type, may be used in an expression wherever an int or
    ** unsigned int may be used. If an int can represent all values of the original type,
    ** the value is converted to an int; otherwise it is converted to an unsigned int.
    ** These are called the integral promotions.
    */

    if (IsTypeBitField (T)) {
        /* As we now support long bit-fields, we need modified rules for them:
        ** - If an int can represent all values of the bit-field, the bit-field is converted
        **   to an int;
        ** - Otherwise, if an unsigned int can represent all values of the bit-field, the
        **   bit-field is converted to an unsigned int;
        ** - Otherwise, the bit-field will have its declared integer type.
        ** These rules are borrowed from C++ and seem to be consistent with GCC/Clang's.
        */
        if (T->A.B.Width > INT_BITS) {
            return IsSignUnsigned (T) ? type_ulong : type_long;
        }
        return T->A.B.Width == INT_BITS && IsSignUnsigned (T) ? type_uint : type_int;
    } else if (IsTypeChar (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)) {
        /* An integer cannot represent all values from unsigned short, so convert unsigned short
        ** to unsigned int.
        */
        return IsSignUnsigned (T) ? type_uint : type_int;
    } else if (!IsIncompleteESUType (T)) {
        /* The type is a complete type not smaller than int, so leave it alone. */
        return T;
    } else {
        /* Otherwise, this is an incomplete enum, and there is expceted to be an error already.
        ** Assume int to avoid further errors.
        */
        return type_int;
    }
}



const Type* ArithmeticConvert (const Type* lhst, const Type* rhst)
/* Perform the usual arithmetic conversions for binary operators. */
{
    /* https://port70.net/~nsz/c/c89/c89-draft.html#3.2.1.5
    ** Many binary operators that expect operands of arithmetic type cause conversions and yield
    ** result types in a similar way. The purpose is to yield a common type, which is also the type
    ** of the result. This pattern is called the usual arithmetic conversions.
    */

    /* There are additional rules for floating point types that we don't bother with, since
    ** floating point types are not (yet) supported.
    ** The integral promotions are performed on both operands.
    */
    lhst = IntPromotion (lhst);
    rhst = IntPromotion (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))) {
        return type_ulong;
    }

    /* Otherwise, if one operand has type long int and the other has type unsigned int,
    ** if a long int can represent all values of an unsigned int, the operand of type unsigned int
    ** 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))) {
        /* 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)) {
        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))) {
        return type_uint;
    }

    /* Otherwise, both operands have type int. */
    CHECK (IsTypeInt (lhst));
    CHECK (IsSignSigned (lhst));
    CHECK (IsTypeInt (rhst));
    CHECK (IsSignSigned (rhst));
    return type_int;
}



const Type* SignedType (const Type* T)
/* Get signed counterpart of the integral type */
{
    switch (GetUnderlyingTypeCode (T) & T_MASK_TYPE) {
        case T_TYPE_CHAR:
            return type_schar;

        case T_TYPE_INT:
        case T_TYPE_SHORT:
            return type_int;

        case T_TYPE_LONG:
            return type_long;

        default:
            Internal ("Unknown type code: %lX", GetUnderlyingTypeCode (T));
            return T;
    }
}



const Type* UnsignedType (const Type* T)
/* Get unsigned counterpart of the integral type */
{
    switch (GetUnderlyingTypeCode (T) & T_MASK_TYPE) {
        case T_TYPE_CHAR:
            return type_uchar;

        case T_TYPE_INT:
        case T_TYPE_SHORT:
            return type_uint;

        case T_TYPE_LONG:
            return type_ulong;

        default:
            Internal ("Unknown type code: %lX", GetUnderlyingTypeCode (T));
            return T;
    }
}



Type* NewBitFieldType (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.
*/
{
    Type* P;

    /* The type specifier must be integeral */
    CHECK (IsClassInt (T));

    /* Allocate the new type string */
    P = TypeAlloc (3);

    /* Create the return type... */
    P[0].C = IsSignSigned (T) ? T_SBITFIELD : T_UBITFIELD;
    P[0].C |= (T[0].C & T_QUAL_ADDRSIZE);
    P[0].A.B.Offs  = BitOffs;
    P[0].A.B.Width = BitWidth;

    /* Get the declaration type */
    memcpy (&P[1], GetUnderlyingType (T), sizeof (P[1]));

    /* Get done... */
    P[2].C = T_END;

    /* ...and return it */
    return P;
}



int IsTypeFragBitField (const Type* T)
/* Return true if this is a bit-field that shares byte space with other fields */
{
    return IsTypeBitField (T) &&
           (T->A.B.Offs != 0 || T->A.B.Width != CHAR_BITS * SizeOf (T));
}



int IsClassObject (const Type* T)
/* Return true if this is a fully described object type */
{
    return !IsTypeFunc (T) && !IsClassIncomplete (T);
}



int IsClassIncomplete (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 IsTypeVoid (T) || IsIncompleteESUType (T);
}



int IsClassArithmetic (const Type* T)
/* Return true if this is an integer or real floating type */
{
    return IsClassInt (T) || IsClassFloat (T);
}



int IsClassBasic (const Type* T)
/* Return true if this is a char, integer or floating type */
{
    return IsClassChar (T) || IsClassInt (T) || IsClassFloat (T);
}



int IsClassScalar (const Type* T)
/* Return true if this is an arithmetic or pointer type */
{
    return IsClassArithmetic (T) || IsTypePtr (T);
}



int IsClassDerived (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);
}



int IsClassAggregate (const Type* T)
/* Return true if this is an array or struct type */
{
    return IsTypeArray (T) || IsTypeStruct (T);
}



int IsRelationType (const Type* T)
/* Return true if this is an arithmetic, array or pointer type */
{
    return IsClassArithmetic (T) || IsClassPtr (T);
}



int IsCastType (const Type* T)
/* Return true if this type can be used for casting */
{
    return IsClassScalar (T) || IsTypeVoid (T);
}



int IsESUType (const Type* T)
/* Return true if this is an enum/struct/union type */
{
    return IsClassStruct (T) || IsTypeEnum (T);
}



int IsIncompleteESUType (const Type* T)
/* Return true if this is an incomplete ESU type */
{
    SymEntry* Sym = GetSymType (T);

    return Sym != 0 && !SymIsDef (Sym);
}



int IsEmptiableObjectType (const Type* T)
/* Return true if this is a struct/union/void type that can have zero size */
{
    return IsClassStruct (T) || IsTypeVoid (T);
}



int HasUnknownSize (const Type* T)
/* Return true if this is an incomplete ESU type or an array of unknown size */
{
    if (IsTypeArray (T)) {
        return GetElementCount (T) == UNSPECIFIED || HasUnknownSize (T + 1);
    }
    return IsIncompleteESUType (T);
}



int IsVariadicFunc (const Type* T)
/* Return true if this is a function type or pointer to function type with
** variable parameter list.
** Check fails if the type is not a function or a pointer to function.
*/
{
    return (GetFuncDesc (T)->Flags & FD_VARIADIC) != 0;
}



int IsFastcallFunc (const Type* T)
/* Return true if this is a function type or pointer to function type by
** __fastcall__ calling convention.
** Check fails if the type is not a function or a pointer to function.
*/
{
    if (UnqualifiedType (T->C) == T_PTR) {
        /* Pointer to function */
        ++T;
    }
    return !IsVariadicFunc (T) && (AutoCDecl ? IsQualFastcall (T) : !IsQualCDecl (T));
}



FuncDesc* GetFuncDesc (const Type* T)
/* Get the FuncDesc pointer from a function or pointer-to-function type */
{
    if (UnqualifiedType (T->C) == T_PTR) {
        /* Pointer to function */
        ++T;
    }

    /* Be sure it's a function type */
    CHECK (IsClassFunc (T));

    /* Get the function descriptor from the type attributes */
    return T->A.F;
}



void SetFuncDesc (Type* T, FuncDesc* F)
/* Set the FuncDesc pointer in a function or pointer-to-function type */
{
    if (UnqualifiedType (T->C) == T_PTR) {
        /* Pointer to function */
        ++T;
    }

    /* Be sure it's a function type */
    CHECK (IsClassFunc (T));

    /* Set the function descriptor */
    T->A.F = F;
}



const Type* GetFuncReturn (const Type* T)
/* Return a pointer to the return type of a function or pointer-to-function type */
{
    if (UnqualifiedType (T->C) == T_PTR) {
        /* Pointer to function */
        ++T;
    }

    /* Be sure it's a function type */
    CHECK (IsClassFunc (T));

    /* Return a pointer to the return type */
    return T + 1;
}



Type* GetFuncReturnModifiable (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) {
        /* Pointer to function */
        ++T;
    }

    /* Be sure it's a function type */
    CHECK (IsClassFunc (T));

    /* Return a pointer to the return type */
    return T + 1;
}



const FuncDesc* GetFuncDefinitionDesc (const Type* T)
/* Get the function descriptor of the function definition */
{
    const FuncDesc* D;

    /* Be sure it's a function type */
    CHECK (IsClassFunc (T));

    D = GetFuncDesc (T);
    return D->FuncDef != 0 ? D->FuncDef : D;
}



long GetElementCount (const Type* T)
/* Get the element count of the array specified in T (which must be of
** array type).
*/
{
    CHECK (IsTypeArray (T));
    return T->A.L;
}



void SetElementCount (Type* T, long Count)
/* Set the element count of the array specified in T (which must be of
** array type).
*/
{
    CHECK (IsTypeArray (T));
    T->A.L = Count;
}



const Type* GetElementType (const Type* T)
/* Return the element type of the given array type. */
{
    CHECK (IsTypeArray (T));
    return T + 1;
}



const Type* GetBaseElementType (const Type* T)
/* Return the base element type of a given type. If T is not an array, this
** will return. Otherwise it will return the base element type, which means
** the element type that is not an array.
*/
{
    while (IsTypeArray (T)) {
        ++T;
    }
    return T;
}



struct SymEntry* GetESUSymEntry (const Type* T)
/* Return a SymEntry pointer from an enum/struct/union type */
{
    /* Only enums, structs or unions have a SymEntry attribute */
    CHECK (IsClassStruct (T) || IsTypeEnum (T));

    /* Return the attribute */
    return T->A.S;
}



void SetESUSymEntry (Type* T, struct SymEntry* S)
/* Set the SymEntry pointer for an enum/struct/union type */
{
    /* Only enums, structs or unions have a SymEntry attribute */
    CHECK (IsClassStruct (T) || IsTypeEnum (T));

    /* Set the attribute */
    T->A.S = S;
}



TypeCode AddrSizeQualifier (unsigned AddrSize)
/* Return T_QUAL_NEAR or T_QUAL_FAR depending on the address size */
{
    switch (AddrSize) {

        case ADDR_SIZE_ABS:
            return T_QUAL_NEAR;

        case ADDR_SIZE_FAR:
            return T_QUAL_FAR;

        default:
            Error ("Invalid address size");
            return T_QUAL_NEAR;

    }
}



int TypeHasAttr (const Type* T)
/* Return true if the given type has attribute data */
{
    return IsClassStruct (T) || IsTypeArray (T) || IsClassFunc (T);
}



void PrintType (FILE* F, const Type* T)
/* Print fulle name of the type */
{
    StrBuf Buf = AUTO_STRBUF_INITIALIZER;
    fprintf (F, "%s", SB_GetConstBuf (GetFullTypeNameBuf (&Buf, T)));
    SB_Done (&Buf);
}



void PrintFuncSig (FILE* F, const char* Name, const Type* T)
/* Print a function signature */
{
    StrBuf Buf       = AUTO_STRBUF_INITIALIZER;
    StrBuf ParamList = AUTO_STRBUF_INITIALIZER;
    StrBuf East      = AUTO_STRBUF_INITIALIZER;
    StrBuf West      = AUTO_STRBUF_INITIALIZER;

    /* Get the function descriptor used in definition */
    const FuncDesc* D = GetFuncDefinitionDesc (T);

    /* Get the parameter list string. Start from the first parameter */
    SymEntry* Param = D->SymTab->SymHead;
    unsigned I;
    for (I = 0; I < D->ParamCount; ++I) {
        CHECK (Param != 0 && (Param->Flags & SC_PARAM) != 0);
        if (I > 0) {
            SB_AppendStr (&ParamList, ", ");
        }
        if (SymIsRegVar (Param)) {
            SB_AppendStr (&ParamList, "register ");
        }
        if (!HasAnonName (Param)) {
            SB_AppendStr (&Buf, Param->Name);
        }
        SB_AppendStr (&ParamList, SB_GetConstBuf (GetFullTypeNameBuf (&Buf, Param->Type)));
        SB_Clear (&Buf);
        /* Next argument */
        Param = Param->NextSym;
    }
    if ((D->Flags & FD_VARIADIC) == 0) {
        if (D->ParamCount == 0 && (D->Flags & FD_EMPTY) == 0) {
            SB_AppendStr (&ParamList, "void");
        }
    } else {
        if (D->ParamCount > 0) {
            SB_AppendStr (&ParamList, ", ...");
        } else {
            SB_AppendStr (&ParamList, "...");
        }
    }
    SB_Terminate (&ParamList);

    /* Get the function qualifiers */
    if (GetQualifierTypeCodeNameBuf (&Buf, T->C, T_QUAL_NONE) > 0) {
        /* Append a space between the qualifiers and the name */
        SB_AppendChar (&Buf, ' ');
    }
    SB_Terminate (&Buf);

    /* Get the signature string without the return type */
    SB_Printf (&West, "%s%s (%s)", SB_GetConstBuf (&Buf), Name, SB_GetConstBuf (&ParamList));
    SB_Done (&Buf);
    SB_Done (&ParamList);

    /* Complete with the return type */
    GetFullTypeNameWestEast (&West, &East, GetFuncReturn (T));
    SB_Append (&West, &East);
    SB_Terminate (&West);

    /* Output */
    fprintf (F, "%s", SB_GetConstBuf (&West));
    SB_Done (&East);
    SB_Done (&West);
}



void PrintRawType (FILE* F, const Type* T)
/* Print a type string in raw hex format (for debugging) */
{
    while (T->C != T_END) {
        fprintf (F, "%04lX ", T->C);
        ++T;
    }
    fprintf (F, "\n");
}