ByteOrder.h

Go to the documentation of this file.

#ifndef __LDK_BYTEORDER_H__
#define __LDK_BYTEORDER_H__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   This software is provided 'as-is', without any express or implied warranty.
//   In no event will the authors be held liable for any damages arising from
//   the use of this software.
//
//   Permission is granted to anyone to use this software for any purpose,
//   including commercial applications, and to alter it and redistribute it
//   freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented; you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not be
//   misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any source distribution.
//


#include "LDK/Types.h"

/* This byteorder stuff was lifted from PhysFS, which in turn lifted it from SDL*/
#define LDK_LIL_ENDIAN  1234
#define LDK_BIG_ENDIAN  4321

#if  defined(__i386__) || defined(__ia64__) || defined(WIN32) || \
    (defined(__alpha__) || defined(__alpha)) || \
     defined(__arm__) || defined(ARM) || \
    (defined(__mips__) && defined(__MIPSEL__)) || \
     defined(__SYMBIAN32__) || \
     defined(__x86_64__) || \
     defined(__LITTLE_ENDIAN__)
#define LDK_BYTEORDER    LDK_LIL_ENDIAN
#else
#define LDK_BYTEORDER    LDK_BIG_ENDIAN
#endif

namespace LDK
{

inline uint16 swap16(uint16 dat)
{
    return (dat<<8)|(dat>>8);
}

inline uint32 swap32(uint32 dat)
{
    return (dat<<24)|((dat<<8)&0x00FF0000)|((dat>>8)&0x0000FF00)|(dat>>24);
}

inline uint64 swap64(uint64 dat)  //Separate into high and low 32-bit values and swap them
{
    uint32 hi, lo;

    lo = (uint32)(dat&0xFFFFFFFF);
    dat >>= 32;
    hi = (uint32)(dat&0xFFFFFFFF);
    dat = swap32(lo);
    dat <<= 32;
    dat |= swap32(hi);
    return dat;
}

#if LDK_BYTEORDER == LDK_LIL_ENDIAN
inline uint16 swapULE16(uint16 x) { return x; }
inline int16  swapSLE16(int16 x)  { return x; }
inline uint32 swapULE32(uint32 x) { return x; }
inline int32  swapSLE32(int32 x)  { return x; }
inline uint64 swapULE64(uint64 x) { return x; }
inline int64  swapSLE64(int64 x)  { return x; }
inline uint16 swapUBE16(uint16 x) { return swap16(x); }
inline int16  swapSBE16(int16 x)  { return swap16(x); }
inline uint32 swapUBE32(uint32 x) { return swap32(x); }
inline int32  swapSBE32(int32 x)  { return swap32(x); }
inline uint64 swapUBE64(uint64 x) { return swap64(x); }
inline int64  swapSBE64(int64 x)  { return swap64(x); }

#else //LDK_BYTEORDER == LDK_BIG_ENDIAN
inline uint16 swapULE16(uint16 x) { return swap16(x); }

inline int16  swapSLE16(int16 x)  { return swap16(x); }

inline uint32 swapULE32(uint32 x) { return swap32(x); }

inline int32  swapSLE32(int32 x)  { return swap32(x); }

inline uint64 swapULE64(uint64 x) { return swap64(x); }

inline int64  swapSLE64(int64 x)  { return swap64(x); }

inline uint16 swapUBE16(uint16 x) { return x; }

inline int16  swapSBE16(int16 x)  { return x; }

inline uint32 swapUBE32(uint32 x) { return x; }

inline int32  swapSBE32(int32 x)  { return x; }

inline uint64 swapUBE64(uint64 x) { return x; }

inline int64  swapSBE64(int64 x)  { return x; }
#endif //LDK_BYTEORDER == LDK_LIL_ENDIAN

} //namespace LDK


#endif //__LDK_BYTEORDER_H__

---