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