DoTypeBase.hpp

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder


#ifndef DOTYPEBASE_HPP
#define DOTYPEBASE_HPP

#include "DoBase.hpp"


// Type machinery - Convert type to integer
// 
#define DOT_PRIMITIVE   0x01        // 1: A primitive type  0: A user type
#define DOT_REF         0x02        // It's a C++ reference 
#define DOT_CONST       0x04        // Innermost type is const 
#define DOT_ARRAY       0x08        // A sized array (requires trailing size descriptor)
#define DOT_PTR         0x10        // First pointer bit 
#define DOT_PTR_MASK    0x70
#define TO_PTR_MASK(n)  ((n&7)<<4)
#define TO_PTR_LEVEL(n) ((n>>4)&7)
#define DOT_CONST_PTR   0x80        // Some pointer level have const (requires trailing const descriptor)

// For structs and user types
#define DOT_HAS_NO_VTABLE       0x100   // 1: Has no VTable, 0: Has VTable 
#define DOT_IS_BASE_STRUCT      0x200   // 1 It is a base struct/class item 

//#define DOT_PRIM_USER_MASK      (DOT_PRIMITIVE|DOT_HAS_NO_VTABLE)
#define DOT_IS_PRIMITIVE(t)     (((t)&DOT_PRIMITIVE)!=0)
#define DOT_IS_USERTYPE(t)      (((t)&DOT_PRIMITIVE)==0)
#define DOT_HAS_VTABLE(t)       ( !((t)&DOT_HAS_NO_VTABLE) && (DOT_IS_USERTYPE(t) || ((t)&DOT_TYPE_MASK)==DOT_STRUCT) )
#define DOT_IS_BASE(t)          ( ((t)&DOT_IS_BASE_STRUCT) && (DOT_IS_USERTYPE(t) || ((t)&DOT_TYPE_MASK)==DOT_STRUCT) )


#define DOT_COMMON_MASK     0xFFF    // Bits shared by both common and user-types
#define DOT_USERTYPE_MASK   0xFFFFF000 // All user-type bits
#define DOT_BASETYPE_MASK   (DOT_USERTYPE_MASK|DOT_PRIMITIVE)

// Bits for primitive type 
#define DOT_TYPE_MASK 0xF000
#define DOT_VOID      0x0000
#define DOT_BOOL      0x1000
#define DOT_CHAR      0x2000
#define DOT_SINT      0x3000    // Signed integer
#define DOT_UINT      0x4000    // Unsigned integer
#define DOT_UNSIGNED  0x1000    // Difference between signed & unsigned
#define DOT_FLOAT     0x5000
#define DOT_PADDING   0x6000    // Padding inside structures
#define DOT_OPAQUE    0x7000    // Opaque type 
#define DOT_FUNC      0x8000    // Function 
#define DOT_STRUCT    0x9000    // struct
#define DOT_ENUM      0xA000    // enums 
#define DOT_ACCESS_SPEC 0xB000  // protected/public/private/...
#define DOT_TEMPLATE_ARG 0xF000 // Template arg, not yet determined   

// We can overwrite VTable bit here 
#define DOT_SIZE_MASK 0x0700   // Size qualifier for base type (if appliciable)
#define DOT_SIZE_POS  8         // (char/int/uint/float types)
#define DOT_SIZE_1    0x0000
#define DOT_SIZE_2    0x0100
#define DOT_SIZE_4    0x0200
#define DOT_SIZE_8    0x0300
#define DOT_SIZE_16   0x0400


// Bit 16..31 have different use for different types: 
//
// struct: (need another word on its own?)
// - padding (default / explicit(none) / ) (2)
// - size unit: byte/int (1)
// - sizeof (12)
// For base classes: Could add one bit to both of struct and user type 
// to indicate it is a base. (Use size bit, DOT_IS_BASE_STRUCT !)
//
// function
// - # Calling conv (cdecl/thiscall/...)
// - # Return values (0..3)
// - # Args - traverse the list 
// - # Atomic / Stable - Can be safely applied from script 
// - # Volatile - Opposite as above
//
// enum
// ...?
//
// template arg
// - ID which (T1, T2, T3, ...)
//


// We jam pointer and ref together here.
#define DOT_PTR_REF_LEVEL(t) (((t&DOT_PTR_MASK)+((t&DOT_REF)?DOT_PTR:0))>>3)

template<int N>
struct DoLog2{ enum { v=1+DoLog2<N/2>::v }; };

template<>
struct DoLog2<0>{ enum { v=-1 }; };

// Default case, user-type
template<class T>
struct DoType2Int {
    // If custom type, can check if it has a VTable
    enum { v = IsVObj<T>::v ? 0 : DOT_HAS_NO_VTABLE };
};

template<class T>
struct DoType2Int<const T> {
    enum { v=DOT_CONST|DoType2Int<T>::v };
};

template<class T>
struct DoType2Int<T&> {
    enum { v=DOT_REF|DoType2Int<T>::v };
};

template<class T>
struct DoType2Int<T*> {
    enum { v=DOT_PTR+DoType2Int<T>::v };
};

template<> struct DoType2Int<void> { enum { v=DOT_VOID|DOT_PRIMITIVE }; };
template<> struct DoType2Int<bool> { enum { v=DOT_BOOL|DOT_PRIMITIVE }; };

template<> struct DoType2Int<char> { enum { v=DOT_CHAR|DOT_PRIMITIVE }; };
template<> struct DoType2Int<wchar_t> { enum { v=DOT_CHAR|(DoLog2<sizeof(wchar_t)>::v<<DOT_SIZE_POS)|DOT_PRIMITIVE }; };

template<> struct DoType2Int<short> { enum { v=DOT_SINT|DOT_SIZE_2|DOT_PRIMITIVE }; };
template<> struct DoType2Int<int> { enum { v=DOT_SINT|(DoLog2<sizeof(int)>::v<<DOT_SIZE_POS)|DOT_PRIMITIVE }; };
template<> struct DoType2Int<long> { enum { v=DOT_SINT|(DoLog2<sizeof(long)>::v<<DOT_SIZE_POS)|DOT_PRIMITIVE }; };
template<> struct DoType2Int<long long> { enum { v=DOT_SINT|(DoLog2<sizeof(long long)>::v<<DOT_SIZE_POS)|DOT_PRIMITIVE }; };

template<> struct DoType2Int<unsigned short> { enum { v=DOT_UINT|DOT_SIZE_2|DOT_PRIMITIVE }; };
template<> struct DoType2Int<unsigned int> { enum { v=DOT_UINT|(DoLog2<sizeof(int)>::v<<DOT_SIZE_POS)|DOT_PRIMITIVE }; };
template<> struct DoType2Int<unsigned long> { enum { v=DOT_UINT|(DoLog2<sizeof(long)>::v<<DOT_SIZE_POS)|DOT_PRIMITIVE }; };
template<> struct DoType2Int<unsigned long long> { enum { v=DOT_UINT|(DoLog2<sizeof(long long)>::v<<DOT_SIZE_POS)|DOT_PRIMITIVE }; };

template<> struct DoType2Int<float> { enum { v=DOT_FLOAT|DOT_SIZE_4 }; };
template<> struct DoType2Int<double> { enum { v=DOT_FLOAT|DOT_SIZE_8 }; };



template<class T>
struct DoFullType2Int {
    static int Id(){ 
        // doTypeInfo::Id() return 0 for anything unknown and peels of any qualifiers
        return DoType2Int<T>::v | doTypeInfo<T>::Id();
    }
};

#endif // DO_TYPEBASE_HPP

---