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