coldfire/include/basictypes.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
/*
 * Defintions of the basic data types.
 */
 
#ifndef _BASICTYPES_H_
#define _BASICTYPES_H_
#include <stddef.h>
 
typedef unsigned char BOOL;
typedef unsigned char BOOLEAN;
typedef volatile unsigned char VBOOLEAN;
typedef VBOOLEAN *PVBOOLEAN;
typedef BOOLEAN *PBOOLEAN;
typedef const BOOLEAN *PCBOOLEAN;
 
typedef const char *PCSTR;
typedef char *PSTR;
 
#ifdef TRUE
#undef TRUE
#endif
#define TRUE (1)
#ifdef FALSE
#undef FALSE
#endif
#define FALSE (0)
#ifdef NULL
#undef NULL
#endif
#define NULL (0)
 
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef volatile signed char vint8_t;
typedef volatile unsigned char vuint8_t;
 
typedef signed short int16_t;
typedef unsigned short uint16_t;
typedef volatile signed short vint16_t;
typedef volatile unsigned short vuint16_t;
 
typedef signed long int32_t;
typedef unsigned long uint32_t;
typedef volatile signed long vint32_t;
typedef volatile unsigned long vuint32_t;
 
typedef signed long long int64_t;
typedef unsigned long long uint64_t;
typedef volatile signed long long vint64_t;
typedef volatile unsigned long long vuint64_t;
 
typedef signed char INT8;
typedef unsigned char UINT8;
typedef volatile signed char VINT8;
typedef volatile unsigned char VUINT8;
 
typedef signed short INT16;
typedef unsigned short UINT16;
typedef volatile signed short VINT16;
typedef volatile unsigned short VUINT16;
 
typedef signed long INT32;
typedef unsigned long UINT32;
typedef volatile signed long VINT32;
typedef volatile unsigned long VUINT32;
 
typedef vuint8_t *pvuint8_t;
typedef vint8_t *pvint8_t;
typedef vint16_t *pvint16_t;
typedef vuint16_t *pvuint16_t;
typedef vuint32_t *pvuint32_t;
typedef vint32_t *pvint32_t;
 
typedef unsigned char *puint8_t;
typedef signed char *pint8_t;
typedef signed short *pint16_t;
typedef unsigned short *puint16_t;
typedef unsigned long *puint32_t;
typedef signed long *pint32_t;
 
typedef const unsigned char *pcuint8_t;
typedef const signed char *pcint8_t;
typedef const signed short *pcint16_t;
typedef const unsigned short *pcuint16_t;
typedef const unsigned long *pcuint32_t;
typedef const signed long *pcint32_t;
 
#define beint16_t int16_t
#define beuint16_t uint16_t
#define beuint32_t uint32_t
#define beint32_t int32_t
 
#define pbeint16_t pint16_t
#define pbeuint16_t puint16_t
#define pbeuint32_t puint32_t
#define pbeint32_t pint32_t
 
#define vbeint16_t vint16_t
#define vbeuint16_t vuint16_t
#define vbeuint32_t vuint32_t
#define vbeint32_t vint32_t
 
#define pvbeint16_t pvint16_t
#define pvbeuint16_t pvuint16_t
#define pvbeuint32_t pvuint32_t
#define pvbeint32_t pvint32_t
 
typedef float befloat;
typedef double bedouble;
typedef volatile float vbefloat;
typedef volatile double vbedouble;
typedef float *pbefloat;
typedef double *pbedouble;
typedef volatile float *pvbefloat;
typedef volatile double *pvbedouble;
 
#ifdef __cplusplus
typedef volatile bool vbool_t;
typedef bool *pbool_t;
typedef vbool_t *pvbool_t;
 
inline uint16_t __REV16(uint16_t v)
{
    return ((v >> 8) & 0xFF) + ((v << 8) & 0xFF00);
}
inline int16_t __REVSH(int16_t v)
{
    return ((v >> 8) & 0xFF) + ((v << 8) & 0xFF00);
};
inline uint32_t __REV(uint32_t v)
{
    return ((v >> 24) & 0XFF) + ((v >> 8) & 0XFF00) + ((v << 24) & 0XFF000000) + ((v << 8) & 0x00FF0000);
};
inline int32_t __REV(int32_t v)
{
    return ((v >> 24) & 0XFF) + ((v >> 8) & 0XFF00) + ((v << 24) & 0XFF000000) + ((v << 8) & 0x00FF0000);
};
 
extern "C"
void * memcpy(void *,const void*,size_t);
inline float __REV(float f)
{
    uint32_t v;
    memcpy(&v, &f, sizeof(float));
    v = ((v >> 24) & 0XFF) + ((v >> 8) & 0XFF00) + ((v << 24) & 0XFF000000) + ((v << 8) & 0x00FF0000);
    memcpy(&f, &v, sizeof(float));
//    f = *(float *)&v;
    return f;
}
 
template<typename T>
class LEu16
{
    T val;
 
   public:
    LEu16() = default;
    //    inline LEu16() : val(0) {}
    inline LEu16(T rhs) : val(__REV16(rhs)) {}
    inline LEu16(uint32_t &rhs) : val(__REV16((uint16_t)rhs)) {}
    inline T operator=(T rhs)
    {
        val = __REV16(rhs);
        return rhs;
    }
    inline operator T() const { return __REV16(val); }
    inline explicit operator uint32_t() const { return __REV16(val); }
    inline T getMem() { return val; }
 
    inline T operator^=(T rhs)
    {
        val ^= __REV16(rhs);
        return __REV16(val);
    }
    inline T operator|=(T rhs)
    {
        val |= __REV16(rhs);
        return __REV16(val);
    }
    inline T operator&=(T rhs)
    {
        val &= __REV16(rhs);
        return __REV16(val);
    }
    inline T operator%=(T rhs)
    {
        T ret = __REV16(val) % rhs;
        val = __REV16(ret);
        return ret;
    }
    inline T operator+=(T rhs)
    {
        T ret = __REV16(val) + rhs;
        val = __REV16(ret);
        return ret;
    }
    inline T operator-=(T rhs)
    {
        T ret = __REV16(val) - rhs;
        val = __REV16(ret);
        return ret;
    }
 
    inline T operator++()
    {
        T ret = __REV16(val) + 1;
        val = __REV16(ret);
        return ret;
    }
    inline T operator--()
    {
        T ret = __REV16(val) - 1;
        val = __REV16(ret);
        return ret;
    }
    inline T operator++(int)
    {
        T ret = __REV16(val);
        val = __REV16(ret + 1);
        return ret;
    }
    inline T operator--(int)
    {
        T ret = __REV16(val);
        val = __REV16(ret - 1);
        return ret;
    }
} __attribute__((packed));
 
template<typename T>
class LEs16
{
    T val;
 
   public:
    LEs16() = default;
    //    inline LEs16() : val(0) {}
    inline LEs16(T rhs) : val(__REV16(rhs)) {}
    inline LEs16(int32_t &rhs) : val(__REVSH((int16_t)rhs)) {}
    inline T operator=(T rhs)
    {
        val = __REVSH(rhs);
        return rhs;
    }
    inline operator T() const { return __REVSH(val); }
    inline explicit operator int32_t() const { return (int32_t)(__REV16(val)); }
    inline T getMem() { return val; }
 
    inline T operator^=(T rhs)
    {
        val ^= __REVSH(rhs);
        return __REVSH(val);
    }
    inline T operator|=(T rhs)
    {
        val |= __REVSH(rhs);
        return __REVSH(val);
    }
    inline T operator&=(T rhs)
    {
        val &= __REVSH(rhs);
        return __REVSH(val);
    }
    inline T operator%=(T rhs)
    {
        T ret = __REVSH(val) % rhs;
        val = __REVSH(ret);
        return ret;
    }
    inline T operator+=(T rhs)
    {
        T ret = __REVSH(val) + rhs;
        val = __REVSH(ret);
        return ret;
    }
    inline T operator-=(T rhs)
    {
        T ret = __REVSH(val) - rhs;
        val = __REVSH(ret);
        return ret;
    }
 
    inline T operator++()
    {
        T ret = __REVSSH(val) + 1;
        val = __REV16(ret);
        return ret;
    }
    inline T operator--()
    {
        T ret = __REVSH(val) - 1;
        val = __REVSH(ret);
        return ret;
    }
    inline T operator++(int)
    {
        T ret = __REVSH(val);
        val = __REVSH(ret + 1);
        return ret;
    }
    inline T operator--(int)
    {
        T ret = __REVSH(val);
        val = __REVSH(ret - 1);
        return ret;
    }
} __attribute__((packed));
 
template<typename T>
class LE32
{
    T val;
 
   public:
    LE32() = default;
    //    inline LE32() : val(0) {}
    inline LE32(T rhs) : val(__REV(rhs)) {}
    //    LE32(IPADDR4 rhs);
    inline T operator=(T rhs)
    {
        val = __REV(rhs);
        return rhs;
    }
    inline operator T() const { return __REV(val); }
    inline T getMem() { return val; }
 
    inline T operator^=(T rhs)
    {
        val ^= __REV(rhs);
        return __REV(val);
    }
    inline T operator|=(T rhs)
    {
        val |= __REV(rhs);
        return __REV(val);
    }
    inline T operator&=(T rhs)
    {
        val &= __REV(rhs);
        return __REV(val);
    }
    inline T operator%=(T rhs)
    {
        T ret = __REV(val) % rhs;
        val = __REV(ret);
        return ret;
    }
    inline T operator+=(T rhs)
    {
        T ret = __REV(val) + rhs;
        val = __REV(ret);
        return ret;
    }
    inline T operator-=(T rhs)
    {
        T ret = __REV(val) - rhs;
        val = __REV(ret);
        return ret;
    }
 
    inline T operator++()
    {
        T ret = __REVSSH(val) + 1;
        val = __REV16(ret);
        return ret;
    }
    inline T operator--()
    {
        T ret = __REV(val) - 1;
        val = __REV(ret);
        return ret;
    }
    inline T operator++(int)
    {
        T ret = __REV(val);
        val = __REV(ret + 1);
        return ret;
    }
    inline T operator--(int)
    {
        T ret = __REV(val);
        val = __REV(ret - 1);
        return ret;
    }
 
} __attribute__((packed));
 
class LE_Float
{
    union {
        float val;
        uint8_t valBuf[4];
    };
 
   public:
    LE_Float() = default;
    //    inline BE32() : val(0) {}
    inline LE_Float(float rhs) : val(__REV(rhs)) {}
    //    BE32(IPADDR4 rhs);
    inline float operator=(float rhs)
    {
        val = __REV(rhs);
        return rhs;
    }
    inline operator float() const { return __REV(val); }
    inline float getMem() { return val; }
 
    inline float operator+=(float rhs)
    {
        float ret = __REV(val) + rhs;
        val = __REV(ret);
        return ret;
    }
    inline float operator-=(float rhs)
    {
        float ret = __REV(val) - rhs;
        val = __REV(ret);
        return ret;
    }
 
    inline float operator++()
    {
        float ret = __REV(val) + 1;
        val = __REV16(ret);
        return ret;
    }
    inline float operator--()
    {
        float ret = __REV(val) - 1;
        val = __REV(ret);
        return ret;
    }
    inline float operator++(int)
    {
        float ret = __REV(val);
        val = __REV(ret + 1);
        return ret;
    }
    inline float operator--(int)
    {
        float ret = __REV(val);
        val = __REV(ret - 1);
        return ret;
    }
 
    inline float operator=(float rhs) volatile
    {
        val = __REV(rhs);
        return rhs;
    }
    inline float getMem() volatile { return val; }
    inline operator float() const volatile { return __REV(val); }
 
    inline float operator+=(float rhs) volatile
    {
        float ret = __REV(val) + rhs;
        val = __REV(ret);
        return ret;
    }
    inline float operator-=(float rhs) volatile
    {
        float ret = __REV(val) - rhs;
        val = __REV(ret);
        return ret;
    }
 
    inline float operator++() volatile
    {
        float ret = __REV(val) + 1;
        val = __REV16(ret);
        return ret;
    }
    inline float operator--() volatile
    {
        float ret = __REV(val) - 1;
        val = __REV(ret);
        return ret;
    }
    inline float operator++(int) volatile
    {
        float ret = __REV(val);
        val = __REV(ret + 1);
        return ret;
    }
    inline float operator--(int) volatile
    {
        float ret = __REV(val);
        val = __REV(ret - 1);
        return ret;
    }
 
    //    friend inline float operator<<(BE32<T> lhs, unsigned int shift)
    //        { return (__REV(lhs.val)) << shift; }
    //    friend inline float operator>>(BE32<T> lhs, unsigned int shift)
    //        { return (__REV(lhs.val)) >> shift; }
} __attribute__((packed));
 
class LE_Double
{
    union {
        double val;
        uint8_t valBuf[8];
    };
 
   public:
    LE_Double() = default;
    //    inline BE32() : val(0) {}
    inline LE_Double(double rhs)
        :valBuf{
            (uint8_t)(((uint64_t)rhs)>>56),(uint8_t)(((uint64_t)rhs)>>48),
            (uint8_t)(((uint64_t)rhs)>>40),(uint8_t)(((uint64_t)rhs)>>32),
            (uint8_t)(((uint64_t)rhs)>>24),(uint8_t)(((uint64_t)rhs)>>16),
            (uint8_t)(((uint64_t)rhs)>> 8),(uint8_t)(((uint64_t)rhs)>> 0)
        }
    { }
    //    BE32(IPADDR4 rhs);
    inline double operator=(double rhs)
    {
        valBuf[0] = (uint8_t)(((uint64_t)rhs)>>56);
        valBuf[1] = (uint8_t)(((uint64_t)rhs)>>48),
        valBuf[2] = (uint8_t)(((uint64_t)rhs)>>40);
        valBuf[3] = (uint8_t)(((uint64_t)rhs)>>32);
        valBuf[4] = (uint8_t)(((uint64_t)rhs)>>24);
        valBuf[5] = (uint8_t)(((uint64_t)rhs)>>16);
        valBuf[6] = (uint8_t)(((uint64_t)rhs)>> 8);
        valBuf[7] = (uint8_t)(((uint64_t)rhs)>> 0);
        return rhs;
    }
    inline operator double() const
    {
        return (double)
            (
             (((uint64_t)valBuf[0])<<56) | (((uint64_t)valBuf[0])<<48)
                | (((uint64_t)valBuf[0])<<40) | (((uint64_t)valBuf[0])<<32)
                | (((uint64_t)valBuf[0])<<24) | (((uint64_t)valBuf[0])<<16)
                | (((uint64_t)valBuf[0])<< 8) | (((uint64_t)valBuf[0])<< 0)
                );
    }
    inline double getMem() { return val; }
 
    inline double operator+=(double rhs)
    {
        double ret = ((double)(*this)) + rhs;
        *this = ret;
        return ret;
    }
    inline double operator-=(double rhs)
    {
        double ret = ((double)(*this)) - rhs;
        *this = ret;
        return ret;
    }
 
    inline double operator++()
    {
        double ret = ((double)(*this)) + 1;
        *this = ret;
        return ret;
    }
    inline double operator--()
    {
        double ret = ((double)(*this)) - 1;
        *this = ret;
        return ret;
    }
    inline double operator++(int)
    {
        double ret = ((double)(*this));
        *this = ret + 1;
        return ret;
    }
    inline double operator--(int)
    {
        double ret = ((double)(*this));
        *this = ret - 1;
        return ret;
    }
 
    inline double operator=(double rhs) volatile
    {
        valBuf[0] = (uint8_t)(((uint64_t)rhs)>>56);
        valBuf[1] = (uint8_t)(((uint64_t)rhs)>>48),
        valBuf[2] = (uint8_t)(((uint64_t)rhs)>>40);
        valBuf[3] = (uint8_t)(((uint64_t)rhs)>>32);
        valBuf[4] = (uint8_t)(((uint64_t)rhs)>>24);
        valBuf[5] = (uint8_t)(((uint64_t)rhs)>>16);
        valBuf[6] = (uint8_t)(((uint64_t)rhs)>> 8);
        valBuf[7] = (uint8_t)(((uint64_t)rhs)>> 0);
        return rhs;
    }
    inline double getMem() volatile { return val; }
    inline operator double() const volatile
    {
        return (double)
            (
             (((uint64_t)valBuf[0])<<56) | (((uint64_t)valBuf[0])<<48)
                | (((uint64_t)valBuf[0])<<40) | (((uint64_t)valBuf[0])<<32)
                | (((uint64_t)valBuf[0])<<24) | (((uint64_t)valBuf[0])<<16)
                | (((uint64_t)valBuf[0])<< 8) | (((uint64_t)valBuf[0])<< 0)
                );
    }
 
    inline double operator+=(double rhs) volatile
    {
        double ret = ((double)(*this)) + rhs;
        *this = ret;
        return ret;
    }
    inline double operator-=(double rhs) volatile
    {
        double ret = ((double)(*this)) - rhs;
        *this = ret;
        return ret;
    }
 
    inline double operator++() volatile
    {
        double ret = ((double)(*this)) + 1;
        *this = ret;
        return ret;
    }
    inline double operator--() volatile
    {
        double ret = ((double)(*this)) - 1;
        *this = ret;
        return ret;
    }
    inline double operator++(int) volatile
    {
        double ret = ((double)(*this));
        *this = ret + 1;
        return ret;
    }
    inline double operator--(int) volatile
    {
        double ret = ((double)(*this));
        *this = ret - 1;
        return ret;
    }
 
    //    friend inline double operator<<(BE32<T> lhs, unsigned int shift)
    //        { return (__REV(lhs.val)) << shift; }
    //    friend inline double operator>>(BE32<T> lhs, unsigned int shift)
    //        { return (__REV(lhs.val)) >> shift; }
} __attribute__((packed));
 
typedef LEs16<int16_t> leint16_t;
typedef LEu16<uint16_t> leuint16_t;
typedef LE32<uint32_t> leuint32_t;
typedef LE32<uint32_t> leint32_t;
 
typedef LEs16<int16_t> *pleint16_t;
typedef LEu16<uint16_t> *pleuint16_t;
typedef LE32<uint32_t> *pleuint32_t;
typedef LE32<uint32_t> *pleint32_t;
 
typedef LEs16<volatile int16_t> vleint16_t;
typedef LEu16<volatile uint16_t> vleuint16_t;
typedef LE32<volatile uint32_t> vleuint32_t;
typedef LE32<volatile uint32_t> vleint32_t;
 
typedef LEs16<volatile int16_t> *pvleint16_t;
typedef LEu16<volatile uint16_t> *pvleuint16_t;
typedef LE32<volatile uint32_t> *pvleuint32_t;
typedef LE32<volatile uint32_t> *pvleint32_t;
 
typedef LE_Float lefloat;
typedef LE_Double ledouble;
typedef volatile LE_Float vlefloat;
typedef volatile LE_Double vledouble;
typedef LE_Float *plefloat;
typedef LE_Double *pledouble;
typedef volatile LE_Float *pvlefloat;
typedef volatile LE_Double *pvledouble;
 
#ifdef MAKE_LEINT_TEST
#include <stdio.h>
void LEINT_TEST()
{
    uint8_t buf[4];
    buf[0] = 0x01;
    buf[1] = 0x23;
    buf[2] = 0x45;
    buf[3] = 0x67;
 
    iprintf("int16_t=%08X\r\n", (int)(*((int16_t *)buf)));
    iprintf("uint16_t=%08X\r\n", (unsigned int)(*((uint16_t *)buf)));
    iprintf("int32_t=%08X\r\n", (int)(*((int32_t *)buf)));
    iprintf("uint32_t=%08X\r\n", (unsigned int)(*((uint32_t *)buf)));
 
    iprintf("leint16_t=%08X\r\n", (int)(*((leint16_t *)buf)));
    iprintf("leuint16_t=%08X\r\n", (unsigned int)(*((leuint16_t *)buf)));
    iprintf("leint32_t=%08X\r\n", (int)(*((leint32_t *)buf)));
    iprintf("leuint32_t=%08X\r\n", (unsigned int)(*((leuint32_t *)buf)));
}
#endif
#endif
 
#define uint32_t_max (0xFFFFFFFF)
 
#define HTONS(x) (x)   // HTOBES(x)
#define HTONL(x) (x)   // HTOBEL(x)
#define NTOHL(x) (x)   // HTOBEL(x)
#define NTOHS(x) (x)   // HTOBES(x)
 
#endif /* _BASICTYPES_H_ */