CommonServices.h   [plain text]


/*
 * Copyright (c) 1997-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * 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@

    Change History (most recent first):
    
$Log: CommonServices.h,v $
Revision 1.3  2004/04/08 09:27:12  bradley
Added macro for portable specification of callback calling conventions.

Revision 1.2  2004/03/07 05:53:39  bradley
Fixed NumVersion extraction macros. Updated error code mappings to match latest internal version.

Revision 1.1  2004/01/30 02:25:59  bradley
Common Services and portability support for various platforms.

*/

//---------------------------------------------------------------------------------------------------------------------------
/*!	@header		CommonServices
	
	Common Services for Mac OS X, Linux, Palm, VxWorks, Windows, and Windows CE.
*/

#ifndef	__COMMON_SERVICES__
#define	__COMMON_SERVICES__

#ifdef	__cplusplus
	extern "C" {
#endif

#if 0
#pragma mark == Target ==
#endif

//===========================================================================================================================
//	 Target
//===========================================================================================================================

// Macintosh

#if( !defined( TARGET_OS_MAC ) )
	#if( ( macintosh || __MACH__ ) && !KERNEL )
		// ConditionalMacros.h in CoreServices will define this TARGET_* flag.
	#else
		#define	TARGET_OS_MAC			0
	#endif
#endif

#if( !defined( TARGET_API_MAC_OSX_KERNEL ) )
	#if( __MACH__ && KERNEL )
		#define	TARGET_API_MAC_OSX_KERNEL		1
	#else
		#define	TARGET_API_MAC_OSX_KERNEL		0
	#endif
#endif

// Linux

#if( !defined( TARGET_OS_LINUX ) )
	#if( defined( __linux__ ) )
		#define	TARGET_OS_LINUX			1
	#else
		#define	TARGET_OS_LINUX			0
	#endif
#endif

// Palm

#if( !defined( TARGET_OS_PALM ) )
	#if( defined( __PALMOS_TRAPS__ ) || defined( __PALMOS_ARMLET__ ) )
		#define	TARGET_OS_PALM			1
	#else
		#define	TARGET_OS_PALM			0
	#endif
#endif

// VxWorks

#if( !defined( TARGET_OS_VXWORKS ) )
	
	// No predefined macro for VxWorks so just assume VxWorks if nothing else is set.
	
	#if( !macintosh && !__MACH__  && !defined( __linux__ ) && !defined( __PALMOS_TRAPS__ ) && !defined( __PALMOS_ARMLET__ ) && !defined( _WIN32 ) )
		#define	TARGET_OS_VXWORKS		1
	#else
		#define	TARGET_OS_VXWORKS		0
	#endif
#endif

// Windows

#if( !defined( TARGET_OS_WIN32 ) )
	#if( macintosh || __MACH__ )
		// ConditionalMacros.h in CoreServices will define this TARGET_* flag.
	#else			
		#if( defined( _WIN32 ) )
			#define	TARGET_OS_WIN32		1
		#else
			#define	TARGET_OS_WIN32		0
		#endif
	#endif
#endif

// Windows CE

#if( !defined( TARGET_OS_WINDOWS_CE ) )
	#if( defined( _WIN32_WCE ) )
		#define	TARGET_OS_WINDOWS_CE	1
	#else
		#define	TARGET_OS_WINDOWS_CE	0
	#endif
#endif

#if 0
#pragma mark == Includes ==
#endif

//===========================================================================================================================
//	 Includes
//===========================================================================================================================

#if( !KERNEL )
	#include	<stddef.h>
#endif
	
#if( ( macintosh || __MACH__ ) && !KERNEL )
		
	#if( defined( __MWERKS__ ) )
		#if( __option( c9x ) )
			#include	<stdbool.h>
		#endif
	#else
		#include	<stdbool.h>
	#endif
	
	#include	<stdint.h>
	
	#if( __MACH__ )
		
		// Mac OS X
		
		#include	<sys/types.h>
		#include	<netinet/in.h>
		#include	<arpa/inet.h>
		#include	<fcntl.h>
		#include	<pthread.h>
		#include	<sys/ioctl.h>
		#include	<sys/socket.h>
		#include	<unistd.h>
		
		#include	<CoreServices/CoreServices.h>
	
	#else
		
		// Classic Mac OS
		
		#include	<ConditionalMacros.h>
		#include	<MacTypes.h>
	
	#endif
	
#elif( KERNEL )
	
	// Mac OS X Kernel
	
	#include	<stdint.h>
	
	#include	<libkern/OSTypes.h>
	#include	<sys/types.h>
	
#elif( TARGET_OS_LINUX )
	
	// Linux (no special includes yet).

#elif( TARGET_OS_PALM )
	
	// Palm (no special includes yet).

#elif( TARGET_OS_VXWORKS )
	
	// VxWorks
	
	#include	"vxWorks.h"
	
#elif( TARGET_OS_WIN32 )
	
	// Windows
	
	#if( !defined( WIN32_WINDOWS ) )
		#define	WIN32_WINDOWS		0x0401
	#endif
	
	#if( !defined( _WIN32_WINDOWS ) )
		#define	_WIN32_WINDOWS		0x0401
	#endif
	
	#if( !defined( WIN32_LEAN_AND_MEAN ) )
		#define	WIN32_LEAN_AND_MEAN			// Needed to avoid redefinitions by Windows interfaces.
	#endif
	
	#if( defined( __MWERKS__ ) )
	
		#if( __option( c9x ) )
			#include	<stdbool.h>
		#endif
		
		#include	<stdint.h>
		
	#elif( defined( _MSC_VER ) )
	
		#pragma warning( disable:4127 )		// Disable "conditional expression is constant" warning for debug macros.
		#pragma warning( disable:4706 )		// Disable "assignment within conditional expression" for Microsoft headers.
		
	#endif

	#include	<windows.h>
	#include	<winsock2.h>
	#include	<Ws2tcpip.h>
	
	#if( defined( _MSC_VER ) )
		#pragma warning( default:4706 )
	#endif
	
#else
	#error unknown OS - update this file to support your OS
#endif

#if( !defined( TARGET_BUILD_MAIN ) )
	#if( !TARGET_OS_VXWORKS )
		#define	TARGET_BUILD_MAIN		1
	#endif
#endif

#if( __GNUC__ || !TARGET_OS_VXWORKS )
	#define	TARGET_LANGUAGE_C_LIKE		1
#else
	#define	TARGET_LANGUAGE_C_LIKE		0
#endif

#if 0
#pragma mark == CPU ==
#endif

//===========================================================================================================================
//	CPU
//===========================================================================================================================

// PowerPC

#if( !defined( TARGET_CPU_PPC ) )
	#if( defined( __ppc__ ) || defined( __PPC__ ) || defined( powerpc ) || defined( ppc ) || defined( _M_MPPC ) )
		#define	TARGET_CPU_PPC				1
	#else
		#define	TARGET_CPU_PPC				0
	#endif
#endif

// x86

#if( !defined( TARGET_CPU_X86 ) )
	#if( __INTEL__ || defined( __i386__ ) || defined( i386 ) || defined( intel ) || defined( _M_IX86 ) )
		#define	TARGET_CPU_X86				1
	#else
		#define	TARGET_CPU_X86				0
	#endif
#endif

// MIPS

#if( !defined( TARGET_CPU_MIPS ) )
	#if( __MIPS__ || defined( MIPS32 ) || defined( R3000 ) || defined( R4000 ) || defined( R4650 ) || defined( _M_MRX000 ) )
		#define	TARGET_CPU_MIPS				1
	#else
		#define	TARGET_CPU_MIPS				0
	#endif
#endif

#if( !defined( TARGET_CPU_PPC ) && !defined( TARGET_CPU_X86 ) && !defined( TARGET_CPU_MIPS ) )
	#error unknown CPU - update this file to support your CPU
#endif

#if 0
#pragma mark == Byte Order ==
#endif

//===========================================================================================================================
//	Byte Order
//===========================================================================================================================

// TARGET_RT_LITTLE_ENDIAN

#if( !defined( TARGET_RT_LITTLE_ENDIAN ) )
	#if( MIPSEL || IL_LITTLE_ENDIAN || defined( __LITTLE_ENDIAN__ ) 										|| \
		 ( defined(   BYTE_ORDER ) && defined(   LITTLE_ENDIAN ) && (   BYTE_ORDER ==   LITTLE_ENDIAN ) )	|| \
		 ( defined(  _BYTE_ORDER ) && defined(  _LITTLE_ENDIAN ) && (  _BYTE_ORDER ==  _LITTLE_ENDIAN ) )	|| \
		 ( defined( __BYTE_ORDER ) && defined( __LITTLE_ENDIAN ) && ( __BYTE_ORDER == __LITTLE_ENDIAN ) )	|| \
		 TARGET_CPU_X86 || ( defined( TARGET_RT_BIG_ENDIAN ) && !TARGET_RT_BIG_ENDIAN ) )
		#define	TARGET_RT_LITTLE_ENDIAN		1
	#else
		#define	TARGET_RT_LITTLE_ENDIAN		0
	#endif
#endif

// TARGET_RT_BIG_ENDIAN

#if( !defined( TARGET_RT_BIG_ENDIAN ) )
	#if( MIPSEB || IL_BIG_ENDIAN || defined( __BIG_ENDIAN__ ) 										|| \
		 ( defined(   BYTE_ORDER ) && defined(   BIG_ENDIAN ) && (   BYTE_ORDER ==   BIG_ENDIAN ) )	|| \
		 ( defined(  _BYTE_ORDER ) && defined(  _BIG_ENDIAN ) && (  _BYTE_ORDER ==  _BIG_ENDIAN ) )	|| \
		 ( defined( __BYTE_ORDER ) && defined( __BIG_ENDIAN ) && ( __BYTE_ORDER == __BIG_ENDIAN ) )	|| \
		( defined( TARGET_RT_LITTLE_ENDIAN ) && !TARGET_RT_LITTLE_ENDIAN ) )
		#define	TARGET_RT_BIG_ENDIAN		1
	#else
		#define	TARGET_RT_BIG_ENDIAN		0
	#endif
#endif

#if( defined( TARGET_RT_LITTLE_ENDIAN ) && !defined( TARGET_RT_BIG_ENDIAN ) )
	#if( TARGET_RT_LITTLE_ENDIAN )
		#define	TARGET_RT_BIG_ENDIAN		0
	#else
		#define	TARGET_RT_BIG_ENDIAN		1
	#endif
#endif

#if( defined( TARGET_RT_BIG_ENDIAN ) && !defined( TARGET_RT_LITTLE_ENDIAN ) )
	#if( TARGET_RT_BIG_ENDIAN )
		#define	TARGET_RT_LITTLE_ENDIAN		0
	#else
		#define	TARGET_RT_LITTLE_ENDIAN		1
	#endif
#endif

#if( !defined( TARGET_RT_LITTLE_ENDIAN ) || !defined( TARGET_RT_BIG_ENDIAN ) )
	#error unknown byte order - update this file to support your byte order
#endif

// TARGET_RT_BYTE_ORDER

#if( !defined( TARGET_RT_BYTE_ORDER_BIG_ENDIAN ) )
	#define	TARGET_RT_BYTE_ORDER_BIG_ENDIAN			1234
#endif

#if( !defined( TARGET_RT_BYTE_ORDER_LITTLE_ENDIAN ) )
	#define	TARGET_RT_BYTE_ORDER_LITTLE_ENDIAN		4321
#endif

#if( !defined( TARGET_RT_BYTE_ORDER ) )
	#if( TARGET_RT_LITTLE_ENDIAN )
		#define	TARGET_RT_BYTE_ORDER				TARGET_RT_BYTE_ORDER_LITTLE_ENDIAN
	#else
		#define	TARGET_RT_BYTE_ORDER				TARGET_RT_BYTE_ORDER_BIG_ENDIAN
	#endif
#endif

#if 0
#pragma mark == Constants ==
#endif

//===========================================================================================================================
//	Constants
//===========================================================================================================================

#if( !TARGET_OS_MAC )
	#define CR		'\r'
#endif

#define LF			'\n'
#define	CRSTR		"\r"
#define	LFSTR		"\n"
#define CRLF		"\r\n"
#define CRCR 		"\r\r"

#if 0
#pragma mark == Compatibility ==
#endif

//===========================================================================================================================
//	Compatibility
//===========================================================================================================================

// Macros to allow the same code to work on Windows and other sockets API-compatible platforms.

#if( TARGET_OS_WIN32 )
	#define	close_compat( X )		closesocket( X )
	#define	errno_compat()			(int) GetLastError()
	#define	set_errno_compat( X )	SetLastError( X )
	#define	EWOULDBLOCK_compat		WSAEWOULDBLOCK
	#define	ETIMEDOUT_compat		WSAETIMEDOUT
	#define	ENOTCONN_compat			WSAENOTCONN
	#define	IsValidSocket( X )		( ( X ) != INVALID_SOCKET )
	#define	kInvalidSocketRef		INVALID_SOCKET
	#if( TARGET_LANGUAGE_C_LIKE )
		typedef SOCKET				SocketRef;
	#endif
#else
	#define	close_compat( X )		close( X )
	#define	errno_compat()			errno
	#define	set_errno_compat( X )	do { errno = ( X ); } while( 0 )
	#define	EWOULDBLOCK_compat		EWOULDBLOCK
	#define	ETIMEDOUT_compat		ETIMEDOUT
	#define	ENOTCONN_compat			ENOTCONN
	#define	IsValidSocket( X )		( ( X ) >= 0 )
	#define	kInvalidSocketRef		-1
	#if( TARGET_LANGUAGE_C_LIKE )
		typedef int					SocketRef;
	#endif
#endif

// socklen_t is not defined on the following platforms so emulate it if not defined:
// 
// - Pre-Panther Mac OS X. Panther defines SO_NOADDRERR so trigger off that.
// - Windows SDK prior to 2003. 2003+ SDK's define EAI_AGAIN so trigger off that.
// - VxWorks

#if( TARGET_LANGUAGE_C_LIKE )
	#if( ( TARGET_OS_MAC && !defined( SO_NOADDRERR ) ) || ( TARGET_OS_WIN32 && !defined( EAI_AGAIN ) ) || TARGET_OS_VXWORKS )
		typedef int						socklen_t;
	#endif
#endif

// ssize_t is not defined on the following platforms so emulate it if not defined:
// 
// - Mac OS X when not building with BSD headers
// - Windows

#if( TARGET_LANGUAGE_C_LIKE )
	#if( ( TARGET_OS_WIN32 || !defined( _BSD_SSIZE_T_DEFINED_ ) ) && !TARGET_OS_VXWORKS )
		typedef int						ssize_t;
	#endif
#endif

// sockaddr_storage is not supported on non-IPv6 machines so alias it to an IPv4-compatible structure.

#if( TARGET_LANGUAGE_C_LIKE )
	#if( !defined( AF_INET6 ) )
		#define	sockaddr_storage		sockaddr_in
		#define	ss_family				sin_family
	#endif
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	SOCKADDR_IS_IP_LOOPBACK
	
	@abstract	Determines if a sockaddr is an IPv4 or IPv6 loopback address (if IPv6 is supported).
*/

#if( defined( AF_INET6 ) )
	#define	SOCKADDR_IS_IP_LOOPBACK( SA )															\
		( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )   							\
		? ( ( (const struct sockaddr_in *)( SA ) )->sin_addr.s_addr == htonl( INADDR_LOOPBACK ) )	\
		: ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET6 ) 							\
			? IN6_IS_ADDR_LOOPBACK( &( (const struct sockaddr_in6 *)( SA ) )->sin6_addr ) 			\
			: 0
#else
	#define	SOCKADDR_IS_IP_LOOPBACK( SA )															\
		( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )  								\
		? ( ( (const struct sockaddr_in *)( SA ) )->sin_addr.s_addr == htonl( INADDR_LOOPBACK ) ) 	\
		: 0
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	SOCKADDR_IS_IP_LINK_LOCAL
	
	@abstract	Determines if a sockaddr is an IPv4 or IPv6 link-local address (if IPv6 is supported).
*/

#if( defined( AF_INET6 ) )
	#define	SOCKADDR_IS_IP_LINK_LOCAL( SA )																\
		( ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )   								\
		  ? ( ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 0 ] == 169 ) && 	\
			  ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 1 ] == 254 ) )	\
		  : IN6_IS_ADDR_LOOPBACK( &( (const struct sockaddr_in6 *)( SA ) )->sin6_addr ) )
#else
	#define	SOCKADDR_IS_IP_LINK_LOCAL( SA )																\
		( ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )   								\
		  ? ( ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 0 ] == 169 ) && 	\
			  ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 1 ] == 254 ) )	\
		  : 0 )
#endif

// _beginthreadex and _endthreadex are not supported on Windows CE 2.1 or later (the C runtime issues with leaking 
// resources have apparently been resolved and they seem to have just ripped out support for the API) so map it to 
// CreateThread on Windows CE.

#if( TARGET_OS_WINDOWS_CE )
	#define	_beginthreadex_compat( SECURITY_PTR, STACK_SIZE, START_ADDRESS, ARG_LIST, FLAGS, THREAD_ID_PTR )			\
		(uintptr_t) CreateThread( SECURITY_PTR, STACK_SIZE, (LPTHREAD_START_ROUTINE) START_ADDRESS, ARG_LIST, FLAGS, 	\
					  (LPDWORD) THREAD_ID_PTR )
	
	#define	_endthreadex_compat( RESULT )		ExitThread( (DWORD) RESULT )
#elif( TARGET_OS_WIN32 )
	#define	_beginthreadex_compat				_beginthreadex
	#define	_endthreadex_compat					_endthreadex
#endif

// The C99 "inline" keyword is not supported by Microsoft compilers, but they do support __inline so map it when needed.

#if( defined( _MSC_VER ) )
	#define	inline_compat		__inline
#else
	#define	inline_compat		inline
#endif

// Calling conventions 

#if( !defined( CALLBACK_COMPAT ) )
	#if( TARGET_OS_WIN32 || TARGET_OS_WINDOWS_CE )
		#define	CALLBACK_COMPAT		CALLBACK
	#else
		#define	CALLBACK_COMPAT
	#endif
#endif

#if 0
#pragma mark == Macros ==
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	kSizeCString

	@abstract	A meta-value to pass to supported routines to indicate the size should be calculated with strlen.
*/

#define	kSizeCString		( (size_t) -1 )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	sizeof_array
	
	@abstract	Determines the number of elements in an array.
*/

#define	sizeof_array( X )		( sizeof( X ) / sizeof( X[ 0 ] ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	sizeof_element
	
	@abstract	Determines the size of an array element.
*/

#define	sizeof_element( X )		sizeof( X[ 0 ] )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	sizeof_string
	
	@abstract	Determines the size of a constant C string, excluding the null terminator.
*/

#define	sizeof_string( X )		( sizeof( ( X ) ) - 1 )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	sizeof_field
	
	@abstract	Determines the size of a field of a type.
*/

#define	sizeof_field( TYPE, FIELD )		sizeof( ( ( (TYPE *) 0 )->FIELD ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	RoundUp

	@abstract	Rounds X up to a multiple of Y.
*/

#define	RoundUp( X, Y )		( ( X ) + ( ( Y ) - ( ( X ) % ( Y ) ) ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	IsAligned

	@abstract	Returns non-zero if X is aligned to a Y byte boundary and 0 if not. Y must be a power of 2.
*/

#define	IsAligned( X, Y )		( ( ( X ) & ( ( Y ) - 1 ) ) == 0 )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	IsFieldAligned

	@abstract	Returns non-zero if FIELD of type TYPE is aligned to a Y byte boundary and 0 if not. Y must be a power of 2.
*/

#define	IsFieldAligned( X, TYPE, FIELD, Y )		IsAligned( ( (uintptr_t)( X ) ) + offsetof( TYPE, FIELD ), ( Y ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	AlignDown

	@abstract	Aligns X down to a Y byte boundary. Y must be a power of 2.
*/

#define	AlignDown( X, Y )		( ( X ) & ~( ( Y ) - 1 ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	AlignUp

	@abstract	Aligns X up to a Y byte boundary. Y must be a power of 2.
*/

#define	AlignUp( X, Y )		( ( ( X ) + ( ( Y ) - 1 ) ) & ~( ( Y ) - 1 ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	Min

	@abstract	Returns the lesser of X and Y.
*/

#if( !defined( Min ) )
	#define	Min( X, Y )		( ( ( X ) < ( Y ) ) ? ( X ) : ( Y ) )
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	Max

	@abstract	Returns the greater of X and Y.
*/

#if( !defined( Max ) )
	#define	Max( X, Y )		( ( ( X ) > ( Y ) ) ? ( X ) : ( Y ) )
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	InsertBits

	@abstract	Inserts BITS (both 0 and 1 bits) into X, controlled by MASK and SHIFT, and returns the result.
	
	@discussion
	
	MASK is the bitmask of the bits in the final position.
	SHIFT is the number of bits to shift left for 1 to reach the first bit position of MASK.
	
	For example, if you wanted to insert 0x3 into the leftmost 4 bits of a 32-bit value:
	
	InsertBits( 0, 0x3, 0xF0000000U, 28 ) == 0x30000000
*/

#define	InsertBits( X, BITS, MASK, SHIFT )		( ( ( X ) & ~( MASK ) ) | ( ( ( BITS ) << ( SHIFT ) ) & ( MASK ) ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	ExtractBits

	@abstract	Extracts bits from X, controlled by MASK and SHIFT, and returns the result.
	
	@discussion
	
	MASK is the bitmask of the bits in the final position.
	SHIFT is the number of bits to shift right to right justify MASK.
	
	For example, if you had a 32-bit value (e.g. 0x30000000) wanted the left-most 4 bits (e.g. 3 in this example):
	
	ExtractBits( 0x30000000U, 0xF0000000U, 28 ) == 0x3
*/

#define	ExtractBits( X, MASK, SHIFT )			( ( ( X ) >> ( SHIFT ) ) & ( ( MASK ) >> ( SHIFT ) ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	Stringify

	@abstract	Stringify's an expression.
	
	@discussion
	
	Stringify macros to process raw text passed via -D options to C string constants. The double-wrapping is necessary 
	because the C preprocessor doesn't perform its normal argument expansion pre-scan with stringified macros so the 
	-D macro needs to be expanded once via the wrapper macro then stringified so the raw text is stringified. Otherwise, 
	the replacement value would be used instead of the symbolic name (only for preprocessor symbols like #defines).
	
	For example:
	
		#define	kMyConstant		1
		
		printf( "%s", Stringify( kMyConstant ) );			// Prints "kMyConstant"
		printf( "%s", StringifyExpansion( kMyConstant ) );	// Prints "1"
		
	Non-preprocessor symbols do not have this issue. For example:
	
		enum
		{
			kMyConstant = 1
		};
		
		printf( "%s", Stringify( kMyConstant ) );			// Prints "kMyConstant"
		printf( "%s", StringifyExpansion( kMyConstant ) );	// Prints "kMyConstant"
	
	See <http://gcc.gnu.org/onlinedocs/cpp/Argument-Prescan.html> for more info on C preprocessor pre-scanning.
*/

#define	Stringify( X )				# X
#define	StringifyExpansion( X )		Stringify( X )

#if 0
#pragma mark == Types ==
#endif

#if( TARGET_LANGUAGE_C_LIKE )
//===========================================================================================================================
//	 Standard Types
//===========================================================================================================================

#if( !defined( INT8_MIN ) )
	
	#define INT8_MIN					SCHAR_MIN
	
	#if( defined( _MSC_VER ) )

		// C99 stdint.h not supported in VC++/VS.NET yet.

		typedef INT8					int8_t;
		typedef UINT8					uint8_t;
		typedef INT16					int16_t;
		typedef UINT16					uint16_t;
		typedef INT32					int32_t;
		typedef UINT32					uint32_t;
		typedef __int64					int64_t;
		typedef unsigned __int64		uint64_t;
		
	#elif( TARGET_OS_VXWORKS && ( TORNADO_VERSION < 220 ) )
		typedef long long				int64_t;
		typedef unsigned long long		uint64_t;
	#endif
	
	typedef int8_t						int_least8_t;
	typedef int16_t						int_least16_t;
	typedef int32_t						int_least32_t;
	typedef int64_t						int_least64_t;

	typedef uint8_t						uint_least8_t;
	typedef uint16_t					uint_least16_t;
	typedef uint32_t					uint_least32_t;
	typedef uint64_t					uint_least64_t;
	
	typedef int8_t						int_fast8_t;
	typedef int16_t						int_fast16_t;
	typedef int32_t						int_fast32_t;
	typedef int64_t						int_fast64_t;
	
	typedef uint8_t						uint_fast8_t;
	typedef uint16_t					uint_fast16_t;
	typedef uint32_t					uint_fast32_t;
	typedef uint64_t					uint_fast64_t;

	#if( !defined( _MSC_VER ) || TARGET_OS_WINDOWS_CE )
		typedef long int				intptr_t;
		typedef unsigned long int		uintptr_t;
	#endif

#endif

// Macros for minimum-width integer constants

#if( !defined( INT8_C ) )
	#define INT8_C( value )			value
#endif

#if( !defined( INT16_C ) )
	#define INT16_C( value )		value
#endif

#if( !defined( INT32_C ) )
	#define INT32_C( value )		value ## L
#endif

#if( !defined( INT64_C ) )
	#if( defined( _MSC_VER ) )
		#define INT64_C( value )	value ## i64
	#else
		#define INT64_C( value )	value ## LL
	#endif
#endif

#if( !defined( UINT8_C ) )
	#define UINT8_C( value )		value ## U
#endif

#if( !defined( UINT16_C ) )
	#define UINT16_C( value )		value ## U
#endif

#if( !defined( UINT32_C ) )
	#define UINT32_C( value )		value ## UL
#endif

#if( !defined( UINT64_C ) )
	#if( defined( _MSC_VER ) )
		#define UINT64_C( value )	value ## UI64
	#else
		#define UINT64_C( value )	value ## ULL
	#endif
#endif

#if 0
#pragma mark == bool ==
#endif

//===========================================================================================================================
//	 Boolean Constants and Types
//===========================================================================================================================

// C++ defines bool, true, and false. Metrowerks allows this to be controlled by the "bool" option though.
// C99 defines __bool_true_false_are_defined when bool, true, and false are defined.
// MacTypes.h defines true and false (Mac builds only).
// 
// Note: The Metrowerks has to be in its own block because Microsoft Visual Studio .NET does not completely 
// short-circuit and gets confused by the option( bool ) portion of the conditional.

#if( defined( __MWERKS__ ) )
	
	// Note: The following test is done on separate lines because CodeWarrior doesn't like it all on one line.
	
	#if( !__bool_true_false_are_defined && ( !defined( __cplusplus ) || !__option( bool ) ) )
		#define	COMMON_SERVICES_NEEDS_BOOL		1
	#else
		#define	COMMON_SERVICES_NEEDS_BOOL		0
	#endif
	
	// Workaround when building with CodeWarrior, but using the Apple stdbool.h header, which uses _Bool.
	
	#if( __bool_true_false_are_defined && !defined( __cplusplus ) && !__option( c9x ) )
		#define _Bool	int
	#endif
	
	// Workaround when building with CodeWarrior for C++ with bool disabled and using the Apple stdbool.h header, 
	// which defines true and false to map to C++ true and false (which are not enabled). Serenity Now!
	
	#if( __bool_true_false_are_defined && defined( __cplusplus ) && !__option( bool ) )
		#define	true	1
		#define	false	0
	#endif
#else
	#define	COMMON_SERVICES_NEEDS_BOOL			( !defined( __cplusplus ) && !__bool_true_false_are_defined )
#endif

#if( COMMON_SERVICES_NEEDS_BOOL )
	
	typedef int		bool;
	
	#define	bool	bool
	
	#if( !defined( __MACTYPES__ ) && !defined( true ) && !defined( false ) )
		#define true	1
		#define false	0
	#endif
	
	#define __bool_true_false_are_defined		1
#endif

// IOKit IOTypes.h typedef's bool if TYPE_BOOL is not defined so define it here to prevent redefinition by IOTypes.h.

#if( TARGET_API_MAC_OSX_KERNEL )
	#define TYPE_BOOL		1
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@typedef	CStr255
	
	@abstract	255 character null-terminated (C-style) string.
*/

#if( TARGET_LANGUAGE_C_LIKE )
	typedef char	CStr255[ 256 ];
#endif

#endif	// TARGET_LANGUAGE_C_LIKE

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	TYPE_LONGLONG_NATIVE

	@abstract	Defines whether long long (or its equivalent) is natively supported or requires special libraries.
*/

#if( !defined( TYPE_LONGLONG_NATIVE ) )
	#if( !TARGET_OS_VXWORKS )
		#define	TYPE_LONGLONG_NATIVE			1
	#else
		#define	TYPE_LONGLONG_NATIVE			0
	#endif
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	long_long_compat

	@abstract	Compatibility type to map to the closest thing to long long and unsigned long long.
	
	@discussion
	
	Neither long long nor unsigned long long are supported by Microsoft compilers, but they do support proprietary
	"__int64" and "unsigned __int64" equivalents so map to those types if the real long long is not supported.
*/

#if( TARGET_LANGUAGE_C_LIKE )
	#if( TARGET_OS_WIN32 )
		typedef __int64					long_long_compat;
		typedef unsigned __int64		unsigned_long_long_compat;
	#else
		typedef signed long long		long_long_compat;
		typedef unsigned long long		unsigned_long_long_compat;
	#endif
#endif

#if 0
#pragma mark == Errors ==
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@enum		OSStatus

	@abstract	Status Code
	
	@constant	kNoErr						    0 No error occurred.
	@constant	kInProgressErr				    1 Operation in progress.
	@constant	kUnknownErr					-6700 Unknown error occurred.
	@constant	kOptionErr					-6701 Option was not acceptable.
	@constant	kSelectorErr				-6702 Selector passed in is invalid or unknown.
	@constant	kExecutionStateErr			-6703 Call made in the wrong execution state (e.g. called at interrupt time).
	@constant	kPathErr					-6704 Path is invalid, too long, or otherwise not usable.
	@constant	kParamErr					-6705 Parameter is incorrect, missing, or not appropriate.
	@constant	kParamCountErr				-6706 Incorrect or unsupported number of parameters.
	@constant	kCommandErr					-6707 Command invalid or not supported.
	@constant	kIDErr						-6708 Unknown, invalid, or inappropriate identifier.
	@constant	kStateErr					-6709 Not in appropriate state to perform operation.
	@constant	kRangeErr					-6710 Index is out of range or not valid.
	@constant	kRequestErr					-6711 Request was improperly formed or not appropriate.
	@constant	kResponseErr				-6712 Response was incorrect or out of sequence.
	@constant	kChecksumErr				-6713 Checksum does not match the actual data.
	@constant	kNotHandledErr				-6714 Operation was not handled (or not handled completely).
	@constant	kVersionErr					-6715 Version is not incorrect or not compatibile.
	@constant	kSignatureErr				-6716 Signature did not match what was expected.
	@constant	kFormatErr					-6717 Unknown, invalid, or inappropriate file/data format.
	@constant	kNotInitializedErr			-6718 Action request before needed services were initialized.
	@constant	kAlreadyInitializedErr		-6719 Attempt made to initialize when already initialized.
	@constant	kNotInUseErr				-6720 Object not in use (e.g. cannot abort if not already in use).
	@constant	kInUseErr					-6721 Object is in use (e.g. cannot reuse active param blocks).
	@constant	kTimeoutErr					-6722 Timeout occurred.
	@constant	kCanceledErr				-6723 Operation canceled (successful cancel).
	@constant	kAlreadyCanceledErr			-6724 Operation has already been canceled.
	@constant	kCannotCancelErr			-6725 Operation could not be canceled (maybe already done or invalid).
	@constant	kDeletedErr					-6726 Object has already been deleted.
	@constant	kNotFoundErr				-6727 Something was not found.
	@constant	kNoMemoryErr				-6728 Not enough memory was available to perform the operation.
	@constant	kNoResourcesErr				-6729 Resources unavailable to perform the operation.
	@constant	kDuplicateErr				-6730 Duplicate found or something is a duplicate.
	@constant	kImmutableErr				-6731 Entity is not changeable.
	@constant	kUnsupportedDataErr			-6732 Data is unknown or not supported.
	@constant	kIntegrityErr				-6733 Data is corrupt.
	@constant	kIncompatibleErr			-6734 Data is not compatible or it is in an incompatible format.
	@constant	kUnsupportedErr				-6735 Feature or option is not supported.
	@constant	kUnexpectedErr				-6736 Error occurred that was not expected.
	@constant	kValueErr					-6737 Value is not appropriate.
	@constant	kNotReadableErr				-6738 Could not read or reading is not allowed.
	@constant	kNotWritableErr				-6739 Could not write or writing is not allowed.
	@constant	kBadReferenceErr			-6740 An invalid or inappropriate reference was specified.
	@constant	kFlagErr					-6741 An invalid, inappropriate, or unsupported flag was specified.
	@constant	kMalformedErr				-6742 Something was not formed correctly.
	@constant	kSizeErr					-6743 Size was too big, too small, or not appropriate.
	@constant	kNameErr					-6744 Name was not correct, allowed, or appropriate.
	@constant	kNotReadyErr				-6745 Device or service is not ready.
	@constant	kReadErr					-6746 Could not read.
	@constant	kWriteErr					-6747 Could not write.
	@constant	kMismatchErr				-6748 Something does not match.
	@constant	kDateErr					-6749 Date is invalid or out-of-range.
	@constant	kUnderrunErr				-6750 Less data than expected.
	@constant	kOverrunErr					-6751 More data than expected.
	@constant	kEndingErr					-6752 Connection, session, or something is ending.
	@constant	kConnectionErr				-6753 Connection failed or could not be established.
	@constant	kAuthenticationErr			-6754 Authentication failed or is not supported.
	@constant	kOpenErr					-6755 Could not open file, pipe, device, etc.
	@constant	kTypeErr					-6756 Incorrect or incompatible type (e.g. file, data, etc.).
	@constant	kSkipErr					-6757 Items should be or was skipped.
	@constant	kNoAckErr					-6758 No acknowledge.
	@constant	kCollisionErr				-6759 Collision occurred (e.g. two on bus at same time).
	@constant	kBackoffErr					-6760 Backoff in progress and operation intentionally failed.
	@constant	kNoAddressAckErr			-6761 No acknowledge of address.
	@constant	kBusyErr					-6762 Cannot perform because something is busy.
	@constant	kNoSpaceErr					-6763 Not enough space to perform operation.
*/

#if( TARGET_LANGUAGE_C_LIKE )
	#if( !TARGET_OS_MAC && !TARGET_API_MAC_OSX_KERNEL )
		typedef int32_t		OSStatus;
	#endif
#endif

#define kNoErr						0
#define kInProgressErr				1

// Generic error codes are in the range -6700 to -6779.

#define kGenericErrorBase			-6700	// Starting error code for all generic errors.
	
#define kUnknownErr					-6700
#define kOptionErr					-6701
#define kSelectorErr				-6702
#define kExecutionStateErr			-6703
#define kPathErr					-6704
#define kParamErr					-6705
#define kParamCountErr				-6706
#define kCommandErr					-6707
#define kIDErr						-6708
#define kStateErr					-6709
#define kRangeErr					-6710
#define kRequestErr					-6711
#define kResponseErr				-6712
#define kChecksumErr				-6713
#define kNotHandledErr				-6714
#define kVersionErr					-6715
#define kSignatureErr				-6716
#define kFormatErr					-6717
#define kNotInitializedErr			-6718
#define kAlreadyInitializedErr		-6719
#define kNotInUseErr				-6720
#define kInUseErr					-6721
#define kTimeoutErr					-6722
#define kCanceledErr				-6723
#define kAlreadyCanceledErr			-6724
#define kCannotCancelErr			-6725
#define kDeletedErr					-6726
#define kNotFoundErr				-6727
#define kNoMemoryErr				-6728
#define kNoResourcesErr				-6729
#define kDuplicateErr				-6730
#define kImmutableErr				-6731
#define kUnsupportedDataErr			-6732
#define kIntegrityErr				-6733
#define kIncompatibleErr			-6734
#define kUnsupportedErr				-6735
#define kUnexpectedErr				-6736
#define kValueErr					-6737
#define kNotReadableErr				-6738
#define kNotWritableErr				-6739
#define	kBadReferenceErr			-6740
#define	kFlagErr					-6741
#define	kMalformedErr				-6742
#define	kSizeErr					-6743
#define	kNameErr					-6744
#define	kNotReadyErr				-6745
#define	kReadErr					-6746
#define	kWriteErr					-6747
#define	kMismatchErr				-6748
#define	kDateErr					-6749
#define	kUnderrunErr				-6750
#define	kOverrunErr					-6751
#define	kEndingErr					-6752
#define	kConnectionErr				-6753
#define	kAuthenticationErr			-6754
#define	kOpenErr					-6755
#define	kTypeErr					-6756
#define	kSkipErr					-6757
#define	kNoAckErr					-6758
#define	kCollisionErr				-6759
#define	kBackoffErr					-6760
#define	kNoAddressAckErr			-6761
#define	kBusyErr					-6762
#define	kNoSpaceErr					-6763

#define kGenericErrorEnd			-6779	// Last generic error code (inclusive)

#if 0
#pragma mark == Mac Compatibility ==
#endif

//===========================================================================================================================
//	Mac Compatibility
//===========================================================================================================================

//---------------------------------------------------------------------------------------------------------------------------
/*!	@enum		Duration
	
	@abstract	Type used to specify a duration of time.
	
	@constant	kDurationImmediate			Indicates no delay/wait time.
	@constant	kDurationMicrosecond		Microsecond units.
	@constant	kDurationMillisecond		Millisecond units.
	@constant	kDurationSecond				Second units.
	@constant	kDurationMinute				Minute units.
	@constant	kDurationHour				Hour units.
	@constant	kDurationDay				Day units.
	@constant	kDurationForever			Infinite period of time (no timeout).

	@discussion 
	
	Duration values are intended to be multiplied by the specific interval to achieve an actual duration. For example, 
	to wait for 5 seconds you would use "5 * kDurationSecond".
*/

#if( TARGET_LANGUAGE_C_LIKE )
	#if( !TARGET_OS_MAC )
		typedef	int32_t		Duration;
	#endif
#endif

#define	kDurationImmediate				0L
#define	kDurationMicrosecond			-1L
#define	kDurationMillisecond			1L
#define	kDurationSecond					( 1000L * kDurationMillisecond )
#define	kDurationMinute					( 60L * kDurationSecond )
#define	kDurationHour					( 60L * kDurationMinute )
#define	kDurationDay					( 24L * kDurationHour )
#define	kDurationForever				0x7FFFFFFFL

// Seconds <-> Minutes <-> Hours <-> Days <-> Weeks <-> Months <-> Years conversions

#define kNanosecondsPerMicrosecond		1000
#define kNanosecondsPerMillisecond		1000000
#define kNanosecondsPerSecond			1000000000
#define kMicrosecondsPerSecond			1000000
#define kMicrosecondsPerMillisecond		1000
#define kMillisecondsPerSecond			1000
#define kSecondsPerMinute				60
#define kSecondsPerHour					( 60 * 60 )				// 3600
#define kSecondsPerDay					( 60 * 60 * 24 )		// 86400
#define kSecondsPerWeek					( 60 * 60 * 24 * 7 )	// 604800
#define kMinutesPerHour					60
#define kMinutesPerDay					( 60 * 24 )				// 1440
#define kHoursPerDay					24
#define kDaysPerWeek					7
#define kWeeksPerYear					52
#define kMonthsPerYear					12

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	VersionStages

	@abstract	NumVersion-style version stages.
*/

#define	kVersionStageDevelopment		0x20
#define	kVersionStageAlpha				0x40
#define	kVersionStageBeta				0x60
#define	kVersionStageFinal				0x80

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	NumVersionBuild

	@abstract	Builds a 32-bit Mac-style NumVersion value (e.g. NumVersionBuild( 1, 2, 3, kVersionStageBeta, 4 ) -> 1.2.3b4).
*/

#define	NumVersionBuild( MAJOR, MINOR, BUGFIX, STAGE, REV )	\
	( ( ( ( MAJOR )  & 0xFF ) << 24 ) |						\
	  ( ( ( MINOR )  & 0x0F ) << 20 ) |						\
	  ( ( ( BUGFIX ) & 0x0F ) << 16 ) |						\
	  ( ( ( STAGE )  & 0xFF ) <<  8 ) |						\
	  ( ( ( REV )    & 0xFF )       ) )

#define	NumVersionExtractMajor( VERSION )				( (uint8_t)( ( ( VERSION ) >> 24 ) & 0xFF ) )
#define	NumVersionExtractMinorAndBugFix( VERSION )		( (uint8_t)( ( ( VERSION ) >> 16 ) & 0xFF ) )
#define	NumVersionExtractMinor( VERSION )				( (uint8_t)( ( ( VERSION ) >> 20 ) & 0x0F ) )
#define	NumVersionExtractBugFix( VERSION )				( (uint8_t)( ( ( VERSION ) >> 16 ) & 0x0F ) )
#define	NumVersionExtractStage( VERSION )				( (uint8_t)( ( ( VERSION ) >>  8 ) & 0xFF ) )
#define	NumVersionExtractRevision( VERSION )			( (uint8_t)(   ( VERSION )         & 0xFF ) )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	NumVersionCompare

	@abstract	Compares two NumVersion values and returns the following values:
	
		left < right -> -1
		left > right ->  1
		left = right ->  0
*/

#if( TARGET_LANGUAGE_C_LIKE )
	int	NumVersionCompare( uint32_t inLeft, uint32_t inRight );
#endif

#if 0
#pragma mark == Binary Constants ==
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	binary_4
	
	@abstract	Macro to generate an 4-bit constant using binary notation (e.g. binary_4( 1010 ) == 0xA).
*/

#define	binary_4( a )						binary_4_hex_wrap( hex_digit4( a ) )
#define binary_4_hex_wrap( a )				binary_4_hex( a )
#define binary_4_hex( a )					( 0x ## a )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	binary_8
	
	@abstract	Macro to generate an 8-bit constant using binary notation (e.g. binary_8( 01111011 ) == 0x7B).
*/

#define	binary_8( a )						binary_8_hex_wrap( hex_digit8( a ) )
#define binary_8_hex_wrap( a )				binary_8_hex( a )
#define binary_8_hex( a )					( 0x ## a )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	binary_16
	
	@abstract	Macro to generate an 16-bit constant using binary notation (e.g. binary_16( 01111011, 01111011 ) == 0x7B7B).
*/

#define	binary_16( a, b )					binary_16_hex_wrap( hex_digit8( a ), hex_digit8( b ) )
#define binary_16_hex_wrap( a, b )			binary_16_hex( a, b )
#define binary_16_hex( a, b )				( 0x ## a ## b )

//---------------------------------------------------------------------------------------------------------------------------
/*!	@defined	binary_32
	
	@abstract	Macro to generate an 32-bit constant using binary notation 
				(e.g. binary_32( 01111011, 01111011, 01111011, 01111011 ) == 0x7B7B7B7B).
*/

#define	binary_32( a, b, c, d )				binary_32_hex_wrap( hex_digit8( a ), hex_digit8( b ), hex_digit8( c ), hex_digit8( d ) )
#define binary_32_hex_wrap( a, b, c, d )	binary_32_hex( a, b, c, d )
#define binary_32_hex( a, b, c, d )			( 0x ## a ## b ## c ## d )

// Binary Constant Helpers

#define hex_digit8( a )						HEX_DIGIT_ ## a
#define hex_digit4( a )						HEX_DIGIT_ ## 0000 ## a

#define HEX_DIGIT_00000000					00
#define HEX_DIGIT_00000001					01
#define HEX_DIGIT_00000010					02
#define HEX_DIGIT_00000011					03
#define HEX_DIGIT_00000100					04
#define HEX_DIGIT_00000101					05
#define HEX_DIGIT_00000110					06
#define HEX_DIGIT_00000111					07
#define HEX_DIGIT_00001000					08
#define HEX_DIGIT_00001001					09
#define HEX_DIGIT_00001010					0A
#define HEX_DIGIT_00001011					0B
#define HEX_DIGIT_00001100					0C
#define HEX_DIGIT_00001101					0D
#define HEX_DIGIT_00001110					0E
#define HEX_DIGIT_00001111					0F
#define HEX_DIGIT_00010000					10
#define HEX_DIGIT_00010001					11
#define HEX_DIGIT_00010010					12
#define HEX_DIGIT_00010011					13
#define HEX_DIGIT_00010100					14
#define HEX_DIGIT_00010101					15
#define HEX_DIGIT_00010110					16
#define HEX_DIGIT_00010111					17
#define HEX_DIGIT_00011000					18
#define HEX_DIGIT_00011001					19
#define HEX_DIGIT_00011010					1A
#define HEX_DIGIT_00011011					1B
#define HEX_DIGIT_00011100					1C
#define HEX_DIGIT_00011101					1D
#define HEX_DIGIT_00011110					1E
#define HEX_DIGIT_00011111					1F
#define HEX_DIGIT_00100000					20
#define HEX_DIGIT_00100001					21
#define HEX_DIGIT_00100010					22
#define HEX_DIGIT_00100011					23
#define HEX_DIGIT_00100100					24
#define HEX_DIGIT_00100101					25
#define HEX_DIGIT_00100110					26
#define HEX_DIGIT_00100111					27
#define HEX_DIGIT_00101000					28
#define HEX_DIGIT_00101001					29
#define HEX_DIGIT_00101010					2A
#define HEX_DIGIT_00101011					2B
#define HEX_DIGIT_00101100					2C
#define HEX_DIGIT_00101101					2D
#define HEX_DIGIT_00101110					2E
#define HEX_DIGIT_00101111					2F
#define HEX_DIGIT_00110000					30
#define HEX_DIGIT_00110001					31
#define HEX_DIGIT_00110010					32
#define HEX_DIGIT_00110011					33
#define HEX_DIGIT_00110100					34
#define HEX_DIGIT_00110101					35
#define HEX_DIGIT_00110110					36
#define HEX_DIGIT_00110111					37
#define HEX_DIGIT_00111000					38
#define HEX_DIGIT_00111001					39
#define HEX_DIGIT_00111010					3A
#define HEX_DIGIT_00111011					3B
#define HEX_DIGIT_00111100					3C
#define HEX_DIGIT_00111101					3D
#define HEX_DIGIT_00111110					3E
#define HEX_DIGIT_00111111					3F
#define HEX_DIGIT_01000000					40
#define HEX_DIGIT_01000001					41
#define HEX_DIGIT_01000010					42
#define HEX_DIGIT_01000011					43
#define HEX_DIGIT_01000100					44
#define HEX_DIGIT_01000101					45
#define HEX_DIGIT_01000110					46
#define HEX_DIGIT_01000111					47
#define HEX_DIGIT_01001000					48
#define HEX_DIGIT_01001001					49
#define HEX_DIGIT_01001010					4A
#define HEX_DIGIT_01001011					4B
#define HEX_DIGIT_01001100					4C
#define HEX_DIGIT_01001101					4D
#define HEX_DIGIT_01001110					4E
#define HEX_DIGIT_01001111					4F
#define HEX_DIGIT_01010000					50
#define HEX_DIGIT_01010001					51
#define HEX_DIGIT_01010010					52
#define HEX_DIGIT_01010011					53
#define HEX_DIGIT_01010100					54
#define HEX_DIGIT_01010101					55
#define HEX_DIGIT_01010110					56
#define HEX_DIGIT_01010111					57
#define HEX_DIGIT_01011000					58
#define HEX_DIGIT_01011001					59
#define HEX_DIGIT_01011010					5A
#define HEX_DIGIT_01011011					5B
#define HEX_DIGIT_01011100					5C
#define HEX_DIGIT_01011101					5D
#define HEX_DIGIT_01011110					5E
#define HEX_DIGIT_01011111					5F
#define HEX_DIGIT_01100000					60
#define HEX_DIGIT_01100001					61
#define HEX_DIGIT_01100010					62
#define HEX_DIGIT_01100011					63
#define HEX_DIGIT_01100100					64
#define HEX_DIGIT_01100101					65
#define HEX_DIGIT_01100110					66
#define HEX_DIGIT_01100111					67
#define HEX_DIGIT_01101000					68
#define HEX_DIGIT_01101001					69
#define HEX_DIGIT_01101010					6A
#define HEX_DIGIT_01101011					6B
#define HEX_DIGIT_01101100					6C
#define HEX_DIGIT_01101101					6D
#define HEX_DIGIT_01101110					6E
#define HEX_DIGIT_01101111					6F
#define HEX_DIGIT_01110000					70
#define HEX_DIGIT_01110001					71
#define HEX_DIGIT_01110010					72
#define HEX_DIGIT_01110011					73
#define HEX_DIGIT_01110100					74
#define HEX_DIGIT_01110101					75
#define HEX_DIGIT_01110110					76
#define HEX_DIGIT_01110111					77
#define HEX_DIGIT_01111000					78
#define HEX_DIGIT_01111001					79
#define HEX_DIGIT_01111010					7A
#define HEX_DIGIT_01111011					7B
#define HEX_DIGIT_01111100					7C
#define HEX_DIGIT_01111101					7D
#define HEX_DIGIT_01111110					7E
#define HEX_DIGIT_01111111					7F
#define HEX_DIGIT_10000000					80
#define HEX_DIGIT_10000001					81
#define HEX_DIGIT_10000010					82
#define HEX_DIGIT_10000011					83
#define HEX_DIGIT_10000100					84
#define HEX_DIGIT_10000101					85
#define HEX_DIGIT_10000110					86
#define HEX_DIGIT_10000111					87
#define HEX_DIGIT_10001000					88
#define HEX_DIGIT_10001001					89
#define HEX_DIGIT_10001010					8A
#define HEX_DIGIT_10001011					8B
#define HEX_DIGIT_10001100					8C
#define HEX_DIGIT_10001101					8D
#define HEX_DIGIT_10001110					8E
#define HEX_DIGIT_10001111					8F
#define HEX_DIGIT_10010000					90
#define HEX_DIGIT_10010001					91
#define HEX_DIGIT_10010010					92
#define HEX_DIGIT_10010011					93
#define HEX_DIGIT_10010100					94
#define HEX_DIGIT_10010101					95
#define HEX_DIGIT_10010110					96
#define HEX_DIGIT_10010111					97
#define HEX_DIGIT_10011000					98
#define HEX_DIGIT_10011001					99
#define HEX_DIGIT_10011010					9A
#define HEX_DIGIT_10011011					9B
#define HEX_DIGIT_10011100					9C
#define HEX_DIGIT_10011101					9D
#define HEX_DIGIT_10011110					9E
#define HEX_DIGIT_10011111					9F
#define HEX_DIGIT_10100000					A0
#define HEX_DIGIT_10100001					A1
#define HEX_DIGIT_10100010					A2
#define HEX_DIGIT_10100011					A3
#define HEX_DIGIT_10100100					A4
#define HEX_DIGIT_10100101					A5
#define HEX_DIGIT_10100110					A6
#define HEX_DIGIT_10100111					A7
#define HEX_DIGIT_10101000					A8
#define HEX_DIGIT_10101001					A9
#define HEX_DIGIT_10101010					AA
#define HEX_DIGIT_10101011					AB
#define HEX_DIGIT_10101100					AC
#define HEX_DIGIT_10101101					AD
#define HEX_DIGIT_10101110					AE
#define HEX_DIGIT_10101111					AF
#define HEX_DIGIT_10110000					B0
#define HEX_DIGIT_10110001					B1
#define HEX_DIGIT_10110010					B2
#define HEX_DIGIT_10110011					B3
#define HEX_DIGIT_10110100					B4
#define HEX_DIGIT_10110101					B5
#define HEX_DIGIT_10110110					B6
#define HEX_DIGIT_10110111					B7
#define HEX_DIGIT_10111000					B8
#define HEX_DIGIT_10111001					B9
#define HEX_DIGIT_10111010					BA
#define HEX_DIGIT_10111011					BB
#define HEX_DIGIT_10111100					BC
#define HEX_DIGIT_10111101					BD
#define HEX_DIGIT_10111110					BE
#define HEX_DIGIT_10111111					BF
#define HEX_DIGIT_11000000					C0
#define HEX_DIGIT_11000001					C1
#define HEX_DIGIT_11000010					C2
#define HEX_DIGIT_11000011					C3
#define HEX_DIGIT_11000100					C4
#define HEX_DIGIT_11000101					C5
#define HEX_DIGIT_11000110					C6
#define HEX_DIGIT_11000111					C7
#define HEX_DIGIT_11001000					C8
#define HEX_DIGIT_11001001					C9
#define HEX_DIGIT_11001010					CA
#define HEX_DIGIT_11001011					CB
#define HEX_DIGIT_11001100					CC
#define HEX_DIGIT_11001101					CD
#define HEX_DIGIT_11001110					CE
#define HEX_DIGIT_11001111					CF
#define HEX_DIGIT_11010000					D0
#define HEX_DIGIT_11010001					D1
#define HEX_DIGIT_11010010					D2
#define HEX_DIGIT_11010011					D3
#define HEX_DIGIT_11010100					D4
#define HEX_DIGIT_11010101					D5
#define HEX_DIGIT_11010110					D6
#define HEX_DIGIT_11010111					D7
#define HEX_DIGIT_11011000					D8
#define HEX_DIGIT_11011001					D9
#define HEX_DIGIT_11011010					DA
#define HEX_DIGIT_11011011					DB
#define HEX_DIGIT_11011100					DC
#define HEX_DIGIT_11011101					DD
#define HEX_DIGIT_11011110					DE
#define HEX_DIGIT_11011111					DF
#define HEX_DIGIT_11100000					E0
#define HEX_DIGIT_11100001					E1
#define HEX_DIGIT_11100010					E2
#define HEX_DIGIT_11100011					E3
#define HEX_DIGIT_11100100					E4
#define HEX_DIGIT_11100101					E5
#define HEX_DIGIT_11100110					E6
#define HEX_DIGIT_11100111					E7
#define HEX_DIGIT_11101000					E8
#define HEX_DIGIT_11101001					E9
#define HEX_DIGIT_11101010					EA
#define HEX_DIGIT_11101011					EB
#define HEX_DIGIT_11101100					EC
#define HEX_DIGIT_11101101					ED
#define HEX_DIGIT_11101110					EE
#define HEX_DIGIT_11101111					EF
#define HEX_DIGIT_11110000					F0
#define HEX_DIGIT_11110001					F1
#define HEX_DIGIT_11110010					F2
#define HEX_DIGIT_11110011					F3
#define HEX_DIGIT_11110100					F4
#define HEX_DIGIT_11110101					F5
#define HEX_DIGIT_11110110					F6
#define HEX_DIGIT_11110111					F7
#define HEX_DIGIT_11111000					F8
#define HEX_DIGIT_11111001					F9
#define HEX_DIGIT_11111010					FA
#define HEX_DIGIT_11111011					FB
#define HEX_DIGIT_11111100					FC
#define HEX_DIGIT_11111101					FD
#define HEX_DIGIT_11111110					FE
#define HEX_DIGIT_11111111					FF

#if 0
#pragma mark == Debugging ==
#endif

//---------------------------------------------------------------------------------------------------------------------------
/*!	@function	CommonServicesTest

	@abstract	Unit test.
*/

#if( DEBUG )
	#if( TARGET_LANGUAGE_C_LIKE )
		OSStatus	CommonServicesTest( void );
	#endif
#endif

#ifdef	__cplusplus
	}
#endif

#endif	// __COMMON_SERVICES__