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 // Limits 838 839 #if( !defined( UINT32_MAX ) ) 840 #define UINT32_MAX UINT32_C( 4294967295 ) 841 #endif 842 843 #if 0 844 #pragma mark == bool == 845 #endif 846 847 //=========================================================================================================================== 848 // Boolean Constants and Types 849 //=========================================================================================================================== 850 851 // C++ defines bool, true, and false. Metrowerks allows this to be controlled by the "bool" option though. 852 // C99 defines __bool_true_false_are_defined when bool, true, and false are defined. 853 // MacTypes.h defines true and false (Mac builds only). 854 // 855 // Note: The Metrowerks has to be in its own block because Microsoft Visual Studio .NET does not completely 856 // short-circuit and gets confused by the option( bool ) portion of the conditional. 857 858 #if ( defined( __MWERKS__ ) ) 859 860 // Note: The following test is done on separate lines because CodeWarrior doesn't like it all on one line. 861 862 #if ( !__bool_true_false_are_defined && ( !defined( __cplusplus ) || !__option( bool ) ) ) 863 #define COMMON_SERVICES_NEEDS_BOOL 1 864 #else 865 #define COMMON_SERVICES_NEEDS_BOOL 0 866 #endif 867 868 // Workaround when building with CodeWarrior, but using the Apple stdbool.h header, which uses _Bool. 869 870 #if ( __bool_true_false_are_defined && !defined( __cplusplus ) && !__option( c9x ) ) 871 #define _Bool int 872 #endif 873 874 // Workaround when building with CodeWarrior for C++ with bool disabled and using the Apple stdbool.h header, 875 // which defines true and false to map to C++ true and false (which are not enabled). Serenity Now! 876 877 #if ( __bool_true_false_are_defined && defined( __cplusplus ) && !__option( bool ) ) 878 #define true 1 879 #define false 0 880 #endif 881 #else 882 #define COMMON_SERVICES_NEEDS_BOOL ( !defined( __cplusplus ) && !__bool_true_false_are_defined ) 883 #endif 884 885 #if ( COMMON_SERVICES_NEEDS_BOOL ) 886 887 typedef int bool; 888 889 #define bool bool 890 891 #if ( !defined( __MACTYPES__ ) && !defined( true ) && !defined( false ) ) 892 #define true 1 893 #define false 0 894 #endif 895 896 #define __bool_true_false_are_defined 1 897 #endif 898 899 // IOKit IOTypes.h typedef's bool if TYPE_BOOL is not defined so define it here to prevent redefinition by IOTypes.h. 900 901 #if ( TARGET_API_MAC_OSX_KERNEL ) 902 #define TYPE_BOOL 1 903 #endif 904 905 //--------------------------------------------------------------------------------------------------------------------------- 906 /*! @typedef CStr255 907 908 @abstract 255 character null-terminated (C-style) string. 909 */ 910 911 #if ( TARGET_LANGUAGE_C_LIKE ) 912 typedef char CStr255[ 256 ]; 913 #endif 914 915 #endif // TARGET_LANGUAGE_C_LIKE 916 917 //--------------------------------------------------------------------------------------------------------------------------- 918 /*! @defined TYPE_LONGLONG_NATIVE 919 920 @abstract Defines whether long long (or its equivalent) is natively supported or requires special libraries. 921 */ 922 923 #if ( !defined( TYPE_LONGLONG_NATIVE ) ) 924 #if ( !TARGET_OS_VXWORKS ) 925 #define TYPE_LONGLONG_NATIVE 1 926 #else 927 #define TYPE_LONGLONG_NATIVE 0 928 #endif 929 #endif 930 931 //--------------------------------------------------------------------------------------------------------------------------- 932 /*! @defined long_long_compat 933 934 @abstract Compatibility type to map to the closest thing to long long and unsigned long long. 935 936 @discussion 937 938 Neither long long nor unsigned long long are supported by Microsoft compilers, but they do support proprietary 939 "__int64" and "unsigned __int64" equivalents so map to those types if the real long long is not supported. 940 */ 941 942 #if ( TARGET_LANGUAGE_C_LIKE ) 943 #if ( TARGET_OS_WIN32 ) 944 typedef __int64 long_long_compat; 945 typedef unsigned __int64 unsigned_long_long_compat; 946 #else 947 typedef signed long long long_long_compat; 948 typedef unsigned long long unsigned_long_long_compat; 949 #endif 950 #endif 951 952 #if 0 953 #pragma mark == Errors == 954 #endif 955 956 //--------------------------------------------------------------------------------------------------------------------------- 957 /*! @enum OSStatus 958 959 @abstract Status Code 960 961 @constant kNoErr 0 No error occurred. 962 @constant kInProgressErr 1 Operation in progress. 963 @constant kUnknownErr -6700 Unknown error occurred. 964 @constant kOptionErr -6701 Option was not acceptable. 965 @constant kSelectorErr -6702 Selector passed in is invalid or unknown. 966 @constant kExecutionStateErr -6703 Call made in the wrong execution state (e.g. called at interrupt time). 967 @constant kPathErr -6704 Path is invalid, too long, or otherwise not usable. 968 @constant kParamErr -6705 Parameter is incorrect, missing, or not appropriate. 969 @constant kParamCountErr -6706 Incorrect or unsupported number of parameters. 970 @constant kCommandErr -6707 Command invalid or not supported. 971 @constant kIDErr -6708 Unknown, invalid, or inappropriate identifier. 972 @constant kStateErr -6709 Not in appropriate state to perform operation. 973 @constant kRangeErr -6710 Index is out of range or not valid. 974 @constant kRequestErr -6711 Request was improperly formed or not appropriate. 975 @constant kResponseErr -6712 Response was incorrect or out of sequence. 976 @constant kChecksumErr -6713 Checksum does not match the actual data. 977 @constant kNotHandledErr -6714 Operation was not handled (or not handled completely). 978 @constant kVersionErr -6715 Version is not incorrect or not compatibile. 979 @constant kSignatureErr -6716 Signature did not match what was expected. 980 @constant kFormatErr -6717 Unknown, invalid, or inappropriate file/data format. 981 @constant kNotInitializedErr -6718 Action request before needed services were initialized. 982 @constant kAlreadyInitializedErr -6719 Attempt made to initialize when already initialized. 983 @constant kNotInUseErr -6720 Object not in use (e.g. cannot abort if not already in use). 984 @constant kInUseErr -6721 Object is in use (e.g. cannot reuse active param blocks). 985 @constant kTimeoutErr -6722 Timeout occurred. 986 @constant kCanceledErr -6723 Operation canceled (successful cancel). 987 @constant kAlreadyCanceledErr -6724 Operation has already been canceled. 988 @constant kCannotCancelErr -6725 Operation could not be canceled (maybe already done or invalid). 989 @constant kDeletedErr -6726 Object has already been deleted. 990 @constant kNotFoundErr -6727 Something was not found. 991 @constant kNoMemoryErr -6728 Not enough memory was available to perform the operation. 992 @constant kNoResourcesErr -6729 Resources unavailable to perform the operation. 993 @constant kDuplicateErr -6730 Duplicate found or something is a duplicate. 994 @constant kImmutableErr -6731 Entity is not changeable. 995 @constant kUnsupportedDataErr -6732 Data is unknown or not supported. 996 @constant kIntegrityErr -6733 Data is corrupt. 997 @constant kIncompatibleErr -6734 Data is not compatible or it is in an incompatible format. 998 @constant kUnsupportedErr -6735 Feature or option is not supported. 999 @constant kUnexpectedErr -6736 Error occurred that was not expected. 1000 @constant kValueErr -6737 Value is not appropriate. 1001 @constant kNotReadableErr -6738 Could not read or reading is not allowed. 1002 @constant kNotWritableErr -6739 Could not write or writing is not allowed. 1003 @constant kBadReferenceErr -6740 An invalid or inappropriate reference was specified. 1004 @constant kFlagErr -6741 An invalid, inappropriate, or unsupported flag was specified. 1005 @constant kMalformedErr -6742 Something was not formed correctly. 1006 @constant kSizeErr -6743 Size was too big, too small, or not appropriate. 1007 @constant kNameErr -6744 Name was not correct, allowed, or appropriate. 1008 @constant kNotReadyErr -6745 Device or service is not ready. 1009 @constant kReadErr -6746 Could not read. 1010 @constant kWriteErr -6747 Could not write. 1011 @constant kMismatchErr -6748 Something does not match. 1012 @constant kDateErr -6749 Date is invalid or out-of-range. 1013 @constant kUnderrunErr -6750 Less data than expected. 1014 @constant kOverrunErr -6751 More data than expected. 1015 @constant kEndingErr -6752 Connection, session, or something is ending. 1016 @constant kConnectionErr -6753 Connection failed or could not be established. 1017 @constant kAuthenticationErr -6754 Authentication failed or is not supported. 1018 @constant kOpenErr -6755 Could not open file, pipe, device, etc. 1019 @constant kTypeErr -6756 Incorrect or incompatible type (e.g. file, data, etc.). 1020 @constant kSkipErr -6757 Items should be or was skipped. 1021 @constant kNoAckErr -6758 No acknowledge. 1022 @constant kCollisionErr -6759 Collision occurred (e.g. two on bus at same time). 1023 @constant kBackoffErr -6760 Backoff in progress and operation intentionally failed. 1024 @constant kNoAddressAckErr -6761 No acknowledge of address. 1025 @constant kBusyErr -6762 Cannot perform because something is busy. 1026 @constant kNoSpaceErr -6763 Not enough space to perform operation. 1027 */ 1028 1029 #if ( TARGET_LANGUAGE_C_LIKE ) 1030 #if ( !TARGET_OS_MAC && !TARGET_API_MAC_OSX_KERNEL ) 1031 typedef int32_t OSStatus; 1032 #endif 1033 #endif 1034 1035 #define kNoErr 0 1036 #define kInProgressErr 1 1037 1038 // Generic error codes are in the range -6700 to -6779. 1039 1040 #define kGenericErrorBase -6700 // Starting error code for all generic errors. 1041 1042 #define kUnknownErr -6700 1043 #define kOptionErr -6701 1044 #define kSelectorErr -6702 1045 #define kExecutionStateErr -6703 1046 #define kPathErr -6704 1047 #define kParamErr -6705 1048 #define kParamCountErr -6706 1049 #define kCommandErr -6707 1050 #define kIDErr -6708 1051 #define kStateErr -6709 1052 #define kRangeErr -6710 1053 #define kRequestErr -6711 1054 #define kResponseErr -6712 1055 #define kChecksumErr -6713 1056 #define kNotHandledErr -6714 1057 #define kVersionErr -6715 1058 #define kSignatureErr -6716 1059 #define kFormatErr -6717 1060 #define kNotInitializedErr -6718 1061 #define kAlreadyInitializedErr -6719 1062 #define kNotInUseErr -6720 1063 #define kInUseErr -6721 1064 #define kTimeoutErr -6722 1065 #define kCanceledErr -6723 1066 #define kAlreadyCanceledErr -6724 1067 #define kCannotCancelErr -6725 1068 #define kDeletedErr -6726 1069 #define kNotFoundErr -6727 1070 #define kNoMemoryErr -6728 1071 #define kNoResourcesErr -6729 1072 #define kDuplicateErr -6730 1073 #define kImmutableErr -6731 1074 #define kUnsupportedDataErr -6732 1075 #define kIntegrityErr -6733 1076 #define kIncompatibleErr -6734 1077 #define kUnsupportedErr -6735 1078 #define kUnexpectedErr -6736 1079 #define kValueErr -6737 1080 #define kNotReadableErr -6738 1081 #define kNotWritableErr -6739 1082 #define kBadReferenceErr -6740 1083 #define kFlagErr -6741 1084 #define kMalformedErr -6742 1085 #define kSizeErr -6743 1086 #define kNameErr -6744 1087 #define kNotReadyErr -6745 1088 #define kReadErr -6746 1089 #define kWriteErr -6747 1090 #define kMismatchErr -6748 1091 #define kDateErr -6749 1092 #define kUnderrunErr -6750 1093 #define kOverrunErr -6751 1094 #define kEndingErr -6752 1095 #define kConnectionErr -6753 1096 #define kAuthenticationErr -6754 1097 #define kOpenErr -6755 1098 #define kTypeErr -6756 1099 #define kSkipErr -6757 1100 #define kNoAckErr -6758 1101 #define kCollisionErr -6759 1102 #define kBackoffErr -6760 1103 #define kNoAddressAckErr -6761 1104 #define kBusyErr -6762 1105 #define kNoSpaceErr -6763 1106 1107 #define kGenericErrorEnd -6779 // Last generic error code (inclusive) 1108 1109 #if 0 1110 #pragma mark == Mac Compatibility == 1111 #endif 1112 1113 //=========================================================================================================================== 1114 // Mac Compatibility 1115 //=========================================================================================================================== 1116 1117 //--------------------------------------------------------------------------------------------------------------------------- 1118 /*! @enum Duration 1119 1120 @abstract Type used to specify a duration of time. 1121 1122 @constant kDurationImmediate Indicates no delay/wait time. 1123 @constant kDurationMicrosecond Microsecond units. 1124 @constant kDurationMillisecond Millisecond units. 1125 @constant kDurationSecond Second units. 1126 @constant kDurationMinute Minute units. 1127 @constant kDurationHour Hour units. 1128 @constant kDurationDay Day units. 1129 @constant kDurationForever Infinite period of time (no timeout). 1130 1131 @discussion 1132 1133 Duration values are intended to be multiplied by the specific interval to achieve an actual duration. For example, 1134 to wait for 5 seconds you would use "5 * kDurationSecond". 1135 */ 1136 1137 #if ( TARGET_LANGUAGE_C_LIKE ) 1138 #if ( !TARGET_OS_MAC ) 1139 typedef int32_t Duration; 1140 #endif 1141 #endif 1142 1143 #define kDurationImmediate 0L 1144 #define kDurationMicrosecond -1L 1145 #define kDurationMillisecond 1L 1146 #define kDurationSecond ( 1000L * kDurationMillisecond ) 1147 #define kDurationMinute ( 60L * kDurationSecond ) 1148 #define kDurationHour ( 60L * kDurationMinute ) 1149 #define kDurationDay ( 24L * kDurationHour ) 1150 #define kDurationForever 0x7FFFFFFFL 1151 1152 // Seconds <-> Minutes <-> Hours <-> Days <-> Weeks <-> Months <-> Years conversions 1153 1154 #define kNanosecondsPerMicrosecond 1000 1155 #define kNanosecondsPerMillisecond 1000000 1156 #define kNanosecondsPerSecond 1000000000 1157 #define kMicrosecondsPerSecond 1000000 1158 #define kMicrosecondsPerMillisecond 1000 1159 #define kMillisecondsPerSecond 1000 1160 #define kSecondsPerMinute 60 1161 #define kSecondsPerHour ( 60 * 60 ) // 3600 1162 #define kSecondsPerDay ( 60 * 60 * 24 ) // 86400 1163 #define kSecondsPerWeek ( 60 * 60 * 24 * 7 ) // 604800 1164 #define kMinutesPerHour 60 1165 #define kMinutesPerDay ( 60 * 24 ) // 1440 1166 #define kHoursPerDay 24 1167 #define kDaysPerWeek 7 1168 #define kWeeksPerYear 52 1169 #define kMonthsPerYear 12 1170 1171 //--------------------------------------------------------------------------------------------------------------------------- 1172 /*! @defined VersionStages 1173 1174 @abstract NumVersion-style version stages. 1175 */ 1176 1177 #define kVersionStageDevelopment 0x20 1178 #define kVersionStageAlpha 0x40 1179 #define kVersionStageBeta 0x60 1180 #define kVersionStageFinal 0x80 1181 1182 //--------------------------------------------------------------------------------------------------------------------------- 1183 /*! @function NumVersionBuild 1184 1185 @abstract Builds a 32-bit Mac-style NumVersion value (e.g. NumVersionBuild( 1, 2, 3, kVersionStageBeta, 4 ) -> 1.2.3b4). 1186 */ 1187 1188 #define NumVersionBuild( MAJOR, MINOR, BUGFIX, STAGE, REV ) \ 1189 ( ( ( ( MAJOR ) & 0xFF ) << 24 ) | \ 1190 ( ( ( MINOR ) & 0x0F ) << 20 ) | \ 1191 ( ( ( BUGFIX ) & 0x0F ) << 16 ) | \ 1192 ( ( ( STAGE ) & 0xFF ) << 8 ) | \ 1193 ( ( ( REV ) & 0xFF ) ) ) 1194 1195 #define NumVersionExtractMajor( VERSION ) ( (uint8_t)( ( ( VERSION ) >> 24 ) & 0xFF ) ) 1196 #define NumVersionExtractMinorAndBugFix( VERSION ) ( (uint8_t)( ( ( VERSION ) >> 16 ) & 0xFF ) ) 1197 #define NumVersionExtractMinor( VERSION ) ( (uint8_t)( ( ( VERSION ) >> 20 ) & 0x0F ) ) 1198 #define NumVersionExtractBugFix( VERSION ) ( (uint8_t)( ( ( VERSION ) >> 16 ) & 0x0F ) ) 1199 #define NumVersionExtractStage( VERSION ) ( (uint8_t)( ( ( VERSION ) >> 8 ) & 0xFF ) ) 1200 #define NumVersionExtractRevision( VERSION ) ( (uint8_t)( ( VERSION ) & 0xFF ) ) 1201 1202 //--------------------------------------------------------------------------------------------------------------------------- 1203 /*! @function NumVersionCompare 1204 1205 @abstract Compares two NumVersion values and returns the following values: 1206 1207 left < right -> -1 1208 left > right -> 1 1209 left = right -> 0 1210 */ 1211 1212 #if ( TARGET_LANGUAGE_C_LIKE ) 1213 int NumVersionCompare( uint32_t inLeft, uint32_t inRight ); 1214 #endif 1215 1216 #if 0 1217 #pragma mark == Binary Constants == 1218 #endif 1219 1220 //--------------------------------------------------------------------------------------------------------------------------- 1221 /*! @defined binary_4 1222 1223 @abstract Macro to generate an 4-bit constant using binary notation (e.g. binary_4( 1010 ) == 0xA). 1224 */ 1225 1226 #define binary_4( a ) binary_4_hex_wrap( hex_digit4( a ) ) 1227 #define binary_4_hex_wrap( a ) binary_4_hex( a ) 1228 #define binary_4_hex( a ) ( 0x ## a ) 1229 1230 //--------------------------------------------------------------------------------------------------------------------------- 1231 /*! @defined binary_8 1232 1233 @abstract Macro to generate an 8-bit constant using binary notation (e.g. binary_8( 01111011 ) == 0x7B). 1234 */ 1235 1236 #define binary_8( a ) binary_8_hex_wrap( hex_digit8( a ) ) 1237 #define binary_8_hex_wrap( a ) binary_8_hex( a ) 1238 #define binary_8_hex( a ) ( 0x ## a ) 1239 1240 //--------------------------------------------------------------------------------------------------------------------------- 1241 /*! @defined binary_16 1242 1243 @abstract Macro to generate an 16-bit constant using binary notation (e.g. binary_16( 01111011, 01111011 ) == 0x7B7B). 1244 */ 1245 1246 #define binary_16( a, b ) binary_16_hex_wrap( hex_digit8( a ), hex_digit8( b ) ) 1247 #define binary_16_hex_wrap( a, b ) binary_16_hex( a, b ) 1248 #define binary_16_hex( a, b ) ( 0x ## a ## b ) 1249 1250 //--------------------------------------------------------------------------------------------------------------------------- 1251 /*! @defined binary_32 1252 1253 @abstract Macro to generate an 32-bit constant using binary notation 1254 (e.g. binary_32( 01111011, 01111011, 01111011, 01111011 ) == 0x7B7B7B7B). 1255 */ 1256 1257 #define binary_32( a, b, c, d ) binary_32_hex_wrap( hex_digit8( a ), hex_digit8( b ), hex_digit8( c ), hex_digit8( d ) ) 1258 #define binary_32_hex_wrap( a, b, c, d ) binary_32_hex( a, b, c, d ) 1259 #define binary_32_hex( a, b, c, d ) ( 0x ## a ## b ## c ## d ) 1260 1261 // Binary Constant Helpers 1262 1263 #define hex_digit8( a ) HEX_DIGIT_ ## a 1264 #define hex_digit4( a ) HEX_DIGIT_ ## 0000 ## a 1265 1266 #define HEX_DIGIT_00000000 00 1267 #define HEX_DIGIT_00000001 01 1268 #define HEX_DIGIT_00000010 02 1269 #define HEX_DIGIT_00000011 03 1270 #define HEX_DIGIT_00000100 04 1271 #define HEX_DIGIT_00000101 05 1272 #define HEX_DIGIT_00000110 06 1273 #define HEX_DIGIT_00000111 07 1274 #define HEX_DIGIT_00001000 08 1275 #define HEX_DIGIT_00001001 09 1276 #define HEX_DIGIT_00001010 0A 1277 #define HEX_DIGIT_00001011 0B 1278 #define HEX_DIGIT_00001100 0C 1279 #define HEX_DIGIT_00001101 0D 1280 #define HEX_DIGIT_00001110 0E 1281 #define HEX_DIGIT_00001111 0F 1282 #define HEX_DIGIT_00010000 10 1283 #define HEX_DIGIT_00010001 11 1284 #define HEX_DIGIT_00010010 12 1285 #define HEX_DIGIT_00010011 13 1286 #define HEX_DIGIT_00010100 14 1287 #define HEX_DIGIT_00010101 15 1288 #define HEX_DIGIT_00010110 16 1289 #define HEX_DIGIT_00010111 17 1290 #define HEX_DIGIT_00011000 18 1291 #define HEX_DIGIT_00011001 19 1292 #define HEX_DIGIT_00011010 1A 1293 #define HEX_DIGIT_00011011 1B 1294 #define HEX_DIGIT_00011100 1C 1295 #define HEX_DIGIT_00011101 1D 1296 #define HEX_DIGIT_00011110 1E 1297 #define HEX_DIGIT_00011111 1F 1298 #define HEX_DIGIT_00100000 20 1299 #define HEX_DIGIT_00100001 21 1300 #define HEX_DIGIT_00100010 22 1301 #define HEX_DIGIT_00100011 23 1302 #define HEX_DIGIT_00100100 24 1303 #define HEX_DIGIT_00100101 25 1304 #define HEX_DIGIT_00100110 26 1305 #define HEX_DIGIT_00100111 27 1306 #define HEX_DIGIT_00101000 28 1307 #define HEX_DIGIT_00101001 29 1308 #define HEX_DIGIT_00101010 2A 1309 #define HEX_DIGIT_00101011 2B 1310 #define HEX_DIGIT_00101100 2C 1311 #define HEX_DIGIT_00101101 2D 1312 #define HEX_DIGIT_00101110 2E 1313 #define HEX_DIGIT_00101111 2F 1314 #define HEX_DIGIT_00110000 30 1315 #define HEX_DIGIT_00110001 31 1316 #define HEX_DIGIT_00110010 32 1317 #define HEX_DIGIT_00110011 33 1318 #define HEX_DIGIT_00110100 34 1319 #define HEX_DIGIT_00110101 35 1320 #define HEX_DIGIT_00110110 36 1321 #define HEX_DIGIT_00110111 37 1322 #define HEX_DIGIT_00111000 38 1323 #define HEX_DIGIT_00111001 39 1324 #define HEX_DIGIT_00111010 3A 1325 #define HEX_DIGIT_00111011 3B 1326 #define HEX_DIGIT_00111100 3C 1327 #define HEX_DIGIT_00111101 3D 1328 #define HEX_DIGIT_00111110 3E 1329 #define HEX_DIGIT_00111111 3F 1330 #define HEX_DIGIT_01000000 40 1331 #define HEX_DIGIT_01000001 41 1332 #define HEX_DIGIT_01000010 42 1333 #define HEX_DIGIT_01000011 43 1334 #define HEX_DIGIT_01000100 44 1335 #define HEX_DIGIT_01000101 45 1336 #define HEX_DIGIT_01000110 46 1337 #define HEX_DIGIT_01000111 47 1338 #define HEX_DIGIT_01001000 48 1339 #define HEX_DIGIT_01001001 49 1340 #define HEX_DIGIT_01001010 4A 1341 #define HEX_DIGIT_01001011 4B 1342 #define HEX_DIGIT_01001100 4C 1343 #define HEX_DIGIT_01001101 4D 1344 #define HEX_DIGIT_01001110 4E 1345 #define HEX_DIGIT_01001111 4F 1346 #define HEX_DIGIT_01010000 50 1347 #define HEX_DIGIT_01010001 51 1348 #define HEX_DIGIT_01010010 52 1349 #define HEX_DIGIT_01010011 53 1350 #define HEX_DIGIT_01010100 54 1351 #define HEX_DIGIT_01010101 55 1352 #define HEX_DIGIT_01010110 56 1353 #define HEX_DIGIT_01010111 57 1354 #define HEX_DIGIT_01011000 58 1355 #define HEX_DIGIT_01011001 59 1356 #define HEX_DIGIT_01011010 5A 1357 #define HEX_DIGIT_01011011 5B 1358 #define HEX_DIGIT_01011100 5C 1359 #define HEX_DIGIT_01011101 5D 1360 #define HEX_DIGIT_01011110 5E 1361 #define HEX_DIGIT_01011111 5F 1362 #define HEX_DIGIT_01100000 60 1363 #define HEX_DIGIT_01100001 61 1364 #define HEX_DIGIT_01100010 62 1365 #define HEX_DIGIT_01100011 63 1366 #define HEX_DIGIT_01100100 64 1367 #define HEX_DIGIT_01100101 65 1368 #define HEX_DIGIT_01100110 66 1369 #define HEX_DIGIT_01100111 67 1370 #define HEX_DIGIT_01101000 68 1371 #define HEX_DIGIT_01101001 69 1372 #define HEX_DIGIT_01101010 6A 1373 #define HEX_DIGIT_01101011 6B 1374 #define HEX_DIGIT_01101100 6C 1375 #define HEX_DIGIT_01101101 6D 1376 #define HEX_DIGIT_01101110 6E 1377 #define HEX_DIGIT_01101111 6F 1378 #define HEX_DIGIT_01110000 70 1379 #define HEX_DIGIT_01110001 71 1380 #define HEX_DIGIT_01110010 72 1381 #define HEX_DIGIT_01110011 73 1382 #define HEX_DIGIT_01110100 74 1383 #define HEX_DIGIT_01110101 75 1384 #define HEX_DIGIT_01110110 76 1385 #define HEX_DIGIT_01110111 77 1386 #define HEX_DIGIT_01111000 78 1387 #define HEX_DIGIT_01111001 79 1388 #define HEX_DIGIT_01111010 7A 1389 #define HEX_DIGIT_01111011 7B 1390 #define HEX_DIGIT_01111100 7C 1391 #define HEX_DIGIT_01111101 7D 1392 #define HEX_DIGIT_01111110 7E 1393 #define HEX_DIGIT_01111111 7F 1394 #define HEX_DIGIT_10000000 80 1395 #define HEX_DIGIT_10000001 81 1396 #define HEX_DIGIT_10000010 82 1397 #define HEX_DIGIT_10000011 83 1398 #define HEX_DIGIT_10000100 84 1399 #define HEX_DIGIT_10000101 85 1400 #define HEX_DIGIT_10000110 86 1401 #define HEX_DIGIT_10000111 87 1402 #define HEX_DIGIT_10001000 88 1403 #define HEX_DIGIT_10001001 89 1404 #define HEX_DIGIT_10001010 8A 1405 #define HEX_DIGIT_10001011 8B 1406 #define HEX_DIGIT_10001100 8C 1407 #define HEX_DIGIT_10001101 8D 1408 #define HEX_DIGIT_10001110 8E 1409 #define HEX_DIGIT_10001111 8F 1410 #define HEX_DIGIT_10010000 90 1411 #define HEX_DIGIT_10010001 91 1412 #define HEX_DIGIT_10010010 92 1413 #define HEX_DIGIT_10010011 93 1414 #define HEX_DIGIT_10010100 94 1415 #define HEX_DIGIT_10010101 95 1416 #define HEX_DIGIT_10010110 96 1417 #define HEX_DIGIT_10010111 97 1418 #define HEX_DIGIT_10011000 98 1419 #define HEX_DIGIT_10011001 99 1420 #define HEX_DIGIT_10011010 9A 1421 #define HEX_DIGIT_10011011 9B 1422 #define HEX_DIGIT_10011100 9C 1423 #define HEX_DIGIT_10011101 9D 1424 #define HEX_DIGIT_10011110 9E 1425 #define HEX_DIGIT_10011111 9F 1426 #define HEX_DIGIT_10100000 A0 1427 #define HEX_DIGIT_10100001 A1 1428 #define HEX_DIGIT_10100010 A2 1429 #define HEX_DIGIT_10100011 A3 1430 #define HEX_DIGIT_10100100 A4 1431 #define HEX_DIGIT_10100101 A5 1432 #define HEX_DIGIT_10100110 A6 1433 #define HEX_DIGIT_10100111 A7 1434 #define HEX_DIGIT_10101000 A8 1435 #define HEX_DIGIT_10101001 A9 1436 #define HEX_DIGIT_10101010 AA 1437 #define HEX_DIGIT_10101011 AB 1438 #define HEX_DIGIT_10101100 AC 1439 #define HEX_DIGIT_10101101 AD 1440 #define HEX_DIGIT_10101110 AE 1441 #define HEX_DIGIT_10101111 AF 1442 #define HEX_DIGIT_10110000 B0 1443 #define HEX_DIGIT_10110001 B1 1444 #define HEX_DIGIT_10110010 B2 1445 #define HEX_DIGIT_10110011 B3 1446 #define HEX_DIGIT_10110100 B4 1447 #define HEX_DIGIT_10110101 B5 1448 #define HEX_DIGIT_10110110 B6 1449 #define HEX_DIGIT_10110111 B7 1450 #define HEX_DIGIT_10111000 B8 1451 #define HEX_DIGIT_10111001 B9 1452 #define HEX_DIGIT_10111010 BA 1453 #define HEX_DIGIT_10111011 BB 1454 #define HEX_DIGIT_10111100 BC 1455 #define HEX_DIGIT_10111101 BD 1456 #define HEX_DIGIT_10111110 BE 1457 #define HEX_DIGIT_10111111 BF 1458 #define HEX_DIGIT_11000000 C0 1459 #define HEX_DIGIT_11000001 C1 1460 #define HEX_DIGIT_11000010 C2 1461 #define HEX_DIGIT_11000011 C3 1462 #define HEX_DIGIT_11000100 C4 1463 #define HEX_DIGIT_11000101 C5 1464 #define HEX_DIGIT_11000110 C6 1465 #define HEX_DIGIT_11000111 C7 1466 #define HEX_DIGIT_11001000 C8 1467 #define HEX_DIGIT_11001001 C9 1468 #define HEX_DIGIT_11001010 CA 1469 #define HEX_DIGIT_11001011 CB 1470 #define HEX_DIGIT_11001100 CC 1471 #define HEX_DIGIT_11001101 CD 1472 #define HEX_DIGIT_11001110 CE 1473 #define HEX_DIGIT_11001111 CF 1474 #define HEX_DIGIT_11010000 D0 1475 #define HEX_DIGIT_11010001 D1 1476 #define HEX_DIGIT_11010010 D2 1477 #define HEX_DIGIT_11010011 D3 1478 #define HEX_DIGIT_11010100 D4 1479 #define HEX_DIGIT_11010101 D5 1480 #define HEX_DIGIT_11010110 D6 1481 #define HEX_DIGIT_11010111 D7 1482 #define HEX_DIGIT_11011000 D8 1483 #define HEX_DIGIT_11011001 D9 1484 #define HEX_DIGIT_11011010 DA 1485 #define HEX_DIGIT_11011011 DB 1486 #define HEX_DIGIT_11011100 DC 1487 #define HEX_DIGIT_11011101 DD 1488 #define HEX_DIGIT_11011110 DE 1489 #define HEX_DIGIT_11011111 DF 1490 #define HEX_DIGIT_11100000 E0 1491 #define HEX_DIGIT_11100001 E1 1492 #define HEX_DIGIT_11100010 E2 1493 #define HEX_DIGIT_11100011 E3 1494 #define HEX_DIGIT_11100100 E4 1495 #define HEX_DIGIT_11100101 E5 1496 #define HEX_DIGIT_11100110 E6 1497 #define HEX_DIGIT_11100111 E7 1498 #define HEX_DIGIT_11101000 E8 1499 #define HEX_DIGIT_11101001 E9 1500 #define HEX_DIGIT_11101010 EA 1501 #define HEX_DIGIT_11101011 EB 1502 #define HEX_DIGIT_11101100 EC 1503 #define HEX_DIGIT_11101101 ED 1504 #define HEX_DIGIT_11101110 EE 1505 #define HEX_DIGIT_11101111 EF 1506 #define HEX_DIGIT_11110000 F0 1507 #define HEX_DIGIT_11110001 F1 1508 #define HEX_DIGIT_11110010 F2 1509 #define HEX_DIGIT_11110011 F3 1510 #define HEX_DIGIT_11110100 F4 1511 #define HEX_DIGIT_11110101 F5 1512 #define HEX_DIGIT_11110110 F6 1513 #define HEX_DIGIT_11110111 F7 1514 #define HEX_DIGIT_11111000 F8 1515 #define HEX_DIGIT_11111001 F9 1516 #define HEX_DIGIT_11111010 FA 1517 #define HEX_DIGIT_11111011 FB 1518 #define HEX_DIGIT_11111100 FC 1519 #define HEX_DIGIT_11111101 FD 1520 #define HEX_DIGIT_11111110 FE 1521 #define HEX_DIGIT_11111111 FF 1522 1523 #if 0 1524 #pragma mark == Debugging == 1525 #endif 1526 1527 //--------------------------------------------------------------------------------------------------------------------------- 1528 /*! @function CommonServicesTest 1529 1530 @abstract Unit test. 1531 */ 1532 1533 #if ( DEBUG ) 1534 #if ( TARGET_LANGUAGE_C_LIKE ) 1535 OSStatus CommonServicesTest( void ); 1536 #endif 1537 #endif 1538 1539 #ifdef __cplusplus 1540 } 1541 #endif 1542 1543 #endif // __COMMON_SERVICES__ 1544