• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* -*- Mode: C; tab-width: 4 -*-
2  *
3  * Copyright (c) 1997-2004 Apple Computer, Inc. All rights reserved.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 //---------------------------------------------------------------------------------------------------------------------------
19 /*!	@header		CommonServices
20 
21 	Common Services for Mac OS X, Linux, Palm, VxWorks, Windows, and Windows CE.
22 */
23 
24 #ifndef	__COMMON_SERVICES__
25 #define	__COMMON_SERVICES__
26 
27 #ifdef	__cplusplus
28 	extern "C" {
29 #endif
30 
31 #if 0
32 #pragma mark == Target ==
33 #endif
34 
35 //===========================================================================================================================
36 //	 Target
37 //===========================================================================================================================
38 
39 // Macintosh
40 
41 #if( !defined( TARGET_OS_MAC ) )
42 	#if( ( macintosh || __MACH__ ) && !KERNEL )
43 		// ConditionalMacros.h in CoreServices will define this TARGET_* flag.
44 	#else
45 		#define	TARGET_OS_MAC			0
46 	#endif
47 #endif
48 
49 #if( !defined( TARGET_API_MAC_OSX_KERNEL ) )
50 	#if( __MACH__ && KERNEL )
51 		#define	TARGET_API_MAC_OSX_KERNEL		1
52 	#else
53 		#define	TARGET_API_MAC_OSX_KERNEL		0
54 	#endif
55 #endif
56 
57 // FreeBSD
58 
59 #if( !defined( TARGET_OS_FREEBSD ) )
60 	#if( defined( __FreeBSD__ ) )
61 		#define TARGET_OS_FREEBSD		1
62 	#else
63 		#define TARGET_OS_FREEBSD		0
64 	#endif
65 #endif
66 
67 // Linux
68 
69 #if( !defined( TARGET_OS_LINUX ) )
70 	#if( defined( __linux__ ) )
71 		#define	TARGET_OS_LINUX			1
72 	#else
73 		#define	TARGET_OS_LINUX			0
74 	#endif
75 #endif
76 
77 // Solaris
78 
79 #if( !defined( TARGET_OS_SOLARIS ) )
80 	#if( defined(solaris) || (defined(__SVR4) && defined(sun)) )
81 		#define	TARGET_OS_SOLARIS		1
82 	#else
83 		#define	TARGET_OS_SOLARIS		0
84 	#endif
85 #endif
86 
87 // Palm
88 
89 #if( !defined( TARGET_OS_PALM ) )
90 	#if( defined( __PALMOS_TRAPS__ ) || defined( __PALMOS_ARMLET__ ) )
91 		#define	TARGET_OS_PALM			1
92 	#else
93 		#define	TARGET_OS_PALM			0
94 	#endif
95 #endif
96 
97 // VxWorks
98 
99 #if( !defined( TARGET_OS_VXWORKS ) )
100 
101 	// No predefined macro for VxWorks so just assume VxWorks if nothing else is set.
102 
103 	#if( !macintosh && !__MACH__  && !defined( __FreeBSD__ ) && !defined( __linux__ ) && !defined ( __SVR4 ) && !defined ( __sun ) && !defined( __PALMOS_TRAPS__ ) && !defined( __PALMOS_ARMLET__ ) && !defined( _WIN32 ) )
104 		#define	TARGET_OS_VXWORKS		1
105 	#else
106 		#define	TARGET_OS_VXWORKS		0
107 	#endif
108 #endif
109 
110 // Windows
111 
112 #if( !defined( TARGET_OS_WIN32 ) )
113 	#if( macintosh || __MACH__ )
114 		// ConditionalMacros.h in CoreServices will define this TARGET_* flag.
115 	#else
116 		#if( defined( _WIN32 ) )
117 			#define	TARGET_OS_WIN32		1
118 		#else
119 			#define	TARGET_OS_WIN32		0
120 		#endif
121 	#endif
122 #endif
123 
124 // Windows CE
125 
126 #if( !defined( TARGET_OS_WINDOWS_CE ) )
127 	#if( defined( _WIN32_WCE ) )
128 		#define	TARGET_OS_WINDOWS_CE	1
129 	#else
130 		#define	TARGET_OS_WINDOWS_CE	0
131 	#endif
132 #endif
133 
134 #if 0
135 #pragma mark == Includes ==
136 #endif
137 
138 //===========================================================================================================================
139 //	 Includes
140 //===========================================================================================================================
141 
142 #if( !KERNEL )
143 	#if defined(WIN32) && !defined(_WSPIAPI_COUNTOF)
144 		#define _WSPIAPI_COUNTOF(_Array) (sizeof(_Array) / sizeof(_Array[0]))
145 	#endif
146 	#include	<stddef.h>
147 #endif
148 
149 #if( ( macintosh || __MACH__ ) && !KERNEL )
150 
151 	#if( defined( __MWERKS__ ) )
152 		#if( __option( c9x ) )
153 			#include	<stdbool.h>
154 		#endif
155 	#else
156 		#include	<stdbool.h>
157 	#endif
158 
159 	#include	<stdint.h>
160 
161 	#if( __MACH__ )
162 
163 		// Mac OS X
164 
165 		#include	<sys/types.h>
166 		#include	<netinet/in.h>
167 		#include	<arpa/inet.h>
168 		#include	<fcntl.h>
169 		#include	<pthread.h>
170 		#include	<sys/ioctl.h>
171 		#include	<sys/socket.h>
172 		#include	<unistd.h>
173 
174 	#else
175 
176 		// Classic Mac OS
177 
178 		#include	<ConditionalMacros.h>
179 		#include	<MacTypes.h>
180 
181 	#endif
182 
183 #elif( KERNEL )
184 
185 	// Mac OS X Kernel
186 
187 	#include	<stdint.h>
188 
189 	#include	<libkern/OSTypes.h>
190 	#include	<sys/types.h>
191 
192 #elif( TARGET_OS_FREEBSD )
193 
194 	// FreeBSD
195 	#include	<stdint.h>
196 	#include	<pthread.h>
197 	#include	<netinet/in.h>
198 	#include	<arpa/inet.h>
199 	#include	<sys/socket.h>
200 
201 #elif( TARGET_OS_LINUX )
202 
203 	// Linux
204 
205 	#include	<stdint.h>
206 	#include	<arpa/inet.h>
207 
208 #elif( TARGET_OS_SOLARIS )
209 
210 	// Solaris
211 
212 	#include	<stdint.h>
213 
214 	#include	<arpa/inet.h>
215 	#include	<arpa/nameser.h>
216 
217 	#if ( defined( BYTE_ORDER ) && defined( LITTLE_ENDIAN ) && ( BYTE_ORDER == LITTLE_ENDIAN ) )
218 		#define TARGET_RT_LITTLE_ENDIAN		1
219 	#endif
220 	#if ( defined( BYTE_ORDER ) && defined( BIG_ENDIAN ) && ( BYTE_ORDER == BIG_ENDIAN ) )
221 		#define TARGET_RT_BIG_ENDIAN		1
222 	#endif
223 
224 #elif( TARGET_OS_PALM )
225 
226 	// Palm (no special includes yet).
227 
228 #elif( TARGET_OS_VXWORKS )
229 
230 	// VxWorks
231 
232 	#include	"vxWorks.h"
233 
234 #elif( TARGET_OS_WIN32 )
235 
236 	// Windows
237 
238 	#if( !defined( WIN32_WINDOWS ) )
239 		#define	WIN32_WINDOWS		0x0401
240 	#endif
241 
242 	#if( !defined( _WIN32_WINDOWS ) )
243 		#define	_WIN32_WINDOWS		0x0401
244 	#endif
245 
246 	#if( !defined( WIN32_LEAN_AND_MEAN ) )
247 		#define	WIN32_LEAN_AND_MEAN			// Needed to avoid redefinitions by Windows interfaces.
248 	#endif
249 
250 	#if( defined( __MWERKS__ ) )
251 
252 		#if( __option( c9x ) )
253 			#include	<stdbool.h>
254 		#endif
255 
256 		#include	<stdint.h>
257 
258 	#elif( defined( _MSC_VER ) )
259 
260 		#pragma warning( disable:4127 )		// Disable "conditional expression is constant" warning for debug macros.
261 		#pragma warning( disable:4706 )		// Disable "assignment within conditional expression" for Microsoft headers.
262 
263 	#endif
264 
265 	#include	<windows.h>
266 	#include	<winsock2.h>
267 	#include	<Ws2tcpip.h>
268 
269 	#if( defined( _MSC_VER ) )
270 		#pragma warning( default:4706 )
271 	#endif
272 
273 #else
274 	#error unknown OS - update this file to support your OS
275 #endif
276 
277 #if( !defined( TARGET_BUILD_MAIN ) )
278 	#if( !TARGET_OS_VXWORKS )
279 		#define	TARGET_BUILD_MAIN		1
280 	#endif
281 #endif
282 
283 #if( __GNUC__ || !TARGET_OS_VXWORKS )
284 	#define	TARGET_LANGUAGE_C_LIKE		1
285 #else
286 	#define	TARGET_LANGUAGE_C_LIKE		0
287 #endif
288 
289 #if 0
290 #pragma mark == CPU ==
291 #endif
292 
293 //===========================================================================================================================
294 //	CPU
295 //===========================================================================================================================
296 
297 // PowerPC
298 
299 #if( !defined( TARGET_CPU_PPC ) )
300 	#if( defined( __ppc__ ) || defined( __PPC__ ) || defined( powerpc ) || defined( ppc ) || defined( _M_MPPC ) )
301 		#define	TARGET_CPU_PPC				1
302 	#else
303 		#define	TARGET_CPU_PPC				0
304 	#endif
305 #endif
306 
307 // x86
308 
309 #if( !defined( TARGET_CPU_X86 ) )
310 	#if( __INTEL__ || defined( __i386__ ) || defined( i386 ) || defined( intel ) || defined( _M_IX86 ) )
311 		#define	TARGET_CPU_X86				1
312 	#else
313 		#define	TARGET_CPU_X86				0
314 	#endif
315 #endif
316 
317 // MIPS
318 
319 #if( !defined( TARGET_CPU_MIPS ) )
320 	#if( __MIPS__ || defined( MIPS32 ) || defined( R3000 ) || defined( R4000 ) || defined( R4650 ) || defined( _M_MRX000 ) )
321 		#define	TARGET_CPU_MIPS				1
322 	#else
323 		#define	TARGET_CPU_MIPS				0
324 	#endif
325 #endif
326 
327 #if( !defined( TARGET_CPU_PPC ) && !defined( TARGET_CPU_X86 ) && !defined( TARGET_CPU_MIPS ) )
328 	#error unknown CPU - update this file to support your CPU
329 #endif
330 
331 #if 0
332 #pragma mark == Byte Order ==
333 #endif
334 
335 //===========================================================================================================================
336 //	Byte Order
337 //===========================================================================================================================
338 
339 // TARGET_RT_LITTLE_ENDIAN
340 
341 #if( !defined( TARGET_RT_LITTLE_ENDIAN ) )
342 	#if( MIPSEL || IL_LITTLE_ENDIAN || defined( __LITTLE_ENDIAN__ ) 										|| \
343 		 ( defined(   BYTE_ORDER ) && defined(   LITTLE_ENDIAN ) && (   BYTE_ORDER ==   LITTLE_ENDIAN ) )	|| \
344 		 ( defined(  _BYTE_ORDER ) && defined(  _LITTLE_ENDIAN ) && (  _BYTE_ORDER ==  _LITTLE_ENDIAN ) )	|| \
345 		 ( defined( __BYTE_ORDER ) && defined( __LITTLE_ENDIAN ) && ( __BYTE_ORDER == __LITTLE_ENDIAN ) )	|| \
346 		 TARGET_CPU_X86 || ( defined( TARGET_RT_BIG_ENDIAN ) && !TARGET_RT_BIG_ENDIAN ) )
347 		#define	TARGET_RT_LITTLE_ENDIAN		1
348 	#else
349 		#define	TARGET_RT_LITTLE_ENDIAN		0
350 	#endif
351 #endif
352 
353 // TARGET_RT_BIG_ENDIAN
354 
355 #if( !defined( TARGET_RT_BIG_ENDIAN ) )
356 	#if( MIPSEB || IL_BIG_ENDIAN || defined( __BIG_ENDIAN__ ) 										|| \
357 		 ( defined(   BYTE_ORDER ) && defined(   BIG_ENDIAN ) && (   BYTE_ORDER ==   BIG_ENDIAN ) )	|| \
358 		 ( defined(  _BYTE_ORDER ) && defined(  _BIG_ENDIAN ) && (  _BYTE_ORDER ==  _BIG_ENDIAN ) )	|| \
359 		 ( defined( __BYTE_ORDER ) && defined( __BIG_ENDIAN ) && ( __BYTE_ORDER == __BIG_ENDIAN ) )	|| \
360 		( defined( TARGET_RT_LITTLE_ENDIAN ) && !TARGET_RT_LITTLE_ENDIAN ) )
361 		#define	TARGET_RT_BIG_ENDIAN		1
362 	#else
363 		#define	TARGET_RT_BIG_ENDIAN		0
364 	#endif
365 #endif
366 
367 #if( defined( TARGET_RT_LITTLE_ENDIAN ) && !defined( TARGET_RT_BIG_ENDIAN ) )
368 	#if( TARGET_RT_LITTLE_ENDIAN )
369 		#define	TARGET_RT_BIG_ENDIAN		0
370 	#else
371 		#define	TARGET_RT_BIG_ENDIAN		1
372 	#endif
373 #endif
374 
375 #if( defined( TARGET_RT_BIG_ENDIAN ) && !defined( TARGET_RT_LITTLE_ENDIAN ) )
376 	#if( TARGET_RT_BIG_ENDIAN )
377 		#define	TARGET_RT_LITTLE_ENDIAN		0
378 	#else
379 		#define	TARGET_RT_LITTLE_ENDIAN		1
380 	#endif
381 #endif
382 
383 #if( !defined( TARGET_RT_LITTLE_ENDIAN ) || !defined( TARGET_RT_BIG_ENDIAN ) )
384 	#error unknown byte order - update this file to support your byte order
385 #endif
386 
387 // TARGET_RT_BYTE_ORDER
388 
389 #if( !defined( TARGET_RT_BYTE_ORDER_BIG_ENDIAN ) )
390 	#define	TARGET_RT_BYTE_ORDER_BIG_ENDIAN			1234
391 #endif
392 
393 #if( !defined( TARGET_RT_BYTE_ORDER_LITTLE_ENDIAN ) )
394 	#define	TARGET_RT_BYTE_ORDER_LITTLE_ENDIAN		4321
395 #endif
396 
397 #if( !defined( TARGET_RT_BYTE_ORDER ) )
398 	#if( TARGET_RT_LITTLE_ENDIAN )
399 		#define	TARGET_RT_BYTE_ORDER				TARGET_RT_BYTE_ORDER_LITTLE_ENDIAN
400 	#else
401 		#define	TARGET_RT_BYTE_ORDER				TARGET_RT_BYTE_ORDER_BIG_ENDIAN
402 	#endif
403 #endif
404 
405 #if 0
406 #pragma mark == Constants ==
407 #endif
408 
409 //===========================================================================================================================
410 //	Constants
411 //===========================================================================================================================
412 
413 #if( !TARGET_OS_MAC )
414 	#define CR		'\r'
415 #endif
416 
417 #define LF			'\n'
418 #define	CRSTR		"\r"
419 #define	LFSTR		"\n"
420 #define CRLF		"\r\n"
421 #define CRCR 		"\r\r"
422 
423 #if 0
424 #pragma mark == Compatibility ==
425 #endif
426 
427 //===========================================================================================================================
428 //	Compatibility
429 //===========================================================================================================================
430 
431 // Macros to allow the same code to work on Windows and other sockets API-compatible platforms.
432 
433 #if( TARGET_OS_WIN32 )
434 	#define	close_compat( X )		closesocket( X )
435 	#define	errno_compat()			(int) GetLastError()
436 	#define	set_errno_compat( X )	SetLastError( X )
437 	#define	EWOULDBLOCK_compat		WSAEWOULDBLOCK
438 	#define	ETIMEDOUT_compat		WSAETIMEDOUT
439 	#define	ENOTCONN_compat			WSAENOTCONN
440 	#define	IsValidSocket( X )		( ( X ) != INVALID_SOCKET )
441 	#define	kInvalidSocketRef		INVALID_SOCKET
442 	#if( TARGET_LANGUAGE_C_LIKE )
443 		typedef SOCKET				SocketRef;
444 	#endif
445 #else
446 	#define	close_compat( X )		close( X )
447 	#define	errno_compat()			errno
448 	#define	set_errno_compat( X )	do { errno = ( X ); } while( 0 )
449 	#define	EWOULDBLOCK_compat		EWOULDBLOCK
450 	#define	ETIMEDOUT_compat		ETIMEDOUT
451 	#define	ENOTCONN_compat			ENOTCONN
452 	#define	IsValidSocket( X )		( ( X ) >= 0 )
453 	#define	kInvalidSocketRef		-1
454 	#if( TARGET_LANGUAGE_C_LIKE )
455 		typedef int					SocketRef;
456 	#endif
457 #endif
458 
459 // socklen_t is not defined on the following platforms so emulate it if not defined:
460 //
461 // - Pre-Panther Mac OS X. Panther defines SO_NOADDRERR so trigger off that.
462 // - Windows SDK prior to 2003. 2003+ SDK's define EAI_AGAIN so trigger off that.
463 // - VxWorks
464 
465 #if( TARGET_LANGUAGE_C_LIKE )
466 	#if( ( TARGET_OS_MAC && !defined( SO_NOADDRERR ) ) || ( TARGET_OS_WIN32 && !defined( EAI_AGAIN ) ) || TARGET_OS_VXWORKS )
467 		typedef int						socklen_t;
468 	#endif
469 #endif
470 
471 // ssize_t is not defined on the following platforms so emulate it if not defined:
472 //
473 // - Mac OS X when not building with BSD headers
474 // - Windows
475 
476 #if( TARGET_LANGUAGE_C_LIKE )
477 	#if( !defined(_SSIZE_T) && ( TARGET_OS_WIN32 || !defined( _BSD_SSIZE_T_DEFINED_ ) ) && !TARGET_OS_FREEBSD && !TARGET_OS_LINUX && !TARGET_OS_VXWORKS && !TARGET_OS_MAC)
478 		typedef int						ssize_t;
479 	#endif
480 #endif
481 
482 // sockaddr_storage is not supported on non-IPv6 machines so alias it to an IPv4-compatible structure.
483 
484 #if( TARGET_LANGUAGE_C_LIKE )
485 	#if( !defined( AF_INET6 ) )
486 		#define	sockaddr_storage		sockaddr_in
487 		#define	ss_family				sin_family
488 	#endif
489 #endif
490 
491 //---------------------------------------------------------------------------------------------------------------------------
492 /*!	@defined	SOCKADDR_IS_IP_LOOPBACK
493 
494 	@abstract	Determines if a sockaddr is an IPv4 or IPv6 loopback address (if IPv6 is supported).
495 */
496 
497 #if( defined( AF_INET6 ) )
498 	#define	SOCKADDR_IS_IP_LOOPBACK( SA )															\
499 		( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )   							\
500 		? ( ( (const struct sockaddr_in *)( SA ) )->sin_addr.s_addr == htonl( INADDR_LOOPBACK ) )	\
501 		: ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET6 ) 							\
502 			? IN6_IS_ADDR_LOOPBACK( &( (const struct sockaddr_in6 *)( SA ) )->sin6_addr ) 			\
503 			: 0
504 #else
505 	#define	SOCKADDR_IS_IP_LOOPBACK( SA )															\
506 		( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )  								\
507 		? ( ( (const struct sockaddr_in *)( SA ) )->sin_addr.s_addr == htonl( INADDR_LOOPBACK ) ) 	\
508 		: 0
509 #endif
510 
511 //---------------------------------------------------------------------------------------------------------------------------
512 /*!	@defined	SOCKADDR_IS_IP_LINK_LOCAL
513 
514 	@abstract	Determines if a sockaddr is an IPv4 or IPv6 link-local address (if IPv6 is supported).
515 */
516 
517 #if( defined( AF_INET6 ) )
518 	#define	SOCKADDR_IS_IP_LINK_LOCAL( SA )																\
519 		( ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )   								\
520 		  ? ( ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 0 ] == 169 ) && 	\
521 			  ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 1 ] == 254 ) )	\
522 		  : IN6_IS_ADDR_LOOPBACK( &( (const struct sockaddr_in6 *)( SA ) )->sin6_addr ) )
523 #else
524 	#define	SOCKADDR_IS_IP_LINK_LOCAL( SA )																\
525 		( ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )   								\
526 		  ? ( ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 0 ] == 169 ) && 	\
527 			  ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 1 ] == 254 ) )	\
528 		  : 0 )
529 #endif
530 
531 // _beginthreadex and _endthreadex are not supported on Windows CE 2.1 or later (the C runtime issues with leaking
532 // resources have apparently been resolved and they seem to have just ripped out support for the API) so map it to
533 // CreateThread on Windows CE.
534 
535 #if( TARGET_OS_WINDOWS_CE )
536 	#define	_beginthreadex_compat( SECURITY_PTR, STACK_SIZE, START_ADDRESS, ARG_LIST, FLAGS, THREAD_ID_PTR )			\
537 		(uintptr_t) CreateThread( SECURITY_PTR, STACK_SIZE, (LPTHREAD_START_ROUTINE) START_ADDRESS, ARG_LIST, FLAGS, 	\
538 					  (LPDWORD) THREAD_ID_PTR )
539 
540 	#define	_endthreadex_compat( RESULT )		ExitThread( (DWORD) RESULT )
541 #elif( TARGET_OS_WIN32 )
542 	#define	_beginthreadex_compat				_beginthreadex
543 	#define	_endthreadex_compat					_endthreadex
544 #endif
545 
546 // The C99 "inline" keyword is not supported by Microsoft compilers, but they do support __inline so map it when needed.
547 
548 #if( defined( _MSC_VER ) )
549 	#define	inline_compat		__inline
550 #else
551 	#define	inline_compat		inline
552 #endif
553 
554 // Calling conventions
555 
556 #if( !defined( CALLBACK_COMPAT ) )
557 	#if( TARGET_OS_WIN32 || TARGET_OS_WINDOWS_CE )
558 		#define	CALLBACK_COMPAT		CALLBACK
559 	#else
560 		#define	CALLBACK_COMPAT
561 	#endif
562 #endif
563 
564 #if 0
565 #pragma mark == Macros ==
566 #endif
567 
568 //---------------------------------------------------------------------------------------------------------------------------
569 /*!	@defined	kSizeCString
570 
571 	@abstract	A meta-value to pass to supported routines to indicate the size should be calculated with strlen.
572 */
573 
574 #define	kSizeCString		( (size_t) -1 )
575 
576 //---------------------------------------------------------------------------------------------------------------------------
577 /*!	@defined	sizeof_array
578 
579 	@abstract	Determines the number of elements in an array.
580 */
581 
582 #define	sizeof_array( X )		( sizeof( X ) / sizeof( X[ 0 ] ) )
583 
584 //---------------------------------------------------------------------------------------------------------------------------
585 /*!	@defined	sizeof_element
586 
587 	@abstract	Determines the size of an array element.
588 */
589 
590 #define	sizeof_element( X )		sizeof( X[ 0 ] )
591 
592 //---------------------------------------------------------------------------------------------------------------------------
593 /*!	@defined	sizeof_string
594 
595 	@abstract	Determines the size of a constant C string, excluding the null terminator.
596 */
597 
598 #define	sizeof_string( X )		( sizeof( ( X ) ) - 1 )
599 
600 //---------------------------------------------------------------------------------------------------------------------------
601 /*!	@defined	sizeof_field
602 
603 	@abstract	Determines the size of a field of a type.
604 */
605 
606 #define	sizeof_field( TYPE, FIELD )		sizeof( ( ( (TYPE *) 0 )->FIELD ) )
607 
608 //---------------------------------------------------------------------------------------------------------------------------
609 /*!	@function	RoundUp
610 
611 	@abstract	Rounds X up to a multiple of Y.
612 */
613 
614 #define	RoundUp( X, Y )		( ( X ) + ( ( Y ) - ( ( X ) % ( Y ) ) ) )
615 
616 //---------------------------------------------------------------------------------------------------------------------------
617 /*!	@function	IsAligned
618 
619 	@abstract	Returns non-zero if X is aligned to a Y byte boundary and 0 if not. Y must be a power of 2.
620 */
621 
622 #define	IsAligned( X, Y )		( ( ( X ) & ( ( Y ) - 1 ) ) == 0 )
623 
624 //---------------------------------------------------------------------------------------------------------------------------
625 /*!	@function	IsFieldAligned
626 
627 	@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.
628 */
629 
630 #define	IsFieldAligned( X, TYPE, FIELD, Y )		IsAligned( ( (uintptr_t)( X ) ) + offsetof( TYPE, FIELD ), ( Y ) )
631 
632 //---------------------------------------------------------------------------------------------------------------------------
633 /*!	@function	AlignDown
634 
635 	@abstract	Aligns X down to a Y byte boundary. Y must be a power of 2.
636 */
637 
638 #define	AlignDown( X, Y )		( ( X ) & ~( ( Y ) - 1 ) )
639 
640 //---------------------------------------------------------------------------------------------------------------------------
641 /*!	@function	AlignUp
642 
643 	@abstract	Aligns X up to a Y byte boundary. Y must be a power of 2.
644 */
645 
646 #define	AlignUp( X, Y )		( ( ( X ) + ( ( Y ) - 1 ) ) & ~( ( Y ) - 1 ) )
647 
648 //---------------------------------------------------------------------------------------------------------------------------
649 /*!	@function	Min
650 
651 	@abstract	Returns the lesser of X and Y.
652 */
653 
654 #if( !defined( Min ) )
655 	#define	Min( X, Y )		( ( ( X ) < ( Y ) ) ? ( X ) : ( Y ) )
656 #endif
657 
658 //---------------------------------------------------------------------------------------------------------------------------
659 /*!	@function	Max
660 
661 	@abstract	Returns the greater of X and Y.
662 */
663 
664 #if( !defined( Max ) )
665 	#define	Max( X, Y )		( ( ( X ) > ( Y ) ) ? ( X ) : ( Y ) )
666 #endif
667 
668 //---------------------------------------------------------------------------------------------------------------------------
669 /*!	@function	InsertBits
670 
671 	@abstract	Inserts BITS (both 0 and 1 bits) into X, controlled by MASK and SHIFT, and returns the result.
672 
673 	@discussion
674 
675 	MASK is the bitmask of the bits in the final position.
676 	SHIFT is the number of bits to shift left for 1 to reach the first bit position of MASK.
677 
678 	For example, if you wanted to insert 0x3 into the leftmost 4 bits of a 32-bit value:
679 
680 	InsertBits( 0, 0x3, 0xF0000000U, 28 ) == 0x30000000
681 */
682 
683 #define	InsertBits( X, BITS, MASK, SHIFT )		( ( ( X ) & ~( MASK ) ) | ( ( ( BITS ) << ( SHIFT ) ) & ( MASK ) ) )
684 
685 //---------------------------------------------------------------------------------------------------------------------------
686 /*!	@function	ExtractBits
687 
688 	@abstract	Extracts bits from X, controlled by MASK and SHIFT, and returns the result.
689 
690 	@discussion
691 
692 	MASK is the bitmask of the bits in the final position.
693 	SHIFT is the number of bits to shift right to right justify MASK.
694 
695 	For example, if you had a 32-bit value (e.g. 0x30000000) wanted the left-most 4 bits (e.g. 3 in this example):
696 
697 	ExtractBits( 0x30000000U, 0xF0000000U, 28 ) == 0x3
698 */
699 
700 #define	ExtractBits( X, MASK, SHIFT )			( ( ( X ) >> ( SHIFT ) ) & ( ( MASK ) >> ( SHIFT ) ) )
701 
702 //---------------------------------------------------------------------------------------------------------------------------
703 /*!	@function	Stringify
704 
705 	@abstract	Stringify's an expression.
706 
707 	@discussion
708 
709 	Stringify macros to process raw text passed via -D options to C string constants. The double-wrapping is necessary
710 	because the C preprocessor doesn't perform its normal argument expansion pre-scan with stringified macros so the
711 	-D macro needs to be expanded once via the wrapper macro then stringified so the raw text is stringified. Otherwise,
712 	the replacement value would be used instead of the symbolic name (only for preprocessor symbols like #defines).
713 
714 	For example:
715 
716 		#define	kMyConstant		1
717 
718 		printf( "%s", Stringify( kMyConstant ) );			// Prints "kMyConstant"
719 		printf( "%s", StringifyExpansion( kMyConstant ) );	// Prints "1"
720 
721 	Non-preprocessor symbols do not have this issue. For example:
722 
723 		enum
724 		{
725 			kMyConstant = 1
726 		};
727 
728 		printf( "%s", Stringify( kMyConstant ) );			// Prints "kMyConstant"
729 		printf( "%s", StringifyExpansion( kMyConstant ) );	// Prints "kMyConstant"
730 
731 	See <http://gcc.gnu.org/onlinedocs/cpp/Argument-Prescan.html> for more info on C preprocessor pre-scanning.
732 */
733 
734 #define	Stringify( X )				# X
735 #define	StringifyExpansion( X )		Stringify( X )
736 
737 #if 0
738 #pragma mark == Types ==
739 #endif
740 
741 #if( TARGET_LANGUAGE_C_LIKE )
742 //===========================================================================================================================
743 //	 Standard Types
744 //===========================================================================================================================
745 
746 #if( !defined( INT8_MIN ) )
747 
748 	#define INT8_MIN					SCHAR_MIN
749 
750 	#if( defined( _MSC_VER ) )
751 
752 		// C99 stdint.h not supported in VC++/VS.NET yet.
753 
754 		typedef INT8					int8_t;
755 		typedef UINT8					uint8_t;
756 		typedef INT16					int16_t;
757 		typedef UINT16					uint16_t;
758 		typedef INT32					int32_t;
759 		typedef UINT32					uint32_t;
760 		typedef __int64					int64_t;
761 		typedef unsigned __int64		uint64_t;
762 
763 	#elif( TARGET_OS_VXWORKS && ( TORNADO_VERSION < 220 ) )
764 		typedef long long				int64_t;
765 		typedef unsigned long long		uint64_t;
766 	#endif
767 
768 	typedef int8_t						int_least8_t;
769 	typedef int16_t						int_least16_t;
770 	typedef int32_t						int_least32_t;
771 	typedef int64_t						int_least64_t;
772 
773 	typedef uint8_t						uint_least8_t;
774 	typedef uint16_t					uint_least16_t;
775 	typedef uint32_t					uint_least32_t;
776 	typedef uint64_t					uint_least64_t;
777 
778 	typedef int8_t						int_fast8_t;
779 	typedef int16_t						int_fast16_t;
780 	typedef int32_t						int_fast32_t;
781 	typedef int64_t						int_fast64_t;
782 
783 	typedef uint8_t						uint_fast8_t;
784 	typedef uint16_t					uint_fast16_t;
785 	typedef uint32_t					uint_fast32_t;
786 	typedef uint64_t					uint_fast64_t;
787 
788 	#if( !defined( _MSC_VER ) || TARGET_OS_WINDOWS_CE )
789 		typedef long int				intptr_t;
790 		typedef unsigned long int		uintptr_t;
791 	#endif
792 
793 #endif
794 
795 // Macros for minimum-width integer constants
796 
797 #if( !defined( INT8_C ) )
798 	#define INT8_C( value )			value
799 #endif
800 
801 #if( !defined( INT16_C ) )
802 	#define INT16_C( value )		value
803 #endif
804 
805 #if( !defined( INT32_C ) )
806 	#define INT32_C( value )		value ## L
807 #endif
808 
809 #if( !defined( INT64_C ) )
810 	#if( defined( _MSC_VER ) )
811 		#define INT64_C( value )	value ## i64
812 	#else
813 		#define INT64_C( value )	value ## LL
814 	#endif
815 #endif
816 
817 #if( !defined( UINT8_C ) )
818 	#define UINT8_C( value )		value ## U
819 #endif
820 
821 #if( !defined( UINT16_C ) )
822 	#define UINT16_C( value )		value ## U
823 #endif
824 
825 #if( !defined( UINT32_C ) )
826 	#define UINT32_C( value )		value ## UL
827 #endif
828 
829 #if( !defined( UINT64_C ) )
830 	#if( defined( _MSC_VER ) )
831 		#define UINT64_C( value )	value ## UI64
832 	#else
833 		#define UINT64_C( value )	value ## ULL
834 	#endif
835 #endif
836 
837 #if 0
838 #pragma mark == bool ==
839 #endif
840 
841 //===========================================================================================================================
842 //	 Boolean Constants and Types
843 //===========================================================================================================================
844 
845 // C++ defines bool, true, and false. Metrowerks allows this to be controlled by the "bool" option though.
846 // C99 defines __bool_true_false_are_defined when bool, true, and false are defined.
847 // MacTypes.h defines true and false (Mac builds only).
848 //
849 // Note: The Metrowerks has to be in its own block because Microsoft Visual Studio .NET does not completely
850 // short-circuit and gets confused by the option( bool ) portion of the conditional.
851 
852 #if( defined( __MWERKS__ ) )
853 
854 	// Note: The following test is done on separate lines because CodeWarrior doesn't like it all on one line.
855 
856 	#if( !__bool_true_false_are_defined && ( !defined( __cplusplus ) || !__option( bool ) ) )
857 		#define	COMMON_SERVICES_NEEDS_BOOL		1
858 	#else
859 		#define	COMMON_SERVICES_NEEDS_BOOL		0
860 	#endif
861 
862 	// Workaround when building with CodeWarrior, but using the Apple stdbool.h header, which uses _Bool.
863 
864 	#if( __bool_true_false_are_defined && !defined( __cplusplus ) && !__option( c9x ) )
865 		#define _Bool	int
866 	#endif
867 
868 	// Workaround when building with CodeWarrior for C++ with bool disabled and using the Apple stdbool.h header,
869 	// which defines true and false to map to C++ true and false (which are not enabled). Serenity Now!
870 
871 	#if( __bool_true_false_are_defined && defined( __cplusplus ) && !__option( bool ) )
872 		#define	true	1
873 		#define	false	0
874 	#endif
875 #else
876 	#define	COMMON_SERVICES_NEEDS_BOOL			( !defined( __cplusplus ) && !__bool_true_false_are_defined )
877 #endif
878 
879 #if( COMMON_SERVICES_NEEDS_BOOL )
880 
881 	typedef int		bool;
882 
883 	#define	bool	bool
884 
885 	#if( !defined( __MACTYPES__ ) && !defined( true ) && !defined( false ) )
886 		#define true	1
887 		#define false	0
888 	#endif
889 
890 	#define __bool_true_false_are_defined		1
891 #endif
892 
893 // IOKit IOTypes.h typedef's bool if TYPE_BOOL is not defined so define it here to prevent redefinition by IOTypes.h.
894 
895 #if( TARGET_API_MAC_OSX_KERNEL )
896 	#define TYPE_BOOL		1
897 #endif
898 
899 //---------------------------------------------------------------------------------------------------------------------------
900 /*!	@typedef	CStr255
901 
902 	@abstract	255 character null-terminated (C-style) string.
903 */
904 
905 #if( TARGET_LANGUAGE_C_LIKE )
906 	typedef char	CStr255[ 256 ];
907 #endif
908 
909 #endif	// TARGET_LANGUAGE_C_LIKE
910 
911 //---------------------------------------------------------------------------------------------------------------------------
912 /*!	@defined	TYPE_LONGLONG_NATIVE
913 
914 	@abstract	Defines whether long long (or its equivalent) is natively supported or requires special libraries.
915 */
916 
917 #if( !defined( TYPE_LONGLONG_NATIVE ) )
918 	#if( !TARGET_OS_VXWORKS )
919 		#define	TYPE_LONGLONG_NATIVE			1
920 	#else
921 		#define	TYPE_LONGLONG_NATIVE			0
922 	#endif
923 #endif
924 
925 //---------------------------------------------------------------------------------------------------------------------------
926 /*!	@defined	long_long_compat
927 
928 	@abstract	Compatibility type to map to the closest thing to long long and unsigned long long.
929 
930 	@discussion
931 
932 	Neither long long nor unsigned long long are supported by Microsoft compilers, but they do support proprietary
933 	"__int64" and "unsigned __int64" equivalents so map to those types if the real long long is not supported.
934 */
935 
936 #if( TARGET_LANGUAGE_C_LIKE )
937 	#if( TARGET_OS_WIN32 )
938 		typedef __int64					long_long_compat;
939 		typedef unsigned __int64		unsigned_long_long_compat;
940 	#else
941 		typedef signed long long		long_long_compat;
942 		typedef unsigned long long		unsigned_long_long_compat;
943 	#endif
944 #endif
945 
946 #if 0
947 #pragma mark == Errors ==
948 #endif
949 
950 //---------------------------------------------------------------------------------------------------------------------------
951 /*!	@enum		OSStatus
952 
953 	@abstract	Status Code
954 
955 	@constant	kNoErr						    0 No error occurred.
956 	@constant	kInProgressErr				    1 Operation in progress.
957 	@constant	kUnknownErr					-6700 Unknown error occurred.
958 	@constant	kOptionErr					-6701 Option was not acceptable.
959 	@constant	kSelectorErr				-6702 Selector passed in is invalid or unknown.
960 	@constant	kExecutionStateErr			-6703 Call made in the wrong execution state (e.g. called at interrupt time).
961 	@constant	kPathErr					-6704 Path is invalid, too long, or otherwise not usable.
962 	@constant	kParamErr					-6705 Parameter is incorrect, missing, or not appropriate.
963 	@constant	kParamCountErr				-6706 Incorrect or unsupported number of parameters.
964 	@constant	kCommandErr					-6707 Command invalid or not supported.
965 	@constant	kIDErr						-6708 Unknown, invalid, or inappropriate identifier.
966 	@constant	kStateErr					-6709 Not in appropriate state to perform operation.
967 	@constant	kRangeErr					-6710 Index is out of range or not valid.
968 	@constant	kRequestErr					-6711 Request was improperly formed or not appropriate.
969 	@constant	kResponseErr				-6712 Response was incorrect or out of sequence.
970 	@constant	kChecksumErr				-6713 Checksum does not match the actual data.
971 	@constant	kNotHandledErr				-6714 Operation was not handled (or not handled completely).
972 	@constant	kVersionErr					-6715 Version is not incorrect or not compatibile.
973 	@constant	kSignatureErr				-6716 Signature did not match what was expected.
974 	@constant	kFormatErr					-6717 Unknown, invalid, or inappropriate file/data format.
975 	@constant	kNotInitializedErr			-6718 Action request before needed services were initialized.
976 	@constant	kAlreadyInitializedErr		-6719 Attempt made to initialize when already initialized.
977 	@constant	kNotInUseErr				-6720 Object not in use (e.g. cannot abort if not already in use).
978 	@constant	kInUseErr					-6721 Object is in use (e.g. cannot reuse active param blocks).
979 	@constant	kTimeoutErr					-6722 Timeout occurred.
980 	@constant	kCanceledErr				-6723 Operation canceled (successful cancel).
981 	@constant	kAlreadyCanceledErr			-6724 Operation has already been canceled.
982 	@constant	kCannotCancelErr			-6725 Operation could not be canceled (maybe already done or invalid).
983 	@constant	kDeletedErr					-6726 Object has already been deleted.
984 	@constant	kNotFoundErr				-6727 Something was not found.
985 	@constant	kNoMemoryErr				-6728 Not enough memory was available to perform the operation.
986 	@constant	kNoResourcesErr				-6729 Resources unavailable to perform the operation.
987 	@constant	kDuplicateErr				-6730 Duplicate found or something is a duplicate.
988 	@constant	kImmutableErr				-6731 Entity is not changeable.
989 	@constant	kUnsupportedDataErr			-6732 Data is unknown or not supported.
990 	@constant	kIntegrityErr				-6733 Data is corrupt.
991 	@constant	kIncompatibleErr			-6734 Data is not compatible or it is in an incompatible format.
992 	@constant	kUnsupportedErr				-6735 Feature or option is not supported.
993 	@constant	kUnexpectedErr				-6736 Error occurred that was not expected.
994 	@constant	kValueErr					-6737 Value is not appropriate.
995 	@constant	kNotReadableErr				-6738 Could not read or reading is not allowed.
996 	@constant	kNotWritableErr				-6739 Could not write or writing is not allowed.
997 	@constant	kBadReferenceErr			-6740 An invalid or inappropriate reference was specified.
998 	@constant	kFlagErr					-6741 An invalid, inappropriate, or unsupported flag was specified.
999 	@constant	kMalformedErr				-6742 Something was not formed correctly.
1000 	@constant	kSizeErr					-6743 Size was too big, too small, or not appropriate.
1001 	@constant	kNameErr					-6744 Name was not correct, allowed, or appropriate.
1002 	@constant	kNotReadyErr				-6745 Device or service is not ready.
1003 	@constant	kReadErr					-6746 Could not read.
1004 	@constant	kWriteErr					-6747 Could not write.
1005 	@constant	kMismatchErr				-6748 Something does not match.
1006 	@constant	kDateErr					-6749 Date is invalid or out-of-range.
1007 	@constant	kUnderrunErr				-6750 Less data than expected.
1008 	@constant	kOverrunErr					-6751 More data than expected.
1009 	@constant	kEndingErr					-6752 Connection, session, or something is ending.
1010 	@constant	kConnectionErr				-6753 Connection failed or could not be established.
1011 	@constant	kAuthenticationErr			-6754 Authentication failed or is not supported.
1012 	@constant	kOpenErr					-6755 Could not open file, pipe, device, etc.
1013 	@constant	kTypeErr					-6756 Incorrect or incompatible type (e.g. file, data, etc.).
1014 	@constant	kSkipErr					-6757 Items should be or was skipped.
1015 	@constant	kNoAckErr					-6758 No acknowledge.
1016 	@constant	kCollisionErr				-6759 Collision occurred (e.g. two on bus at same time).
1017 	@constant	kBackoffErr					-6760 Backoff in progress and operation intentionally failed.
1018 	@constant	kNoAddressAckErr			-6761 No acknowledge of address.
1019 	@constant	kBusyErr					-6762 Cannot perform because something is busy.
1020 	@constant	kNoSpaceErr					-6763 Not enough space to perform operation.
1021 */
1022 
1023 #if( TARGET_LANGUAGE_C_LIKE )
1024 	#if( !TARGET_OS_MAC && !TARGET_API_MAC_OSX_KERNEL )
1025 		typedef int32_t		OSStatus;
1026 	#endif
1027 #endif
1028 
1029 #define kNoErr						0
1030 #define kInProgressErr				1
1031 
1032 // Generic error codes are in the range -6700 to -6779.
1033 
1034 #define kGenericErrorBase			-6700	// Starting error code for all generic errors.
1035 
1036 #define kUnknownErr					-6700
1037 #define kOptionErr					-6701
1038 #define kSelectorErr				-6702
1039 #define kExecutionStateErr			-6703
1040 #define kPathErr					-6704
1041 #define kParamErr					-6705
1042 #define kParamCountErr				-6706
1043 #define kCommandErr					-6707
1044 #define kIDErr						-6708
1045 #define kStateErr					-6709
1046 #define kRangeErr					-6710
1047 #define kRequestErr					-6711
1048 #define kResponseErr				-6712
1049 #define kChecksumErr				-6713
1050 #define kNotHandledErr				-6714
1051 #define kVersionErr					-6715
1052 #define kSignatureErr				-6716
1053 #define kFormatErr					-6717
1054 #define kNotInitializedErr			-6718
1055 #define kAlreadyInitializedErr		-6719
1056 #define kNotInUseErr				-6720
1057 #define kInUseErr					-6721
1058 #define kTimeoutErr					-6722
1059 #define kCanceledErr				-6723
1060 #define kAlreadyCanceledErr			-6724
1061 #define kCannotCancelErr			-6725
1062 #define kDeletedErr					-6726
1063 #define kNotFoundErr				-6727
1064 #define kNoMemoryErr				-6728
1065 #define kNoResourcesErr				-6729
1066 #define kDuplicateErr				-6730
1067 #define kImmutableErr				-6731
1068 #define kUnsupportedDataErr			-6732
1069 #define kIntegrityErr				-6733
1070 #define kIncompatibleErr			-6734
1071 #define kUnsupportedErr				-6735
1072 #define kUnexpectedErr				-6736
1073 #define kValueErr					-6737
1074 #define kNotReadableErr				-6738
1075 #define kNotWritableErr				-6739
1076 #define	kBadReferenceErr			-6740
1077 #define	kFlagErr					-6741
1078 #define	kMalformedErr				-6742
1079 #define	kSizeErr					-6743
1080 #define	kNameErr					-6744
1081 #define	kNotReadyErr				-6745
1082 #define	kReadErr					-6746
1083 #define	kWriteErr					-6747
1084 #define	kMismatchErr				-6748
1085 #define	kDateErr					-6749
1086 #define	kUnderrunErr				-6750
1087 #define	kOverrunErr					-6751
1088 #define	kEndingErr					-6752
1089 #define	kConnectionErr				-6753
1090 #define	kAuthenticationErr			-6754
1091 #define	kOpenErr					-6755
1092 #define	kTypeErr					-6756
1093 #define	kSkipErr					-6757
1094 #define	kNoAckErr					-6758
1095 #define	kCollisionErr				-6759
1096 #define	kBackoffErr					-6760
1097 #define	kNoAddressAckErr			-6761
1098 #define	kBusyErr					-6762
1099 #define	kNoSpaceErr					-6763
1100 
1101 #define kGenericErrorEnd			-6779	// Last generic error code (inclusive)
1102 
1103 #if 0
1104 #pragma mark == Mac Compatibility ==
1105 #endif
1106 
1107 //===========================================================================================================================
1108 //	Mac Compatibility
1109 //===========================================================================================================================
1110 
1111 //---------------------------------------------------------------------------------------------------------------------------
1112 /*!	@enum		Duration
1113 
1114 	@abstract	Type used to specify a duration of time.
1115 
1116 	@constant	kDurationImmediate			Indicates no delay/wait time.
1117 	@constant	kDurationMicrosecond		Microsecond units.
1118 	@constant	kDurationMillisecond		Millisecond units.
1119 	@constant	kDurationSecond				Second units.
1120 	@constant	kDurationMinute				Minute units.
1121 	@constant	kDurationHour				Hour units.
1122 	@constant	kDurationDay				Day units.
1123 	@constant	kDurationForever			Infinite period of time (no timeout).
1124 
1125 	@discussion
1126 
1127 	Duration values are intended to be multiplied by the specific interval to achieve an actual duration. For example,
1128 	to wait for 5 seconds you would use "5 * kDurationSecond".
1129 */
1130 
1131 #if( TARGET_LANGUAGE_C_LIKE )
1132 	#if( !TARGET_OS_MAC )
1133 		typedef	int32_t		Duration;
1134 	#endif
1135 #endif
1136 
1137 #define	kDurationImmediate				0L
1138 #define	kDurationMicrosecond			-1L
1139 #define	kDurationMillisecond			1L
1140 #define	kDurationSecond					( 1000L * kDurationMillisecond )
1141 #define	kDurationMinute					( 60L * kDurationSecond )
1142 #define	kDurationHour					( 60L * kDurationMinute )
1143 #define	kDurationDay					( 24L * kDurationHour )
1144 #define	kDurationForever				0x7FFFFFFFL
1145 
1146 // Seconds <-> Minutes <-> Hours <-> Days <-> Weeks <-> Months <-> Years conversions
1147 
1148 #define kNanosecondsPerMicrosecond		1000
1149 #define kNanosecondsPerMillisecond		1000000
1150 #define kNanosecondsPerSecond			1000000000
1151 #define kMicrosecondsPerSecond			1000000
1152 #define kMicrosecondsPerMillisecond		1000
1153 #define kMillisecondsPerSecond			1000
1154 #define kSecondsPerMinute				60
1155 #define kSecondsPerHour					( 60 * 60 )				// 3600
1156 #define kSecondsPerDay					( 60 * 60 * 24 )		// 86400
1157 #define kSecondsPerWeek					( 60 * 60 * 24 * 7 )	// 604800
1158 #define kMinutesPerHour					60
1159 #define kMinutesPerDay					( 60 * 24 )				// 1440
1160 #define kHoursPerDay					24
1161 #define kDaysPerWeek					7
1162 #define kWeeksPerYear					52
1163 #define kMonthsPerYear					12
1164 
1165 //---------------------------------------------------------------------------------------------------------------------------
1166 /*!	@defined	VersionStages
1167 
1168 	@abstract	NumVersion-style version stages.
1169 */
1170 
1171 #define	kVersionStageDevelopment		0x20
1172 #define	kVersionStageAlpha				0x40
1173 #define	kVersionStageBeta				0x60
1174 #define	kVersionStageFinal				0x80
1175 
1176 //---------------------------------------------------------------------------------------------------------------------------
1177 /*!	@function	NumVersionBuild
1178 
1179 	@abstract	Builds a 32-bit Mac-style NumVersion value (e.g. NumVersionBuild( 1, 2, 3, kVersionStageBeta, 4 ) -> 1.2.3b4).
1180 */
1181 
1182 #define	NumVersionBuild( MAJOR, MINOR, BUGFIX, STAGE, REV )	\
1183 	( ( ( ( MAJOR )  & 0xFF ) << 24 ) |						\
1184 	  ( ( ( MINOR )  & 0x0F ) << 20 ) |						\
1185 	  ( ( ( BUGFIX ) & 0x0F ) << 16 ) |						\
1186 	  ( ( ( STAGE )  & 0xFF ) <<  8 ) |						\
1187 	  ( ( ( REV )    & 0xFF )       ) )
1188 
1189 #define	NumVersionExtractMajor( VERSION )				( (uint8_t)( ( ( VERSION ) >> 24 ) & 0xFF ) )
1190 #define	NumVersionExtractMinorAndBugFix( VERSION )		( (uint8_t)( ( ( VERSION ) >> 16 ) & 0xFF ) )
1191 #define	NumVersionExtractMinor( VERSION )				( (uint8_t)( ( ( VERSION ) >> 20 ) & 0x0F ) )
1192 #define	NumVersionExtractBugFix( VERSION )				( (uint8_t)( ( ( VERSION ) >> 16 ) & 0x0F ) )
1193 #define	NumVersionExtractStage( VERSION )				( (uint8_t)( ( ( VERSION ) >>  8 ) & 0xFF ) )
1194 #define	NumVersionExtractRevision( VERSION )			( (uint8_t)(   ( VERSION )         & 0xFF ) )
1195 
1196 //---------------------------------------------------------------------------------------------------------------------------
1197 /*!	@function	NumVersionCompare
1198 
1199 	@abstract	Compares two NumVersion values and returns the following values:
1200 
1201 		left < right -> -1
1202 		left > right ->  1
1203 		left = right ->  0
1204 */
1205 
1206 #if( TARGET_LANGUAGE_C_LIKE )
1207 	int	NumVersionCompare( uint32_t inLeft, uint32_t inRight );
1208 #endif
1209 
1210 #if 0
1211 #pragma mark == Binary Constants ==
1212 #endif
1213 
1214 //---------------------------------------------------------------------------------------------------------------------------
1215 /*!	@defined	binary_4
1216 
1217 	@abstract	Macro to generate an 4-bit constant using binary notation (e.g. binary_4( 1010 ) == 0xA).
1218 */
1219 
1220 #define	binary_4( a )						binary_4_hex_wrap( hex_digit4( a ) )
1221 #define binary_4_hex_wrap( a )				binary_4_hex( a )
1222 #define binary_4_hex( a )					( 0x ## a )
1223 
1224 //---------------------------------------------------------------------------------------------------------------------------
1225 /*!	@defined	binary_8
1226 
1227 	@abstract	Macro to generate an 8-bit constant using binary notation (e.g. binary_8( 01111011 ) == 0x7B).
1228 */
1229 
1230 #define	binary_8( a )						binary_8_hex_wrap( hex_digit8( a ) )
1231 #define binary_8_hex_wrap( a )				binary_8_hex( a )
1232 #define binary_8_hex( a )					( 0x ## a )
1233 
1234 //---------------------------------------------------------------------------------------------------------------------------
1235 /*!	@defined	binary_16
1236 
1237 	@abstract	Macro to generate an 16-bit constant using binary notation (e.g. binary_16( 01111011, 01111011 ) == 0x7B7B).
1238 */
1239 
1240 #define	binary_16( a, b )					binary_16_hex_wrap( hex_digit8( a ), hex_digit8( b ) )
1241 #define binary_16_hex_wrap( a, b )			binary_16_hex( a, b )
1242 #define binary_16_hex( a, b )				( 0x ## a ## b )
1243 
1244 //---------------------------------------------------------------------------------------------------------------------------
1245 /*!	@defined	binary_32
1246 
1247 	@abstract	Macro to generate an 32-bit constant using binary notation
1248 				(e.g. binary_32( 01111011, 01111011, 01111011, 01111011 ) == 0x7B7B7B7B).
1249 */
1250 
1251 #define	binary_32( a, b, c, d )				binary_32_hex_wrap( hex_digit8( a ), hex_digit8( b ), hex_digit8( c ), hex_digit8( d ) )
1252 #define binary_32_hex_wrap( a, b, c, d )	binary_32_hex( a, b, c, d )
1253 #define binary_32_hex( a, b, c, d )			( 0x ## a ## b ## c ## d )
1254 
1255 // Binary Constant Helpers
1256 
1257 #define hex_digit8( a )						HEX_DIGIT_ ## a
1258 #define hex_digit4( a )						HEX_DIGIT_ ## 0000 ## a
1259 
1260 #define HEX_DIGIT_00000000					00
1261 #define HEX_DIGIT_00000001					01
1262 #define HEX_DIGIT_00000010					02
1263 #define HEX_DIGIT_00000011					03
1264 #define HEX_DIGIT_00000100					04
1265 #define HEX_DIGIT_00000101					05
1266 #define HEX_DIGIT_00000110					06
1267 #define HEX_DIGIT_00000111					07
1268 #define HEX_DIGIT_00001000					08
1269 #define HEX_DIGIT_00001001					09
1270 #define HEX_DIGIT_00001010					0A
1271 #define HEX_DIGIT_00001011					0B
1272 #define HEX_DIGIT_00001100					0C
1273 #define HEX_DIGIT_00001101					0D
1274 #define HEX_DIGIT_00001110					0E
1275 #define HEX_DIGIT_00001111					0F
1276 #define HEX_DIGIT_00010000					10
1277 #define HEX_DIGIT_00010001					11
1278 #define HEX_DIGIT_00010010					12
1279 #define HEX_DIGIT_00010011					13
1280 #define HEX_DIGIT_00010100					14
1281 #define HEX_DIGIT_00010101					15
1282 #define HEX_DIGIT_00010110					16
1283 #define HEX_DIGIT_00010111					17
1284 #define HEX_DIGIT_00011000					18
1285 #define HEX_DIGIT_00011001					19
1286 #define HEX_DIGIT_00011010					1A
1287 #define HEX_DIGIT_00011011					1B
1288 #define HEX_DIGIT_00011100					1C
1289 #define HEX_DIGIT_00011101					1D
1290 #define HEX_DIGIT_00011110					1E
1291 #define HEX_DIGIT_00011111					1F
1292 #define HEX_DIGIT_00100000					20
1293 #define HEX_DIGIT_00100001					21
1294 #define HEX_DIGIT_00100010					22
1295 #define HEX_DIGIT_00100011					23
1296 #define HEX_DIGIT_00100100					24
1297 #define HEX_DIGIT_00100101					25
1298 #define HEX_DIGIT_00100110					26
1299 #define HEX_DIGIT_00100111					27
1300 #define HEX_DIGIT_00101000					28
1301 #define HEX_DIGIT_00101001					29
1302 #define HEX_DIGIT_00101010					2A
1303 #define HEX_DIGIT_00101011					2B
1304 #define HEX_DIGIT_00101100					2C
1305 #define HEX_DIGIT_00101101					2D
1306 #define HEX_DIGIT_00101110					2E
1307 #define HEX_DIGIT_00101111					2F
1308 #define HEX_DIGIT_00110000					30
1309 #define HEX_DIGIT_00110001					31
1310 #define HEX_DIGIT_00110010					32
1311 #define HEX_DIGIT_00110011					33
1312 #define HEX_DIGIT_00110100					34
1313 #define HEX_DIGIT_00110101					35
1314 #define HEX_DIGIT_00110110					36
1315 #define HEX_DIGIT_00110111					37
1316 #define HEX_DIGIT_00111000					38
1317 #define HEX_DIGIT_00111001					39
1318 #define HEX_DIGIT_00111010					3A
1319 #define HEX_DIGIT_00111011					3B
1320 #define HEX_DIGIT_00111100					3C
1321 #define HEX_DIGIT_00111101					3D
1322 #define HEX_DIGIT_00111110					3E
1323 #define HEX_DIGIT_00111111					3F
1324 #define HEX_DIGIT_01000000					40
1325 #define HEX_DIGIT_01000001					41
1326 #define HEX_DIGIT_01000010					42
1327 #define HEX_DIGIT_01000011					43
1328 #define HEX_DIGIT_01000100					44
1329 #define HEX_DIGIT_01000101					45
1330 #define HEX_DIGIT_01000110					46
1331 #define HEX_DIGIT_01000111					47
1332 #define HEX_DIGIT_01001000					48
1333 #define HEX_DIGIT_01001001					49
1334 #define HEX_DIGIT_01001010					4A
1335 #define HEX_DIGIT_01001011					4B
1336 #define HEX_DIGIT_01001100					4C
1337 #define HEX_DIGIT_01001101					4D
1338 #define HEX_DIGIT_01001110					4E
1339 #define HEX_DIGIT_01001111					4F
1340 #define HEX_DIGIT_01010000					50
1341 #define HEX_DIGIT_01010001					51
1342 #define HEX_DIGIT_01010010					52
1343 #define HEX_DIGIT_01010011					53
1344 #define HEX_DIGIT_01010100					54
1345 #define HEX_DIGIT_01010101					55
1346 #define HEX_DIGIT_01010110					56
1347 #define HEX_DIGIT_01010111					57
1348 #define HEX_DIGIT_01011000					58
1349 #define HEX_DIGIT_01011001					59
1350 #define HEX_DIGIT_01011010					5A
1351 #define HEX_DIGIT_01011011					5B
1352 #define HEX_DIGIT_01011100					5C
1353 #define HEX_DIGIT_01011101					5D
1354 #define HEX_DIGIT_01011110					5E
1355 #define HEX_DIGIT_01011111					5F
1356 #define HEX_DIGIT_01100000					60
1357 #define HEX_DIGIT_01100001					61
1358 #define HEX_DIGIT_01100010					62
1359 #define HEX_DIGIT_01100011					63
1360 #define HEX_DIGIT_01100100					64
1361 #define HEX_DIGIT_01100101					65
1362 #define HEX_DIGIT_01100110					66
1363 #define HEX_DIGIT_01100111					67
1364 #define HEX_DIGIT_01101000					68
1365 #define HEX_DIGIT_01101001					69
1366 #define HEX_DIGIT_01101010					6A
1367 #define HEX_DIGIT_01101011					6B
1368 #define HEX_DIGIT_01101100					6C
1369 #define HEX_DIGIT_01101101					6D
1370 #define HEX_DIGIT_01101110					6E
1371 #define HEX_DIGIT_01101111					6F
1372 #define HEX_DIGIT_01110000					70
1373 #define HEX_DIGIT_01110001					71
1374 #define HEX_DIGIT_01110010					72
1375 #define HEX_DIGIT_01110011					73
1376 #define HEX_DIGIT_01110100					74
1377 #define HEX_DIGIT_01110101					75
1378 #define HEX_DIGIT_01110110					76
1379 #define HEX_DIGIT_01110111					77
1380 #define HEX_DIGIT_01111000					78
1381 #define HEX_DIGIT_01111001					79
1382 #define HEX_DIGIT_01111010					7A
1383 #define HEX_DIGIT_01111011					7B
1384 #define HEX_DIGIT_01111100					7C
1385 #define HEX_DIGIT_01111101					7D
1386 #define HEX_DIGIT_01111110					7E
1387 #define HEX_DIGIT_01111111					7F
1388 #define HEX_DIGIT_10000000					80
1389 #define HEX_DIGIT_10000001					81
1390 #define HEX_DIGIT_10000010					82
1391 #define HEX_DIGIT_10000011					83
1392 #define HEX_DIGIT_10000100					84
1393 #define HEX_DIGIT_10000101					85
1394 #define HEX_DIGIT_10000110					86
1395 #define HEX_DIGIT_10000111					87
1396 #define HEX_DIGIT_10001000					88
1397 #define HEX_DIGIT_10001001					89
1398 #define HEX_DIGIT_10001010					8A
1399 #define HEX_DIGIT_10001011					8B
1400 #define HEX_DIGIT_10001100					8C
1401 #define HEX_DIGIT_10001101					8D
1402 #define HEX_DIGIT_10001110					8E
1403 #define HEX_DIGIT_10001111					8F
1404 #define HEX_DIGIT_10010000					90
1405 #define HEX_DIGIT_10010001					91
1406 #define HEX_DIGIT_10010010					92
1407 #define HEX_DIGIT_10010011					93
1408 #define HEX_DIGIT_10010100					94
1409 #define HEX_DIGIT_10010101					95
1410 #define HEX_DIGIT_10010110					96
1411 #define HEX_DIGIT_10010111					97
1412 #define HEX_DIGIT_10011000					98
1413 #define HEX_DIGIT_10011001					99
1414 #define HEX_DIGIT_10011010					9A
1415 #define HEX_DIGIT_10011011					9B
1416 #define HEX_DIGIT_10011100					9C
1417 #define HEX_DIGIT_10011101					9D
1418 #define HEX_DIGIT_10011110					9E
1419 #define HEX_DIGIT_10011111					9F
1420 #define HEX_DIGIT_10100000					A0
1421 #define HEX_DIGIT_10100001					A1
1422 #define HEX_DIGIT_10100010					A2
1423 #define HEX_DIGIT_10100011					A3
1424 #define HEX_DIGIT_10100100					A4
1425 #define HEX_DIGIT_10100101					A5
1426 #define HEX_DIGIT_10100110					A6
1427 #define HEX_DIGIT_10100111					A7
1428 #define HEX_DIGIT_10101000					A8
1429 #define HEX_DIGIT_10101001					A9
1430 #define HEX_DIGIT_10101010					AA
1431 #define HEX_DIGIT_10101011					AB
1432 #define HEX_DIGIT_10101100					AC
1433 #define HEX_DIGIT_10101101					AD
1434 #define HEX_DIGIT_10101110					AE
1435 #define HEX_DIGIT_10101111					AF
1436 #define HEX_DIGIT_10110000					B0
1437 #define HEX_DIGIT_10110001					B1
1438 #define HEX_DIGIT_10110010					B2
1439 #define HEX_DIGIT_10110011					B3
1440 #define HEX_DIGIT_10110100					B4
1441 #define HEX_DIGIT_10110101					B5
1442 #define HEX_DIGIT_10110110					B6
1443 #define HEX_DIGIT_10110111					B7
1444 #define HEX_DIGIT_10111000					B8
1445 #define HEX_DIGIT_10111001					B9
1446 #define HEX_DIGIT_10111010					BA
1447 #define HEX_DIGIT_10111011					BB
1448 #define HEX_DIGIT_10111100					BC
1449 #define HEX_DIGIT_10111101					BD
1450 #define HEX_DIGIT_10111110					BE
1451 #define HEX_DIGIT_10111111					BF
1452 #define HEX_DIGIT_11000000					C0
1453 #define HEX_DIGIT_11000001					C1
1454 #define HEX_DIGIT_11000010					C2
1455 #define HEX_DIGIT_11000011					C3
1456 #define HEX_DIGIT_11000100					C4
1457 #define HEX_DIGIT_11000101					C5
1458 #define HEX_DIGIT_11000110					C6
1459 #define HEX_DIGIT_11000111					C7
1460 #define HEX_DIGIT_11001000					C8
1461 #define HEX_DIGIT_11001001					C9
1462 #define HEX_DIGIT_11001010					CA
1463 #define HEX_DIGIT_11001011					CB
1464 #define HEX_DIGIT_11001100					CC
1465 #define HEX_DIGIT_11001101					CD
1466 #define HEX_DIGIT_11001110					CE
1467 #define HEX_DIGIT_11001111					CF
1468 #define HEX_DIGIT_11010000					D0
1469 #define HEX_DIGIT_11010001					D1
1470 #define HEX_DIGIT_11010010					D2
1471 #define HEX_DIGIT_11010011					D3
1472 #define HEX_DIGIT_11010100					D4
1473 #define HEX_DIGIT_11010101					D5
1474 #define HEX_DIGIT_11010110					D6
1475 #define HEX_DIGIT_11010111					D7
1476 #define HEX_DIGIT_11011000					D8
1477 #define HEX_DIGIT_11011001					D9
1478 #define HEX_DIGIT_11011010					DA
1479 #define HEX_DIGIT_11011011					DB
1480 #define HEX_DIGIT_11011100					DC
1481 #define HEX_DIGIT_11011101					DD
1482 #define HEX_DIGIT_11011110					DE
1483 #define HEX_DIGIT_11011111					DF
1484 #define HEX_DIGIT_11100000					E0
1485 #define HEX_DIGIT_11100001					E1
1486 #define HEX_DIGIT_11100010					E2
1487 #define HEX_DIGIT_11100011					E3
1488 #define HEX_DIGIT_11100100					E4
1489 #define HEX_DIGIT_11100101					E5
1490 #define HEX_DIGIT_11100110					E6
1491 #define HEX_DIGIT_11100111					E7
1492 #define HEX_DIGIT_11101000					E8
1493 #define HEX_DIGIT_11101001					E9
1494 #define HEX_DIGIT_11101010					EA
1495 #define HEX_DIGIT_11101011					EB
1496 #define HEX_DIGIT_11101100					EC
1497 #define HEX_DIGIT_11101101					ED
1498 #define HEX_DIGIT_11101110					EE
1499 #define HEX_DIGIT_11101111					EF
1500 #define HEX_DIGIT_11110000					F0
1501 #define HEX_DIGIT_11110001					F1
1502 #define HEX_DIGIT_11110010					F2
1503 #define HEX_DIGIT_11110011					F3
1504 #define HEX_DIGIT_11110100					F4
1505 #define HEX_DIGIT_11110101					F5
1506 #define HEX_DIGIT_11110110					F6
1507 #define HEX_DIGIT_11110111					F7
1508 #define HEX_DIGIT_11111000					F8
1509 #define HEX_DIGIT_11111001					F9
1510 #define HEX_DIGIT_11111010					FA
1511 #define HEX_DIGIT_11111011					FB
1512 #define HEX_DIGIT_11111100					FC
1513 #define HEX_DIGIT_11111101					FD
1514 #define HEX_DIGIT_11111110					FE
1515 #define HEX_DIGIT_11111111					FF
1516 
1517 #if 0
1518 #pragma mark == Debugging ==
1519 #endif
1520 
1521 //---------------------------------------------------------------------------------------------------------------------------
1522 /*!	@function	CommonServicesTest
1523 
1524 	@abstract	Unit test.
1525 */
1526 
1527 #if( DEBUG )
1528 	#if( TARGET_LANGUAGE_C_LIKE )
1529 		OSStatus	CommonServicesTest( void );
1530 	#endif
1531 #endif
1532 
1533 #ifdef	__cplusplus
1534 	}
1535 #endif
1536 
1537 #endif	// __COMMON_SERVICES__
1538