// Copyright (C) 1983-1998 by Symantec
// Copyright (C) 2000-2009 by Digital Mars
// All Rights Reserved
// http://www.digitalmars.com
// Written by Walter Bright
/*
 * This source file is made available for personal use
 * only. The license is in /dmd/src/dmd/backendlicense.txt
 * or /dm/src/dmd/backendlicense.txt
 * For any other uses, please contact Digital Mars.
 */


#if __SC__
#pragma once
#endif

#ifndef TY_H
#define TY_H 1

//#define TYjhandle     TYnptr          // use for Jupiter handle

/*****************************************
 * Data types.
 * (consists of basic type + modifier bits)
 */

// Basic types.
// casttab[][] in exp2.c depends on the order of this
// typromo[] in cpp.c depends on the order too

enum TYM
{
    TYbool              = 0,
    TYchar              = 1,
    TYschar             = 2,    // signed char
    TYuchar             = 3,    // unsigned char
    TYchar8             = 4,
    TYchar16            = 5,
    TYshort             = 6,
    TYwchar_t           = 7,
    TYushort            = 8,    // unsigned short
    TYenum              = 9,    // enumeration value
    TYint               = 0xA,
    TYuint              = 0xB,  // unsigned
    TYlong              = 0xC,
    TYulong             = 0xD,  // unsigned long
    TYdchar             = 0xE,  // 32 bit Unicode char
    TYllong             = 0xF,  // 64 bit long
    TYullong            = 0x10, // 64 bit unsigned long
    TYfloat             = 0x11, // 32 bit real
    TYdouble            = 0x12, // 64 bit real

    // long double is mapped to either of the following at runtime:
    TYdouble_alias      = 0x13, // 64 bit real (but distinct for overload purposes)
    TYldouble           = 0x14, // 80 bit real

    // Add imaginary and complex types for D and C99
    TYifloat            = 0x15,
    TYidouble           = 0x16,
    TYildouble          = 0x17,
    TYcfloat            = 0x18,
    TYcdouble           = 0x19,
    TYcldouble          = 0x1A,

    TYjhandle           = 0x1B, // Jupiter handle type, equals TYnptr except
                                // that the debug type is different so the
                                // debugger can distinguish them
    TYnullptr           = 0x1C,
    TYnptr              = 0x1D, // data segment relative pointer
    TYref               = 0x24, // reference to another type
    TYvoid              = 0x25,
    TYstruct            = 0x26, // watch tyaggregate()
    TYarray             = 0x27, // watch tyaggregate()
    TYnfunc             = 0x28, // near C func
    TYnpfunc            = 0x2A, // near Cpp func
    TYnsfunc            = 0x2C, // near stdcall func
    TYifunc             = 0x2E, // interrupt func
    TYptr               = 0x33, // generic pointer type
    TYmfunc             = 0x37, // NT C++ member func
    TYjfunc             = 0x38, // LINKd D function
    TYhfunc             = 0x39, // C function with hidden parameter
    TYnref              = 0x3A, // near reference

    TYcent              = 0x3C, // 128 bit signed integer
    TYucent             = 0x3D, // 128 bit unsigned integer

#if TARGET_SEGMENTED
    TYsptr              = 0x1E, // stack segment relative pointer
    TYcptr              = 0x1F, // code segment relative pointer
    TYf16ptr            = 0x20, // special OS/2 far16 pointer
    TYfptr              = 0x21, // far pointer (has segment and offset)
    TYhptr              = 0x22, // huge pointer (has segment and offset)
    TYvptr              = 0x23, // __handle pointer (has segment and offset)
    TYffunc             = 0x29, // far  C func
    TYfpfunc            = 0x2B, // far  Cpp func
    TYfsfunc            = 0x2D, // far stdcall func
    TYf16func           = 0x34, // _far16 _pascal function
    TYnsysfunc          = 0x35, // near __syscall func
    TYfsysfunc          = 0x36, // far __syscall func
    TYfref              = 0x3B, // far reference
#endif

#if !MARS
    TYmemptr            = 0x2F, // pointer to member
    TYident             = 0x30, // type-argument
    TYtemplate          = 0x31, // unexpanded class template
    TYvtshape           = 0x32, // virtual function table
#endif

    // SIMD vector types        // D type
    TYfloat4            = 0x3E, // float[4]
    TYdouble2           = 0x3F, // double[2]
    TYschar16           = 0x40, // byte[16]
    TYuchar16           = 0x41, // ubyte[16]
    TYshort8            = 0x42, // short[8]
    TYushort8           = 0x43, // ushort[8]
    TYlong4             = 0x44, // int[4]
    TYulong4            = 0x45, // uint[4]
    TYllong2            = 0x46, // long[2]
    TYullong2           = 0x47, // ulong[2]

#if MARS
#define TYaarray        TYnptr
#define TYdelegate      (I64 ? TYcent : TYllong)
#define TYdarray        (I64 ? TYucent : TYullong)
#endif

    TYMAX               = 0x48,
};

#define mTYbasic        0xFF    /* bit mask for basic types     */
#define tybasic(ty)     ((ty) & mTYbasic)

#if TX86
// These change depending on memory model
extern int TYptrdiff, TYsize, TYsize_t;

/* Linkage type                 */
#define mTYnear         0x0800
#if TARGET_SEGMENTED
#define mTYfar          0x1000
#define mTYcs           0x2000           // in code segment
#endif
#define mTYthread       0x4000
#define mTYLINK         0x7800           // all linkage bits

#define mTYloadds       0x08000
#define mTYexport       0x10000
#define mTYweak         0x00000
#define mTYimport       0x20000
#define mTYnaked        0x40000
#define mTYMOD          0x78000          // all modifier bits

#else
#define TYTARG          0x11
#include "TGty.h"               /* Target types */
#endif

/* Modifiers to basic types     */

#ifdef JHANDLE
#define mTYarrayhandle  0x200
#else
#define mTYarrayhandle  0x0
#endif
#define mTYconst        0x100
#define mTYvolatile     0x200
#define mTYrestrict     0               // BUG: add for C99
#define mTYmutable      0               // need to add support
#define mTYunaligned    0               // non-zero for PowerPC

#define mTYimmutable    0x00080000       // immutable data
#define mTYshared       0x00100000       // shared data
#define mTYnothrow      0x00200000       // nothrow function

#if !MARS
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
#define mTYnoret        0x01000000        // function has no return
#define mTYtransu       0x01000000        // transparent union
#else
#define mTYfar16        0x01000000
#endif
#define mTYstdcall      0x02000000
#define mTYfastcall     0x04000000
#define mTYinterrupt    0x08000000
#define mTYcdecl        0x10000000
#define mTYpascal       0x20000000
#define mTYsyscall      0x40000000
#define mTYjava         0x80000000

#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
#define mTYTFF          0xFE000000
#else
#define mTYTFF          0xFF000000
#endif
#endif

/* Flags in tytab[] array       */
extern unsigned tytab[];
#define TYFLptr         1
#define TYFLreal        2
#define TYFLintegral    4
#define TYFLcomplex     8
#define TYFLimaginary   0x10
#define TYFLuns         0x20
#define TYFLmptr        0x40
#define TYFLfv          0x80    /* TYfptr || TYvptr     */

#if TX86
#define TYFLfarfunc     0x100
#define TYFLpascal      0x200       // callee cleans up stack
#define TYFLrevparam    0x400       // function parameters are reversed
#define TYFLxmmreg      0x10000     // can be put in XMM register
#else
#define TYFLcallstkc    0x100       // callee cleans up stack
#define TYFLrevparam    0x200       // function parameters are reversed
#endif
#define TYFLnullptr     0x800
#define TYFLshort       0x1000
#define TYFLaggregate   0x2000
#define TYFLfunc        0x4000
#define TYFLref         0x8000

/* Groupings of types   */

#define tyintegral(ty)  (tytab[(ty) & 0xFF] & TYFLintegral)

#define tyarithmetic(ty) (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLreal | TYFLimaginary | TYFLcomplex))

#define tyaggregate(ty) (tytab[(ty) & 0xFF] & TYFLaggregate)

#define tyscalar(ty)    (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLreal | TYFLimaginary | TYFLcomplex | TYFLptr | TYFLmptr | TYFLnullptr))

#define tyfloating(ty)  (tytab[(ty) & 0xFF] & (TYFLreal | TYFLimaginary | TYFLcomplex))

#define tyimaginary(ty) (tytab[(ty) & 0xFF] & TYFLimaginary)

#define tycomplex(ty)   (tytab[(ty) & 0xFF] & TYFLcomplex)

#define tyreal(ty)      (tytab[(ty) & 0xFF] & TYFLreal)

// Fits into 64 bit register
#define ty64reg(ty)     (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLptr) && tysize(ty) <= NPTRSIZE)

// Can go in XMM floating point register
#define tyxmmreg(ty)    (tytab[(ty) & 0xFF] & TYFLxmmreg)

// Is a vector type
#define tyvector(ty)    (tybasic(ty) >= TYfloat4 && tybasic(ty) <= TYullong2)

#ifndef tyshort
/* Types that are chars or shorts       */
#define tyshort(ty)     (tytab[(ty) & 0xFF] & TYFLshort)
#endif

/* Detect TYlong or TYulong     */
#ifndef tylong
#define tylong(ty)      (tybasic(ty) == TYlong || tybasic(ty) == TYulong)
#endif

/* Use to detect a pointer type */
#ifndef typtr
#define typtr(ty)       (tytab[(ty) & 0xFF] & TYFLptr)
#endif

/* Use to detect a reference type */
#ifndef tyref
#define tyref(ty)       (tytab[(ty) & 0xFF] & TYFLref)
#endif

/* Use to detect a pointer type or a member pointer     */
#ifndef tymptr
#define tymptr(ty)      (tytab[(ty) & 0xFF] & (TYFLptr | TYFLmptr))
#endif

// Use to detect a nullptr type or a member pointer
#ifndef tynullptr
#define tynullptr(ty)      (tytab[(ty) & 0xFF] & TYFLnullptr)
#endif

/* Detect TYfptr or TYvptr      */
#ifndef tyfv
#define tyfv(ty)        (tytab[(ty) & 0xFF] & TYFLfv)
#endif

/* Array to give the size in bytes of a type, -1 means error    */
extern signed char tysize[];
extern signed char tyalignsize[];

// Give size of type
#define tysize(ty)      tysize[(ty) & 0xFF]
#define tyalignsize(ty) tyalignsize[(ty) & 0xFF]

/* All data types that fit in exactly 8 bits    */
#ifndef tybyte
#define tybyte(ty)      (tysize(ty) == 1)
#endif

/* Types that fit into a single machine register        */
#ifndef tyreg
#define tyreg(ty)       (tysize(ty) <= REGSIZE)
#endif

/* Detect function type */
#ifndef tyfunc
#define tyfunc(ty)      (tytab[(ty) & 0xFF] & TYFLfunc)
#endif

/* Detect function type where parameters are pushed left to right    */
#ifndef tyrevfunc
#define tyrevfunc(ty)   (tytab[(ty) & 0xFF] & TYFLrevparam)
#endif

/* Detect unsigned types */
#ifndef tyuns
#define tyuns(ty)       (tytab[(ty) & 0xFF] & (TYFLuns | TYFLptr))
#endif

/* Target dependent info        */
#if TX86
#define TYoffset TYuint         /* offset to an address         */

/* Detect cpp function type (callee cleans up stack)    */
#define typfunc(ty)     (tytab[(ty) & 0xFF] & TYFLpascal)

#else
/* Detect cpp function type (callee cleans up stack)    */
#ifndef typfunc
#define typfunc(ty)     (tytab[(ty) & 0xFF] & TYFLcallstkc)
#endif
#endif

/* Array to convert a type to its unsigned equivalent   */
extern const tym_t tytouns[];
#ifndef touns
#define touns(ty)       (tytouns[(ty) & 0xFF])
#endif

/* Determine if TYffunc or TYfpfunc (a far function) */
#ifndef tyfarfunc
#define tyfarfunc(ty)   (tytab[(ty) & 0xFF] & TYFLfarfunc)
#endif

// Determine if parameter can go in register for TYjfunc
#ifndef tyjparam
#define tyjparam(ty)    (tysize(ty) <= NPTRSIZE && !tyfloating(ty) && tybasic(ty) != TYstruct && tybasic(ty) != TYarray)
#endif

/* Determine relaxed type       */
#ifndef tyrelax
#define tyrelax(ty)     (_tyrelax[tybasic(ty)])
#endif

/* Array to give the 'relaxed' type for relaxed type checking   */
extern unsigned char _tyrelax[];
#define type_relax      (config.flags3 & CFG3relax)     // !=0 if relaxed type checking
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
#define type_semirelax  (config.flags3 & CFG3semirelax) // !=0 if semi-relaxed type checking
#else
#define type_semirelax  type_relax
#endif

/* Determine functionally equivalent type       */
extern unsigned char tyequiv[];

/* Give an ascii string for a type      */
extern const char *tystring[];

#if TX86
/* Debugger value for type      */
extern unsigned char dttab[];
extern unsigned short dttab4[];
#endif

#endif /* TY_H */

