Endian.h

Go to the documentation of this file.

 
#ifndef __ENDIAN__
#define __ENDIAN__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if CALL_NOT_IN_CARBON
  SInt16
  EndianS16_BtoN(SInt16 value);
 
  SInt16
  EndianS16_NtoB(SInt16 value);
 
  SInt16
  EndianS16_LtoN(SInt16 value);
 
  SInt16
  EndianS16_NtoL(SInt16 value);
 
  SInt16
  EndianS16_LtoB(SInt16 value);
 
  SInt16
  EndianS16_BtoL(SInt16 value);
 
  UInt16
  EndianU16_BtoN(UInt16 value);
 
  UInt16
  EndianU16_NtoB(UInt16 value);
 
  UInt16
  EndianU16_LtoN(UInt16 value);
 
  UInt16
  EndianU16_NtoL(UInt16 value);
 
  UInt16
  EndianU16_LtoB(UInt16 value);
 
  UInt16
  EndianU16_BtoL(UInt16 value);
 
  SInt32
  EndianS32_BtoN(SInt32 value);
 
  SInt32
  EndianS32_NtoB(SInt32 value);
 
  SInt32
  EndianS32_LtoN(SInt32 value);
 
  SInt32
  EndianS32_NtoL(SInt32 value);
 
  SInt32
  EndianS32_LtoB(SInt32 value);
 
  SInt32
  EndianS32_BtoL(SInt32 value);
 
  UInt32
  EndianU32_BtoN(UInt32 value);
 
  UInt32
  EndianU32_NtoB(UInt32 value);
 
  UInt32
  EndianU32_LtoN(UInt32 value);
 
  UInt32
  EndianU32_NtoL(UInt32 value);
 
  UInt32
  EndianU32_LtoB(UInt32 value);
 
  UInt32
  EndianU32_BtoL(UInt32 value);
 
#endif 
#if !TYPE_LONGLONG
#if CALL_NOT_IN_CARBON
  SInt64
  EndianS64_BtoN(SInt64 value);
 
  SInt64
  EndianS64_NtoB(SInt64 value);
 
  SInt64
  EndianS64_LtoN(SInt64 value);
 
  SInt64
  EndianS64_NtoL(SInt64 value);
 
  SInt64
  EndianS64_LtoB(SInt64 value);
 
  SInt64
  EndianS64_BtoL(SInt64 value);
 
  UInt64
  EndianU64_BtoN(UInt64 value);
 
  UInt64
  EndianU64_NtoB(UInt64 value);
 
  UInt64
  EndianU64_LtoN(UInt64 value);
 
  UInt64
  EndianU64_NtoL(UInt64 value);
 
  UInt64
  EndianU64_LtoB(UInt64 value);
 
  UInt64
  EndianU64_BtoL(UInt64 value);
 
#endif 
#endif 
#if TARGET_RT_LITTLE_ENDIAN
  struct BigEndianLong
  {
    long bigEndianValue;
  };
  typedef struct BigEndianLong BigEndianLong;
  struct BigEndianUnsignedLong
  {
    unsigned long bigEndianValue;
  };
  typedef struct BigEndianUnsignedLong BigEndianUnsignedLong;
  struct BigEndianShort
  {
    short bigEndianValue;
  };
  typedef struct BigEndianShort BigEndianShort;
  struct BigEndianUnsignedShort
  {
    unsigned short bigEndianValue;
  };
  typedef struct BigEndianUnsignedShort BigEndianUnsignedShort;
  struct BigEndianFixed
  {
    Fixed bigEndianValue;
  };
  typedef struct BigEndianFixed BigEndianFixed;
  struct BigEndianUnsignedFixed
  {
    UnsignedFixed bigEndianValue;
  };
  typedef struct BigEndianUnsignedFixed BigEndianUnsignedFixed;
  struct BigEndianOSType
  {
    OSType bigEndianValue;
  };
  typedef struct BigEndianOSType BigEndianOSType;
#else
 
typedef long BigEndianLong;
typedef unsigned long BigEndianUnsignedLong;
typedef short BigEndianShort;
typedef unsigned short BigEndianUnsignedShort;
typedef Fixed BigEndianFixed;
typedef UnsignedFixed BigEndianUnsignedFixed;
typedef OSType BigEndianOSType;
#endif 
#if TARGET_RT_BIG_ENDIAN
#define EndianS16_BtoN(value) (value)
#define EndianS16_NtoB(value) (value)
#define EndianU16_BtoN(value) (value)
#define EndianU16_NtoB(value) (value)
#define EndianS32_BtoN(value) (value)
#define EndianS32_NtoB(value) (value)
#define EndianU32_BtoN(value) (value)
#define EndianU32_NtoB(value) (value)
#define EndianS64_BtoN(value) (value)
#define EndianS64_NtoB(value) (value)
#define EndianU64_BtoN(value) (value)
#define EndianU64_NtoB(value) (value)
#else
#define EndianS16_LtoN(value) (value)
#define EndianS16_NtoL(value) (value)
#define EndianU16_LtoN(value) (value)
#define EndianU16_NtoL(value) (value)
#define EndianS32_LtoN(value) (value)
#define EndianS32_NtoL(value) (value)
#define EndianU32_LtoN(value) (value)
#define EndianU32_NtoL(value) (value)
#define EndianS64_LtoN(value) (value)
#define EndianS64_NtoL(value) (value)
#define EndianU64_LtoN(value) (value)
#define EndianU64_NtoL(value) (value)
#endif
 
#if TARGET_RT_BIG_ENDIAN
#define EndianS16_LtoN(value) EndianS16_LtoB(value)
#define EndianS16_NtoL(value) EndianS16_BtoL(value)
#define EndianU16_LtoN(value) EndianU16_LtoB(value)
#define EndianU16_NtoL(value) EndianU16_BtoL(value)
#define EndianS32_LtoN(value) EndianS32_LtoB(value)
#define EndianS32_NtoL(value) EndianS32_BtoL(value)
#define EndianU32_LtoN(value) EndianU32_LtoB(value)
#define EndianU32_NtoL(value) EndianU32_BtoL(value)
#define EndianS64_LtoN(value) EndianS64_LtoB(value)
#define EndianS64_NtoL(value) EndianS64_BtoL(value)
#define EndianU64_LtoN(value) EndianU64_LtoB(value)
#define EndianU64_NtoL(value) EndianU64_BtoL(value)
#else
#define EndianS16_BtoN(value) EndianS16_BtoL(value)
#define EndianS16_NtoB(value) EndianS16_LtoB(value)
#define EndianU16_BtoN(value) EndianU16_BtoL(value)
#define EndianU16_NtoB(value) EndianU16_LtoB(value)
#define EndianS32_BtoN(value) EndianS32_BtoL(value)
#define EndianS32_NtoB(value) EndianS32_LtoB(value)
#define EndianU32_BtoN(value) EndianU32_BtoL(value)
#define EndianU32_NtoB(value) EndianU32_LtoB(value)
#define EndianS64_BtoN(value) EndianS64_BtoL(value)
#define EndianS64_NtoB(value) EndianS64_LtoB(value)
#define EndianU64_BtoN(value) EndianU64_BtoL(value)
#define EndianU64_NtoB(value) EndianU64_LtoB(value)
#endif
 
#define EndianS16_LtoB(value) ((SInt16)Endian16_Swap(value))
#define EndianS16_BtoL(value) ((SInt16)Endian16_Swap(value))
#define EndianU16_LtoB(value) ((UInt16)Endian16_Swap(value))
#define EndianU16_BtoL(value) ((UInt16)Endian16_Swap(value))
#define EndianS32_LtoB(value) ((SInt32)Endian32_Swap(value))
#define EndianS32_BtoL(value) ((SInt32)Endian32_Swap(value))
#define EndianU32_LtoB(value) ((UInt32)Endian32_Swap(value))
#define EndianU32_BtoL(value) ((UInt32)Endian32_Swap(value))
#define EndianS64_LtoB(value) ((SInt64)Endian64_Swap((UInt64)value))
#define EndianS64_BtoL(value) ((SInt64)Endian64_Swap((UInt64)value))
#define EndianU64_LtoB(value) ((UInt64)Endian64_Swap(value))
#define EndianU64_BtoL(value) ((UInt64)Endian64_Swap(value))
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 Endian16_Swap(__D0)
#endif
  UInt16
  Endian16_Swap(UInt16 value);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 Endian32_Swap(__D0)
#endif
  UInt32
  Endian32_Swap(UInt32 value);
 
#endif 
#define Endian16_Swap(value) \
  (((((UInt16)value) << 8) & 0xFF00) | ((((UInt16)value) >> 8) & 0x00FF))
 
#define Endian32_Swap(value)                \
  (((((UInt32)value) << 24) & 0xFF000000) | \
   ((((UInt32)value) << 8) & 0x00FF0000) |  \
   ((((UInt32)value) >> 8) & 0x0000FF00) |  \
   ((((UInt32)value) >> 24) & 0x000000FF))
 
#if TYPE_LONGLONG
#if TARGET_OS_WIN32
  extern UInt64 Endian64_Swap(UInt64 value);
#elif defined(__MWERKS__) && (__MWERKS__ < 0x1800)
#define Endian64_Swap(value)                        \
  (((((UInt64)value) << 56) & 0xFF00000000000000) | \
   ((((UInt64)value) << 40) & 0x00FF000000000000) | \
   ((((UInt64)value) << 24) & 0x0000FF0000000000) | \
   ((((UInt64)value) << 8) & 0x000000FF00000000) |  \
   ((((UInt64)value) >> 8) & 0x00000000FF000000) |  \
   ((((UInt64)value) >> 24) & 0x0000000000FF0000) | \
   ((((UInt64)value) >> 40) & 0x000000000000FF00) | \
   ((((UInt64)value) >> 56) & 0x00000000000000FF))
#else
#define Endian64_Swap(value)                           \
  (((((UInt64)value) << 56) & 0xFF00000000000000ULL) | \
   ((((UInt64)value) << 40) & 0x00FF000000000000ULL) | \
   ((((UInt64)value) << 24) & 0x0000FF0000000000ULL) | \
   ((((UInt64)value) << 8) & 0x000000FF00000000ULL) |  \
   ((((UInt64)value) >> 8) & 0x00000000FF000000ULL) |  \
   ((((UInt64)value) >> 24) & 0x0000000000FF0000ULL) | \
   ((((UInt64)value) >> 40) & 0x000000000000FF00ULL) | \
   ((((UInt64)value) >> 56) & 0x00000000000000FFULL))
#endif
#else
#ifdef __cplusplus
inline static UInt64 Endian64_Swap(UInt64 value)
{
  UInt64 temp;
  ((UnsignedWide *)&temp)->lo = Endian32_Swap(((UnsignedWide *)&value)->hi);
  ((UnsignedWide *)&temp)->hi = Endian32_Swap(((UnsignedWide *)&value)->lo);
  return temp;
}
#else
#if CALL_NOT_IN_CARBON
UInt64
Endian64_Swap(UInt64 value);
 
#endif 
#endif
#endif 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif