endianrw.h

Go to the documentation of this file.

//
//                          IMPORTANT NOTICE
//
// The following open source license statement does not apply to any
// entity in the Exception List published by FMSoft.
//
// For more information, please visit:
//
// https://www.fmsoft.cn/exception-list
//

/*
 * $Id: endianrw.h 11349 2009-03-02 05:00:43Z weiym $
 * 
 *      MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks, 
 *      pSOS, ThreadX, NuCleus, OSE, and Win32.
 *
 *      The idea comes from LGPL'ed SDL by Sam Lantinga.
 */

#ifndef _MGUI_ENDIAN_RW_H
#define _MGUI_ENDIAN_RW_H


/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
extern "C" {
#endif

/************************** General RW operations ****************************/

#define RWAREA_TYPE_UNKNOWN 0
#define RWAREA_TYPE_STDIO   1
#define RWAREA_TYPE_MEM     2

typedef struct _MG_RWops {
    int (*seek)(struct _MG_RWops *context, int offset, int whence);

    int (*read)(struct _MG_RWops *context, void *ptr, int objsize, int num);

    int (*write)(struct _MG_RWops *context, const void *ptr, int objsize, 
                    int num);

#ifdef _MGUSE_OWN_STDIO
    /* */
    int (*ungetc)(struct _MG_RWops *context, unsigned char c);
#endif

    int (*close)(struct _MG_RWops *context);

    int (*eof)(struct _MG_RWops *context);

    Uint32 type;

    union {
        struct {
            int autoclose;
            FILE *fp;
        } stdio;
        struct {
            Uint8 *base;
            Uint8 *here;
            Uint8 *stop;
        } mem;
        struct {
            void *data1;
        } unknown;
    } hidden;
} MG_RWops;

MG_EXPORT MG_RWops* MGUI_RWFromFile(const char *file, const char *mode);

MG_EXPORT MG_RWops* MGUI_RWFromFP(FILE *fp, int autoclose);

MG_EXPORT MG_RWops* MGUI_RWFromMem(void *mem, size_t size);

MG_EXPORT void MGUI_InitMemRW (MG_RWops* area, void *mem, size_t size);

MG_EXPORT MG_RWops* MGUI_AllocRW(void);

MG_EXPORT void MGUI_FreeRW(MG_RWops *area);

#define MGUI_RWseek(ctx, offset, whence)    (ctx)->seek(ctx, offset, whence)

#define MGUI_RWtell(ctx)                    (ctx)->seek(ctx, 0, SEEK_CUR)

#define MGUI_RWread(ctx, ptr, size, n)      (ctx)->read(ctx, ptr, size, n)

#define MGUI_RWwrite(ctx, ptr, size, n)     (ctx)->write(ctx, ptr, size, n)

#define MGUI_RWclose(ctx)                   (ctx)->close(ctx)

#define MGUI_RWeof(ctx)                     (ctx)->eof(ctx)

MG_EXPORT int MGUI_RWgetc (MG_RWops* area);

/****************** Endian specific read/write interfaces *********************/

/* The macros used to swap values */
/* Try to use superfast macros on systems that support them */
#ifdef linux
#include <endian.h>
#ifdef __arch__swab16
#define ArchSwap16  __arch__swab16
#endif
#ifdef __arch__swab32
#define ArchSwap32  __arch__swab32
#endif
#endif /* linux */

/* Use inline functions for compilers that support them, and static
   functions for those that do not.  Because these functions become
   static for compilers that do not support inline functions, this
   header should only be included in files that actually use them.
*/
#ifndef ArchSwap16
static inline Uint16 ArchSwap16(Uint16 D) {
        return((D<<8)|(D>>8));
}
#endif
#ifndef ArchSwap32
static inline Uint32 ArchSwap32(Uint32 D) {
        return((D<<24)|((D<<8)&0x00FF0000)|((D>>8)&0x0000FF00)|(D>>24));
}
#endif
#ifdef MGUI_HAS_64BIT_TYPE
#ifndef ArchSwap64
static inline Uint64 ArchSwap64(Uint64 val) {
        Uint32 hi, lo;

        /* Separate into high and low 32-bit values and swap them */
        lo = (Uint32)(val&0xFFFFFFFF);
        val >>= 32;
        hi = (Uint32)(val&0xFFFFFFFF);
        val = ArchSwap32(lo);
        val <<= 32;
        val |= ArchSwap32(hi);
        return(val);
}
#endif
#else
#ifndef ArchSwap64
/* This is mainly to keep compilers from complaining in MGUI code.
   If there is no real 64-bit datatype, then compilers will complain about
   the fake 64-bit datatype that MGUI provides when it compiles user code.
*/
#define ArchSwap64(X)        (X)
#endif
#endif /* MGUI_HAS_64BIT_TYPE */

/* Byteswap item from the specified endianness to the native endianness */
#if MGUI_BYTEORDER == MGUI_LIL_ENDIAN

#define ArchSwapLE16(X)        (X)

#define ArchSwapLE32(X)        (X)

#define ArchSwapLE64(X)        (X)

#define ArchSwapBE16(X)        ArchSwap16(X)

#define ArchSwapBE32(X)        ArchSwap32(X)

#define ArchSwapBE64(X)        ArchSwap64(X)
#else
#define ArchSwapLE16(X)        ArchSwap16(X)
#define ArchSwapLE32(X)        ArchSwap32(X)
#define ArchSwapLE64(X)        ArchSwap64(X)
#define ArchSwapBE16(X)        (X)
#define ArchSwapBE32(X)        (X)
#define ArchSwapBE64(X)        (X)
#endif

extern Uint16 MGUI_ReadLE16(MG_RWops *src);

extern Uint16 MGUI_ReadBE16(MG_RWops *src);

extern Uint32 MGUI_ReadLE32(MG_RWops *src);

extern Uint32 MGUI_ReadBE32(MG_RWops *src);

extern Uint64 MGUI_ReadLE64(MG_RWops *src);

extern Uint64 MGUI_ReadBE64(MG_RWops *src);

extern int MGUI_WriteLE16(MG_RWops *dst, Uint16 value);

extern int MGUI_WriteBE16(MG_RWops *dst, Uint16 value);

extern int MGUI_WriteLE32(MG_RWops *dst, Uint32 value);

extern int MGUI_WriteBE32(MG_RWops *dst, Uint32 value);

extern int MGUI_WriteLE64(MG_RWops *dst, Uint64 value);

extern int MGUI_WriteBE64(MG_RWops *dst, Uint64 value);

extern Uint16 MGUI_ReadLE16FP(FILE *src);

extern Uint32 MGUI_ReadLE32FP(FILE *src);

extern int MGUI_WriteLE16FP(FILE *dst, Uint16 value);

extern int MGUI_WriteLE32FP(FILE *dst, Uint32 value);

static inline Uint16 MGUI_ReadLE16Mem (const Uint8** data)
{
#if 1
    Uint16 h1, h2;

    h1 = *(*data); (*data)++;
    h2 = *(*data); (*data)++;
    return ((h2<<8)|h1);
#else
    Uint16 u;
    memcpy (&u, *data, sizeof (Uint16));
    u = ArchSwapLE16 (u);
    *data += sizeof (Uint16);
    return u;
#endif
}

static inline Uint32 MGUI_ReadLE32Mem (const Uint8** data)
{
#if 1
    Uint32 q1, q2, q3, q4;

    q1 = *(*data); (*data)++;
    q2 = *(*data); (*data)++;
    q3 = *(*data); (*data)++;
    q4 = *(*data); (*data)++;
    return ((q4<<24)|(q3<<16)|(q2<<8)|(q1));
#else
    Uint32 u;
    memcpy (&u, *data, sizeof (Uint32));
    u = ArchSwapLE32 (u);
    *data += sizeof (Uint32);
    return u;
#endif
}

static inline Uint16 MGUI_ReadBE16Mem (const Uint8** data)
{
#if 1
    Uint16 h1, h2;

    h1 = *(*data); (*data)++;
    h2 = *(*data); (*data)++;
    return ((h1<<8)|h2);
#else
    Uint16 u;
    memcpy (&u, *data, sizeof (Uint16));
    u = ArchSwapBE16 (u);
    *data += sizeof (Uint16);
    return u;
#endif
}

static inline Uint32 MGUI_ReadBE32Mem (const Uint8** data)
{
#if 1
    Uint32 q1, q2, q3, q4;

    q1 = *(*data); (*data)++;
    q2 = *(*data); (*data)++;
    q3 = *(*data); (*data)++;
    q4 = *(*data); (*data)++;
    return ((q1<<24)|(q2<<16)|(q3<<8)|(q4));
#else
    Uint32 u;
    memcpy (&u, *data, sizeof (Uint32));
    u = ArchSwapBE32 (u);
    *data += sizeof (Uint32);
    return u;
#endif
}

/* Ends C function definitions when using C++ */
#ifdef __cplusplus
}
#endif

#endif /* _MGUI_ENDIAN_RW_H */