| /* |
| * Copyright (c) 2008-2009 Brent Fulgham <bfulgham@gmail.org>. All rights reserved. |
| * |
| * This source code is a modified version of the CoreFoundation sources released by Apple Inc. under |
| * the terms of the APSL version 2.0 (see below). |
| * |
| * For information about changes from the original Apple source release can be found by reviewing the |
| * source control system for the project at https://sourceforge.net/svn/?group_id=246198. |
| * |
| * The original license information is as follows: |
| * |
| * Copyright (c) 2008 Apple Inc. All rights reserved. |
| * |
| * @APPLE_LICENSE_HEADER_START@ |
| * |
| * This file contains Original Code and/or Modifications of Original Code |
| * as defined in and that are subject to the Apple Public Source License |
| * Version 2.0 (the 'License'). You may not use this file except in |
| * compliance with the License. Please obtain a copy of the License at |
| * http://www.opensource.apple.com/apsl/ and read it before using this |
| * file. |
| * |
| * The Original Code and all software distributed under the License are |
| * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
| * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
| * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
| * Please see the License for the specific language governing rights and |
| * limitations under the License. |
| * |
| * @APPLE_LICENSE_HEADER_END@ |
| */ |
| /* CFByteOrder.h |
| Copyright (c) 1995-2007, Apple Inc. All rights reserved. |
| */ |
| |
| #if !defined(__COREFOUNDATION_CFBYTEORDER__) |
| #define __COREFOUNDATION_CFBYTEORDER__ 1 |
| |
| #include <CoreFoundation/CFBase.h> |
| #if defined(__MACH__) && !defined(CF_USE_OSBYTEORDER_H) |
| #include <libkern/OSByteOrder.h> |
| #define CF_USE_OSBYTEORDER_H 1 |
| #endif |
| |
| CF_EXTERN_C_BEGIN |
| |
| enum __CFByteOrder { |
| CFByteOrderUnknown, |
| CFByteOrderLittleEndian, |
| CFByteOrderBigEndian |
| }; |
| typedef CFIndex CFByteOrder; |
| |
| CF_INLINE CFByteOrder CFByteOrderGetCurrent(void) { |
| #if CF_USE_OSBYTEORDER_H |
| int32_t byteOrder = OSHostByteOrder(); |
| switch (byteOrder) { |
| case OSLittleEndian: return CFByteOrderLittleEndian; |
| case OSBigEndian: return CFByteOrderBigEndian; |
| default: break; |
| } |
| return CFByteOrderUnknown; |
| #else |
| #if __LITTLE_ENDIAN__ |
| return CFByteOrderLittleEndian; |
| #elif __BIG_ENDIAN__ |
| return CFByteOrderBigEndian; |
| #else |
| return CFByteOrderUnknown; |
| #endif |
| #endif |
| } |
| |
| CF_INLINE uint16_t CFSwapInt16(uint16_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapInt16(arg); |
| #else |
| uint16_t result; |
| result = (uint16_t)(((arg << 8) & 0xFF00) | ((arg >> 8) & 0xFF)); |
| return result; |
| #endif |
| } |
| |
| CF_INLINE uint32_t CFSwapInt32(uint32_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapInt32(arg); |
| #else |
| uint32_t result; |
| result = ((arg & 0xFF) << 24) | ((arg & 0xFF00) << 8) | ((arg >> 8) & 0xFF00) | ((arg >> 24) & 0xFF); |
| return result; |
| #endif |
| } |
| |
| CF_INLINE uint64_t CFSwapInt64(uint64_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapInt64(arg); |
| #else |
| union CFSwap { |
| uint64_t sv; |
| uint32_t ul[2]; |
| } tmp, result; |
| tmp.sv = arg; |
| result.ul[0] = CFSwapInt32(tmp.ul[1]); |
| result.ul[1] = CFSwapInt32(tmp.ul[0]); |
| return result.sv; |
| #endif |
| } |
| |
| CF_INLINE uint16_t CFSwapInt16BigToHost(uint16_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapBigToHostInt16(arg); |
| #elif __BIG_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt16(arg); |
| #endif |
| } |
| |
| CF_INLINE uint32_t CFSwapInt32BigToHost(uint32_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapBigToHostInt32(arg); |
| #elif __BIG_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt32(arg); |
| #endif |
| } |
| |
| CF_INLINE uint64_t CFSwapInt64BigToHost(uint64_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapBigToHostInt64(arg); |
| #elif __BIG_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt64(arg); |
| #endif |
| } |
| |
| CF_INLINE uint16_t CFSwapInt16HostToBig(uint16_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapHostToBigInt16(arg); |
| #elif __BIG_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt16(arg); |
| #endif |
| } |
| |
| CF_INLINE uint32_t CFSwapInt32HostToBig(uint32_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapHostToBigInt32(arg); |
| #elif __BIG_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt32(arg); |
| #endif |
| } |
| |
| CF_INLINE uint64_t CFSwapInt64HostToBig(uint64_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapHostToBigInt64(arg); |
| #elif __BIG_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt64(arg); |
| #endif |
| } |
| |
| CF_INLINE uint16_t CFSwapInt16LittleToHost(uint16_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapLittleToHostInt16(arg); |
| #elif __LITTLE_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt16(arg); |
| #endif |
| } |
| |
| CF_INLINE uint32_t CFSwapInt32LittleToHost(uint32_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapLittleToHostInt32(arg); |
| #elif __LITTLE_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt32(arg); |
| #endif |
| } |
| |
| CF_INLINE uint64_t CFSwapInt64LittleToHost(uint64_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapLittleToHostInt64(arg); |
| #elif __LITTLE_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt64(arg); |
| #endif |
| } |
| |
| CF_INLINE uint16_t CFSwapInt16HostToLittle(uint16_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapHostToLittleInt16(arg); |
| #elif __LITTLE_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt16(arg); |
| #endif |
| } |
| |
| CF_INLINE uint32_t CFSwapInt32HostToLittle(uint32_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapHostToLittleInt32(arg); |
| #elif __LITTLE_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt32(arg); |
| #endif |
| } |
| |
| CF_INLINE uint64_t CFSwapInt64HostToLittle(uint64_t arg) { |
| #if CF_USE_OSBYTEORDER_H |
| return OSSwapHostToLittleInt64(arg); |
| #elif __LITTLE_ENDIAN__ |
| return arg; |
| #else |
| return CFSwapInt64(arg); |
| #endif |
| } |
| |
| typedef struct {uint32_t v;} CFSwappedFloat32; |
| typedef struct {uint64_t v;} CFSwappedFloat64; |
| |
| CF_INLINE CFSwappedFloat32 CFConvertFloat32HostToSwapped(Float32 arg) { |
| union CFSwap { |
| Float32 v; |
| CFSwappedFloat32 sv; |
| } result; |
| result.v = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt32(result.sv.v); |
| #endif |
| return result.sv; |
| } |
| |
| CF_INLINE Float32 CFConvertFloat32SwappedToHost(CFSwappedFloat32 arg) { |
| union CFSwap { |
| Float32 v; |
| CFSwappedFloat32 sv; |
| } result; |
| result.sv = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt32(result.sv.v); |
| #endif |
| return result.v; |
| } |
| |
| CF_INLINE CFSwappedFloat64 CFConvertFloat64HostToSwapped(Float64 arg) { |
| union CFSwap { |
| Float64 v; |
| CFSwappedFloat64 sv; |
| } result; |
| result.v = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt64(result.sv.v); |
| #endif |
| return result.sv; |
| } |
| |
| CF_INLINE Float64 CFConvertFloat64SwappedToHost(CFSwappedFloat64 arg) { |
| union CFSwap { |
| Float64 v; |
| CFSwappedFloat64 sv; |
| } result; |
| result.sv = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt64(result.sv.v); |
| #endif |
| return result.v; |
| } |
| |
| CF_INLINE CFSwappedFloat32 CFConvertFloatHostToSwapped(float arg) { |
| union CFSwap { |
| float v; |
| CFSwappedFloat32 sv; |
| } result; |
| result.v = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt32(result.sv.v); |
| #endif |
| return result.sv; |
| } |
| |
| CF_INLINE float CFConvertFloatSwappedToHost(CFSwappedFloat32 arg) { |
| union CFSwap { |
| float v; |
| CFSwappedFloat32 sv; |
| } result; |
| result.sv = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt32(result.sv.v); |
| #endif |
| return result.v; |
| } |
| |
| CF_INLINE CFSwappedFloat64 CFConvertDoubleHostToSwapped(double arg) { |
| union CFSwap { |
| double v; |
| CFSwappedFloat64 sv; |
| } result; |
| result.v = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt64(result.sv.v); |
| #endif |
| return result.sv; |
| } |
| |
| CF_INLINE double CFConvertDoubleSwappedToHost(CFSwappedFloat64 arg) { |
| union CFSwap { |
| double v; |
| CFSwappedFloat64 sv; |
| } result; |
| result.sv = arg; |
| #if __LITTLE_ENDIAN__ |
| result.sv.v = CFSwapInt64(result.sv.v); |
| #endif |
| return result.v; |
| } |
| |
| CF_EXTERN_C_END |
| |
| #endif /* ! __COREFOUNDATION_CFBYTEORDER__ */ |
| |