#include "cc.h"

// -----------------------------------------------------------------------
// Architecture

enum 
{
    arch·x64,
    numarch,
};

// -----------------------------------------------------------------------
// Types

/* 
 * enumerated type specifers 
 * see https://en.wikipedia.org/wiki/C_data_types
 */
#define VOID      X(Tvoid, 0)

#define BOOL      X(Tbool, 1)
#define CHAR      X(Tchar, 2)
#define SCHAR     X(Tsign|Tchar, 3)
#define UCHAR     X(Tunsign|Tchar, 4)

#define SHORT     X(Tshort, 5), X(Tshort|Tint, 5)
#define SSHORT    X(Tsign|Tshort, 6), X(Tsign|Tshort|Tint, 6)
#define USHORT    X(Tunsign|Tshort, 7), X(Tunsign|Tshort|Tint, 7)

#define INT       X(0, 8), X(Tint, 8)
#define SINT      X(Tsign, 9), X(Tsign|Tint, 9)
#define UINT      X(Tunsign, 10), X(Tunsign|Tint, 10)

#define LONG      X(Tlong, 11), X(Tlong|Tint, 11)
#define SLONG     X(Tsign|Tlong, 12), X(Tsign|Tlong|Tint, 12)
#define ULONG     X(Tunsign|Tlong, 13), X(Tunsign|Tlong|Tint, 13)

#define VLONG     X(Tvlong, 14), X(Tvlong|Tint, 14)
#define SVLONG    X(Tsign|Tvlong, 15), X(Tsign|Tvlong|Tint, 15)
#define UVLONG    X(Tunsign|Tvlong, 16), X(Tunsign|Tvlong|Tint, 16)

#define FLOAT     X(Tfloat, 17)
#define DOUBLE    X(Tdouble, 18)
#define LONGDB    X(Tlong|Tdouble, 19)
#define COMPLEX   X(Tcmplx, 20)
#define IMAGINARY X(Timag, 21)

/* fixed width definitions */
#define DEF(name, sz, aln, mx, sgn) {.ident=#name, .size=sz, .align=aln, .max=mx, .sign=sgn }

#define  INT8(name)  DEF(name, 1, 1, 0x7f, 0)
#define UINT8(name)  DEF(name, 1, 1, 0xff, 1)

#define  INT16(name) DEF(name, 2, 2, 0x7fff, 0)
#define UINT16(name) DEF(name, 2, 2, 0xffff, 1)

#define  INT32(name) DEF(name, 4, 4, 0x7fffffff, 0)
#define UINT32(name) DEF(name, 4, 4, 0xffffffff, 1)

#define  INT64(name) DEF(name, 8, 8, 0x7fffffffffffffff, 0)
#define UINT64(name) DEF(name, 8, 8, 0xffffffffffffffff, 1)

/* architecture specific definitions */
// TODO: max value should be able to take floats
#define TYPES                                    \
    TYPE(DEF(void, 0, 0, 0, 0), VOID)            \
    TYPE(INT8(bool), BOOL)                       \
    TYPE(UINT8(char), CHAR)                      \
    TYPE(INT8(signed char), SCHAR)               \
    TYPE(UINT8(unsigned char), UCHAR)            \
    TYPE(INT16(short), SHORT)                    \
    TYPE(INT16(signed short), SSHORT)            \
    TYPE(UINT16(unsigned short), USHORT)         \
    TYPE(INT32(int), INT)                        \
    TYPE(INT32(signed int), SINT)                \
    TYPE(UINT32(unsigned int), UINT)             \
    TYPE(INT64(long), LONG)                      \
    TYPE(INT64(signed long), SLONG)              \
    TYPE(UINT64(unsigned long), ULONG)           \
    TYPE(INT64(long long), VLONG)                \
    TYPE(INT64(signed long long), SVLONG)        \
    TYPE(UINT64(unsigned long long), UVLONG)     \
    TYPE(DEF(float, 4, 4, 0, 0), FLOAT)          \
    TYPE(DEF(double, 8, 8, 0, 0), DOUBLE)        \
    TYPE(DEF(long double, 16, 16, 0, 0), LONGDB) \
    TYPE(DEF(complex, 8, 8, 0, 0), COMPLEX)      \
    TYPE(DEF(imaginary, 4, 4, 0, 0), IMAGINARY)  \

Type pointer = {.ident = "<pointer>", .size=8, .align=8, .max=0xffffffffffffffff, .sign=0};

/* pack architecture specific definitions into exported arrays */
#define TYPE(a, ...) a,
Type basetypes[] = {
    TYPES
};
#undef TYPE

#define TYPE(a, ...) __VA_ARGS__,
#define X(a, b) a
uint64 validtypespec[40] = {
    TYPES
    Tstruct, Tunion, Tenum, Tname,
};
#undef X

#define X(a, b) b
int indextypespec[40] = {
    TYPES
    -1, -1, -1, -1,
};
#undef X
#undef TYPE