]> git.saurik.com Git - apple/xnu.git/blame - EXTERNAL_HEADERS/AssertMacros.h
projects / apple / xnu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xnu-2422.90.20.tar.gz
[apple/xnu.git] / EXTERNAL_HEADERS / AssertMacros.h
CommitLineData
b0d623f7 1/*
39236c6e
A		 2 * Copyright (c) 2002-2008 by Apple 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
24
25/*
26 File: AssertMacros.h
b0d623f7 27
39236c6e
A		 28 Contains: This file defines structured error handling and assertion macros for
29 programming in C. Originally used in QuickDraw GX and later enhanced.
30 These macros are used throughout Apple's software.
31
32 New code may not want to begin adopting these macros and instead use
33 existing language functionality.
34
35 See "Living In an Exceptional World" by Sean Parent
36 (develop, The Apple Technical Journal, Issue 11, August/September 1992)
37 <http://developer.apple.com/dev/techsupport/develop/issue11toc.shtml> or
38 <http://www.mactech.com/articles/develop/issue_11/Parent_final.html>
39 for the methodology behind these error handling and assertion macros.
40
41 Bugs?: For bug reports, consult the following page on
42 the World Wide Web:
43
44 http://developer.apple.com/bugreporter/
b0d623f7
A		 45*/
46#ifndef __ASSERTMACROS__
47#define __ASSERTMACROS__
48
b0d623f7
A		 49/*
50 * Macro overview:
51 *
52 * check(assertion)
53 * In production builds, pre-processed away
54 * In debug builds, if assertion evaluates to false, calls DEBUG_ASSERT_MESSAGE
55 *
56 * verify(assertion)
57 * In production builds, evaluates assertion and does nothing
58 * In debug builds, if assertion evaluates to false, calls DEBUG_ASSERT_MESSAGE
59 *
60 * require(assertion, exceptionLabel)
61 * In production builds, if the assertion expression evaluates to false, goto exceptionLabel
62 * In debug builds, if the assertion expression evaluates to false, calls DEBUG_ASSERT_MESSAGE
63 * and jumps to exceptionLabel
64 *
65 * In addition the following suffixes are available:
66 *
67 * _noerr Adds "!= 0" to assertion. Useful for asserting and OSStatus or OSErr is noErr (zero)
68 * _action Adds statement to be executued if assertion fails
69 * _quiet Suppress call to DEBUG_ASSERT_MESSAGE
70 * _string Allows you to add explanitory message to DEBUG_ASSERT_MESSAGE
71 *
72 * For instance, require_noerr_string(resultCode, label, msg) will do nothing if
73 * resultCode is zero, otherwise it will call DEBUG_ASSERT_MESSAGE with msg
74 * and jump to label.
75 *
76 * Configuration:
77 *
78 * By default all macros generate "production code" (i.e non-debug). If
79 * DEBUG_ASSERT_PRODUCTION_CODE is defined to zero or DEBUG is defined to non-zero
80 * while this header is included, the macros will generated debug code.
81 *
82 * If DEBUG_ASSERT_COMPONENT_NAME_STRING is defined, all debug messages will
83 * be prefixed with it.
84 *
85 * By default, all messages write to stderr. If you would like to write a custom
86 * error message formater, defined DEBUG_ASSERT_MESSAGE to your function name.
87 *
39236c6e
A		 88 * Each individual macro will only be defined if it is not already defined, so
89 * you can redefine their behavior singly by providing your own definition before
90 * this file is included.
91 *
92 * If you define __ASSERTMACROS__ before this file is included, then nothing in
93 * this file will take effect.
94 *
95 * Prior to Mac OS X 10.6 the macro names used in this file conflicted with some
96 * user code, including libraries in boost and the proposed C++ standards efforts,
97 * and there was no way for a client of this header to resolve this conflict. Because
98 * of this, most of the macros have been changed so that they are prefixed with
99 * __ and contain at least one capital letter, which should alleviate the current
100 * and future conflicts. However, to allow current sources to continue to compile,
101 * compatibility macros are defined at the end with the old names. A tops script
102 * at the end of this file will convert all of the old macro names used in a directory
103 * to the new names. Clients are recommended to migrate over to these new macros as
104 * they update their sources because a future release of Mac OS X will remove the
105 * old macro definitions ( without the double-underscore prefix ). Clients who
106 * want to compile without the old macro definitions can define the macro
107 * __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES to 0 before this file is
108 * included.
b0d623f7
A		 109 */
110
111
112/*
113 * Before including this file, #define DEBUG_ASSERT_COMPONENT_NAME_STRING to
114 * a C-string containing the name of your client. This string will be passed to
115 * the DEBUG_ASSERT_MESSAGE macro for inclusion in any assertion messages.
116 *
117 * If you do not define DEBUG_ASSERT_COMPONENT_NAME_STRING, the default
118 * DEBUG_ASSERT_COMPONENT_NAME_STRING value, an empty string, will be used by
119 * the assertion macros.
120 */
121#ifndef DEBUG_ASSERT_COMPONENT_NAME_STRING
122 #define DEBUG_ASSERT_COMPONENT_NAME_STRING ""
123#endif
124
125
126/*
127 * To activate the additional assertion code and messages for non-production builds,
128 * #define DEBUG_ASSERT_PRODUCTION_CODE to zero before including this file.
129 *
130 * If you do not define DEBUG_ASSERT_PRODUCTION_CODE, the default value 1 will be used
131 * (production code = no assertion code and no messages).
132 */
133#ifndef DEBUG_ASSERT_PRODUCTION_CODE
134 #define DEBUG_ASSERT_PRODUCTION_CODE !DEBUG
135#endif
136
137
138/*
139 * DEBUG_ASSERT_MESSAGE(component, assertion, label, error, file, line, errorCode)
140 *
141 * Summary:
142 * All assertion messages are routed through this macro. If you wish to use your
143 * own routine to display assertion messages, you can override DEBUG_ASSERT_MESSAGE
144 * by #defining DEBUG_ASSERT_MESSAGE before including this file.
145 *
146 * Parameters:
147 *
148 * componentNameString:
149 * A pointer to a string constant containing the name of the
150 * component this code is part of. This must be a string constant
151 * (and not a string variable or NULL) because the preprocessor
152 * concatenates it with other string constants.
153 *
154 * assertionString:
155 * A pointer to a string constant containing the assertion.
156 * This must be a string constant (and not a string variable or
157 * NULL) because the Preprocessor concatenates it with other
158 * string constants.
159 *
160 * exceptionLabelString:
161 * A pointer to a string containing the exceptionLabel, or NULL.
162 *
163 * errorString:
164 * A pointer to the error string, or NULL. DEBUG_ASSERT_MESSAGE macros
165 * must not attempt to concatenate this string with constant
166 * character strings.
167 *
168 * fileName:
169 * A pointer to the fileName or pathname (generated by the
170 * preprocessor __FILE__ identifier), or NULL.
171 *
172 * lineNumber:
173 * The line number in the file (generated by the preprocessor
174 * __LINE__ identifier), or 0 (zero).
175 *
176 * errorCode:
177 * A value associated with the assertion, or 0.
178 *
179 * Here is an example of a DEBUG_ASSERT_MESSAGE macro and a routine which displays
180 * assertion messsages:
181 *
182 * #define DEBUG_ASSERT_COMPONENT_NAME_STRING "MyCoolProgram"
183 *
184 * #define DEBUG_ASSERT_MESSAGE(componentNameString, assertionString, \
185 * exceptionLabelString, errorString, fileName, lineNumber, errorCode) \
186 * MyProgramDebugAssert(componentNameString, assertionString, \
187 * exceptionLabelString, errorString, fileName, lineNumber, errorCode)
188 *
189 * static void
190 * MyProgramDebugAssert(const char *componentNameString, const char *assertionString,
191 * const char *exceptionLabelString, const char *errorString,
192 * const char *fileName, long lineNumber, int errorCode)
193 * {
194 * if ( (assertionString != NULL) && (*assertionString != '\0') )
195 * fprintf(stderr, "Assertion failed: %s: %s\n", componentNameString, assertionString);
196 * else
197 * fprintf(stderr, "Check failed: %s:\n", componentNameString);
198 * if ( exceptionLabelString != NULL )
199 * fprintf(stderr, " %s\n", exceptionLabelString);
200 * if ( errorString != NULL )
201 * fprintf(stderr, " %s\n", errorString);
202 * if ( fileName != NULL )
203 * fprintf(stderr, " file: %s\n", fileName);
204 * if ( lineNumber != 0 )
205 * fprintf(stderr, " line: %ld\n", lineNumber);
206 * if ( errorCode != 0 )
207 * fprintf(stderr, " error: %d\n", errorCode);
208 * }
209 *
210 * If you do not define DEBUG_ASSERT_MESSAGE, a simple printf to stderr will be used.
211 */
212#ifndef DEBUG_ASSERT_MESSAGE
213 #ifdef KERNEL
214 #include <libkern/libkern.h>
215 #define DEBUG_ASSERT_MESSAGE(name, assertion, label, message, file, line, value) \
216 printf( "AssertMacros: %s, %s file: %s, line: %d\n", assertion, (message!=0) ? message : "", file, line);
217 #else
218 #include <stdio.h>
219 #define DEBUG_ASSERT_MESSAGE(name, assertion, label, message, file, line, value) \
220 fprintf(stderr, "AssertMacros: %s, %s file: %s, line: %d\n", assertion, (message!=0) ? message : "", file, line);
221 #endif
222#endif
223
224
225
226
227
228/*
39236c6e 229 * __Debug_String(message)
b0d623f7
A		 230 *
231 * Summary:
232 * Production builds: does nothing and produces no code.
233 *
234 * Non-production builds: call DEBUG_ASSERT_MESSAGE.
235 *
236 * Parameters:
237 *
238 * message:
239 * The C string to display.
240 *
241 */
39236c6e
A		 242#ifndef __Debug_String
243 #if DEBUG_ASSERT_PRODUCTION_CODE
244 #define __Debug_String(message)
245 #else
246 #define __Debug_String(message) \
247 do \
248 { \
249 DEBUG_ASSERT_MESSAGE( \
250 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
251 "", \
252 0, \
253 message, \
254 __FILE__, \
255 __LINE__, \
256 0); \
257 } while ( 0 )
258 #endif
b0d623f7
A		 259#endif
260
b0d623f7 261/*
39236c6e 262 * __Check(assertion)
b0d623f7
A		 263 *
264 * Summary:
265 * Production builds: does nothing and produces no code.
266 *
267 * Non-production builds: if the assertion expression evaluates to false,
268 * call DEBUG_ASSERT_MESSAGE.
269 *
270 * Parameters:
271 *
272 * assertion:
273 * The assertion expression.
274 */
39236c6e
A		 275#ifndef __Check
276 #if DEBUG_ASSERT_PRODUCTION_CODE
277 #define __Check(assertion)
278 #else
279 #define __Check(assertion) \
280 do \
281 { \
282 if ( __builtin_expect(!(assertion), 0) ) \
283 { \
284 DEBUG_ASSERT_MESSAGE( \
285 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
286 #assertion, 0, 0, __FILE__, __LINE__, 0 ); \
287 } \
288 } while ( 0 )
289 #endif
b0d623f7
A		 290#endif
291
39236c6e
A		 292#ifndef __nCheck
293 #define __nCheck(assertion) __Check(!(assertion))
294#endif
b0d623f7
A		 295
296/*
39236c6e 297 * __Check_String(assertion, message)
b0d623f7
A		 298 *
299 * Summary:
300 * Production builds: does nothing and produces no code.
301 *
302 * Non-production builds: if the assertion expression evaluates to false,
303 * call DEBUG_ASSERT_MESSAGE.
304 *
305 * Parameters:
306 *
307 * assertion:
308 * The assertion expression.
309 *
310 * message:
311 * The C string to display.
312 */
39236c6e
A		 313#ifndef __Check_String
314 #if DEBUG_ASSERT_PRODUCTION_CODE
315 #define __Check_String(assertion, message)
316 #else
317 #define __Check_String(assertion, message) \
318 do \
319 { \
320 if ( __builtin_expect(!(assertion), 0) ) \
321 { \
322 DEBUG_ASSERT_MESSAGE( \
323 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
324 #assertion, 0, message, __FILE__, __LINE__, 0 ); \
325 } \
326 } while ( 0 )
327 #endif
b0d623f7
A		 328#endif
329
39236c6e
A		 330#ifndef __nCheck_String
331 #define __nCheck_String(assertion, message) __Check_String(!(assertion), message)
332#endif
b0d623f7
A		 333
334/*
39236c6e 335 * __Check_noErr(errorCode)
b0d623f7
A		 336 *
337 * Summary:
338 * Production builds: does nothing and produces no code.
339 *
340 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
341 * call DEBUG_ASSERT_MESSAGE.
342 *
343 * Parameters:
344 *
345 * errorCode:
346 * The errorCode expression to compare with 0.
347 */
39236c6e
A		 348#ifndef __Check_noErr
349 #if DEBUG_ASSERT_PRODUCTION_CODE
350 #define __Check_noErr(errorCode)
351 #else
352 #define __Check_noErr(errorCode) \
353 do \
354 { \
355 long evalOnceErrorCode = (errorCode); \
356 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
357 { \
358 DEBUG_ASSERT_MESSAGE( \
359 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
360 #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, evalOnceErrorCode ); \
361 } \
362 } while ( 0 )
363 #endif
b0d623f7
A		 364#endif
365
b0d623f7 366/*
39236c6e 367 * __Check_noErr_String(errorCode, message)
b0d623f7
A		 368 *
369 * Summary:
370 * Production builds: check_noerr_string() does nothing and produces
371 * no code.
372 *
373 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
374 * call DEBUG_ASSERT_MESSAGE.
375 *
376 * Parameters:
377 *
378 * errorCode:
379 * The errorCode expression to compare to 0.
380 *
381 * message:
382 * The C string to display.
383 */
39236c6e
A		 384#ifndef __Check_noErr_String
385 #if DEBUG_ASSERT_PRODUCTION_CODE
386 #define __Check_noErr_String(errorCode, message)
387 #else
388 #define __Check_noErr_String(errorCode, message) \
389 do \
390 { \
391 long evalOnceErrorCode = (errorCode); \
392 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
393 { \
394 DEBUG_ASSERT_MESSAGE( \
395 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
396 #errorCode " == 0 ", 0, message, __FILE__, __LINE__, evalOnceErrorCode ); \
397 } \
398 } while ( 0 )
399 #endif
b0d623f7
A		 400#endif
401
b0d623f7 402/*
39236c6e 403 * __Verify(assertion)
b0d623f7
A		 404 *
405 * Summary:
406 * Production builds: evaluate the assertion expression, but ignore
407 * the result.
408 *
409 * Non-production builds: if the assertion expression evaluates to false,
410 * call DEBUG_ASSERT_MESSAGE.
411 *
412 * Parameters:
413 *
414 * assertion:
415 * The assertion expression.
416 */
39236c6e
A		 417#ifndef __Verify
418 #if DEBUG_ASSERT_PRODUCTION_CODE
419 #define __Verify(assertion) \
420 do \
421 { \
422 if ( !(assertion) ) \
423 { \
424 } \
425 } while ( 0 )
426 #else
427 #define __Verify(assertion) \
428 do \
429 { \
430 if ( __builtin_expect(!(assertion), 0) ) \
431 { \
432 DEBUG_ASSERT_MESSAGE( \
433 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
434 #assertion, 0, 0, __FILE__, __LINE__, 0 ); \
435 } \
436 } while ( 0 )
437 #endif
b0d623f7
A		 438#endif
439
39236c6e
A		 440#ifndef __nVerify
441 #define __nVerify(assertion) __Verify(!(assertion))
442#endif
b0d623f7
A		 443
444/*
39236c6e 445 * __Verify_String(assertion, message)
b0d623f7
A		 446 *
447 * Summary:
448 * Production builds: evaluate the assertion expression, but ignore
449 * the result.
450 *
451 * Non-production builds: if the assertion expression evaluates to false,
452 * call DEBUG_ASSERT_MESSAGE.
453 *
454 * Parameters:
455 *
456 * assertion:
457 * The assertion expression.
458 *
459 * message:
460 * The C string to display.
461 */
39236c6e
A		 462#ifndef __Verify_String
463 #if DEBUG_ASSERT_PRODUCTION_CODE
464 #define __Verify_String(assertion, message) \
465 do \
466 { \
467 if ( !(assertion) ) \
468 { \
469 } \
470 } while ( 0 )
471 #else
472 #define __Verify_String(assertion, message) \
473 do \
474 { \
475 if ( __builtin_expect(!(assertion), 0) ) \
476 { \
477 DEBUG_ASSERT_MESSAGE( \
478 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
479 #assertion, 0, message, __FILE__, __LINE__, 0 ); \
480 } \
481 } while ( 0 )
482 #endif
b0d623f7
A		 483#endif
484
39236c6e
A		 485#ifndef __nVerify_String
486 #define __nVerify_String(assertion, message) __Verify_String(!(assertion), message)
487#endif
b0d623f7
A		 488
489/*
39236c6e 490 * __Verify_noErr(errorCode)
b0d623f7
A		 491 *
492 * Summary:
493 * Production builds: evaluate the errorCode expression, but ignore
494 * the result.
495 *
496 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
497 * call DEBUG_ASSERT_MESSAGE.
498 *
499 * Parameters:
500 *
501 * errorCode:
502 * The expression to compare to 0.
503 */
39236c6e
A		 504#ifndef __Verify_noErr
505 #if DEBUG_ASSERT_PRODUCTION_CODE
506 #define __Verify_noErr(errorCode) \
507 do \
508 { \
509 if ( 0 != (errorCode) ) \
510 { \
511 } \
512 } while ( 0 )
513 #else
514 #define __Verify_noErr(errorCode) \
515 do \
516 { \
517 long evalOnceErrorCode = (errorCode); \
518 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
519 { \
520 DEBUG_ASSERT_MESSAGE( \
521 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
522 #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, evalOnceErrorCode ); \
523 } \
524 } while ( 0 )
525 #endif
b0d623f7
A		 526#endif
527
b0d623f7 528/*
39236c6e 529 * __Verify_noErr_String(errorCode, message)
b0d623f7
A		 530 *
531 * Summary:
532 * Production builds: evaluate the errorCode expression, but ignore
533 * the result.
534 *
535 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
536 * call DEBUG_ASSERT_MESSAGE.
537 *
538 * Parameters:
539 *
540 * errorCode:
541 * The expression to compare to 0.
542 *
543 * message:
544 * The C string to display.
545 */
39236c6e
A		 546#ifndef __Verify_noErr_String
547 #if DEBUG_ASSERT_PRODUCTION_CODE
548 #define __Verify_noErr_String(errorCode, message) \
549 do \
550 { \
551 if ( 0 != (errorCode) ) \
552 { \
553 } \
554 } while ( 0 )
555 #else
556 #define __Verify_noErr_String(errorCode, message) \
557 do \
558 { \
559 long evalOnceErrorCode = (errorCode); \
560 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
561 { \
562 DEBUG_ASSERT_MESSAGE( \
563 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
564 #errorCode " == 0 ", 0, message, __FILE__, __LINE__, evalOnceErrorCode ); \
565 } \
566 } while ( 0 )
567 #endif
b0d623f7
A		 568#endif
569
39236c6e
A		 570/*
571 * __Verify_noErr_Action(errorCode, action)
572 *
573 * Summary:
574 * Production builds: if the errorCode expression does not equal 0 (noErr),
575 * execute the action statement or compound statement (block).
576 *
577 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
578 * call DEBUG_ASSERT_MESSAGE and then execute the action statement or compound
579 * statement (block).
580 *
581 * Parameters:
582 *
583 * errorCode:
584 * The expression to compare to 0.
585 *
586 * action:
587 * The statement or compound statement (block).
588 */
589#ifndef __Verify_noErr_Action
590 #if DEBUG_ASSERT_PRODUCTION_CODE
591 #define __Verify_noErr_Action(errorCode, action) \
592 if ( 0 != (errorCode) ) { \
593 action; \
594 } \
595 else do {} while (0)
596 #else
597 #define __Verify_noErr_Action(errorCode, action) \
598 do { \
599 long evalOnceErrorCode = (errorCode); \
600 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) { \
601 DEBUG_ASSERT_MESSAGE( \
602 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
603 #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, 0 ); \
604 action; \
605 } \
606 } while (0)
607 #endif
608#endif
b0d623f7
A		 609
610/*
39236c6e 611 * __Verify_Action(assertion, action)
b0d623f7
A		 612 *
613 * Summary:
614 * Production builds: if the assertion expression evaluates to false,
615 * then execute the action statement or compound statement (block).
616 *
617 * Non-production builds: if the assertion expression evaluates to false,
618 * call DEBUG_ASSERT_MESSAGE and then execute the action statement or compound
619 * statement (block).
620 *
621 * Parameters:
622 *
623 * assertion:
624 * The assertion expression.
625 *
626 * action:
627 * The statement or compound statement (block).
628 */
39236c6e
A		 629#ifndef __Verify_Action
630 #if DEBUG_ASSERT_PRODUCTION_CODE
631 #define __Verify_Action(assertion, action) \
632 if ( __builtin_expect(!(assertion), 0) ) { \
633 action; \
634 } \
635 else do {} while (0)
636 #else
637 #define __Verify_Action(assertion, action) \
638 if ( __builtin_expect(!(assertion), 0) ) { \
639 DEBUG_ASSERT_MESSAGE( \
640 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
641 #assertion, 0, 0, __FILE__, __LINE__, 0 ); \
642 action; \
643 } \
644 else do {} while (0)
645 #endif
b0d623f7
A		 646#endif
647
b0d623f7 648/*
39236c6e 649 * __Require(assertion, exceptionLabel)
b0d623f7
A		 650 *
651 * Summary:
652 * Production builds: if the assertion expression evaluates to false,
653 * goto exceptionLabel.
654 *
655 * Non-production builds: if the assertion expression evaluates to false,
656 * call DEBUG_ASSERT_MESSAGE and then goto exceptionLabel.
657 *
658 * Parameters:
659 *
660 * assertion:
661 * The assertion expression.
662 *
663 * exceptionLabel:
664 * The label.
665 */
39236c6e
A		 666#ifndef __Require
667 #if DEBUG_ASSERT_PRODUCTION_CODE
668 #define __Require(assertion, exceptionLabel) \
669 do \
670 { \
671 if ( __builtin_expect(!(assertion), 0) ) \
672 { \
673 goto exceptionLabel; \
674 } \
675 } while ( 0 )
676 #else
677 #define __Require(assertion, exceptionLabel) \
678 do \
679 { \
680 if ( __builtin_expect(!(assertion), 0) ) { \
681 DEBUG_ASSERT_MESSAGE( \
682 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
683 #assertion, #exceptionLabel, 0, __FILE__, __LINE__, 0); \
684 goto exceptionLabel; \
685 } \
686 } while ( 0 )
687 #endif
b0d623f7
A		 688#endif
689
39236c6e
A		 690#ifndef __nRequire
691 #define __nRequire(assertion, exceptionLabel) __Require(!(assertion), exceptionLabel)
692#endif
b0d623f7
A		 693
694/*
39236c6e 695 * __Require_Action(assertion, exceptionLabel, action)
b0d623f7
A		 696 *
697 * Summary:
698 * Production builds: if the assertion expression evaluates to false,
699 * execute the action statement or compound statement (block) and then
700 * goto exceptionLabel.
701 *
702 * Non-production builds: if the assertion expression evaluates to false,
703 * call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
704 * statement (block), and then goto exceptionLabel.
705 *
706 * Parameters:
707 *
708 * assertion:
709 * The assertion expression.
710 *
711 * exceptionLabel:
712 * The label.
713 *
714 * action:
715 * The statement or compound statement (block).
716 */
39236c6e
A		 717#ifndef __Require_Action
718 #if DEBUG_ASSERT_PRODUCTION_CODE
719 #define __Require_Action(assertion, exceptionLabel, action) \
720 do \
721 { \
722 if ( __builtin_expect(!(assertion), 0) ) \
723 { \
724 { \
725 action; \
726 } \
727 goto exceptionLabel; \
728 } \
729 } while ( 0 )
730 #else
731 #define __Require_Action(assertion, exceptionLabel, action) \
732 do \
733 { \
734 if ( __builtin_expect(!(assertion), 0) ) \
735 { \
736 DEBUG_ASSERT_MESSAGE( \
737 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
738 #assertion, #exceptionLabel, 0, __FILE__, __LINE__, 0); \
739 { \
740 action; \
741 } \
742 goto exceptionLabel; \
743 } \
744 } while ( 0 )
745 #endif
b0d623f7
A		 746#endif
747
39236c6e
A		 748#ifndef __nRequire_Action
749 #define __nRequire_Action(assertion, exceptionLabel, action) \
750 __Require_Action(!(assertion), exceptionLabel, action)
751#endif
b0d623f7
A		 752
753/*
39236c6e 754 * __Require_Quiet(assertion, exceptionLabel)
b0d623f7
A		 755 *
756 * Summary:
757 * If the assertion expression evaluates to false, goto exceptionLabel.
758 *
759 * Parameters:
760 *
761 * assertion:
762 * The assertion expression.
763 *
764 * exceptionLabel:
765 * The label.
766 */
39236c6e
A		 767#ifndef __Require_Quiet
768 #define __Require_Quiet(assertion, exceptionLabel) \
769 do \
770 { \
771 if ( __builtin_expect(!(assertion), 0) ) \
772 { \
773 goto exceptionLabel; \
774 } \
775 } while ( 0 )
776#endif
b0d623f7 777
39236c6e
A		 778#ifndef __nRequire_Quiet
779 #define __nRequire_Quiet(assertion, exceptionLabel) __Require_Quiet(!(assertion), exceptionLabel)
780#endif
b0d623f7
A		 781
782/*
39236c6e 783 * __Require_Action_Quiet(assertion, exceptionLabel, action)
b0d623f7
A		 784 *
785 * Summary:
786 * If the assertion expression evaluates to false, execute the action
787 * statement or compound statement (block), and goto exceptionLabel.
788 *
789 * Parameters:
790 *
791 * assertion:
792 * The assertion expression.
793 *
794 * exceptionLabel:
795 * The label.
796 *
797 * action:
798 * The statement or compound statement (block).
799 */
39236c6e
A		 800#ifndef __Require_Action_Quiet
801 #define __Require_Action_Quiet(assertion, exceptionLabel, action) \
802 do \
803 { \
804 if ( __builtin_expect(!(assertion), 0) ) \
805 { \
806 { \
807 action; \
808 } \
809 goto exceptionLabel; \
810 } \
811 } while ( 0 )
812#endif
b0d623f7 813
39236c6e
A		 814#ifndef __nRequire_Action_Quiet
815 #define __nRequire_Action_Quiet(assertion, exceptionLabel, action) \
816 __Require_Action_Quiet(!(assertion), exceptionLabel, action)
817#endif
b0d623f7
A		 818
819/*
39236c6e 820 * __Require_String(assertion, exceptionLabel, message)
b0d623f7
A		 821 *
822 * Summary:
823 * Production builds: if the assertion expression evaluates to false,
824 * goto exceptionLabel.
825 *
826 * Non-production builds: if the assertion expression evaluates to false,
827 * call DEBUG_ASSERT_MESSAGE, and then goto exceptionLabel.
828 *
829 * Parameters:
830 *
831 * assertion:
832 * The assertion expression.
833 *
834 * exceptionLabel:
835 * The label.
836 *
837 * message:
838 * The C string to display.
839 */
39236c6e
A		 840#ifndef __Require_String
841 #if DEBUG_ASSERT_PRODUCTION_CODE
842 #define __Require_String(assertion, exceptionLabel, message) \
843 do \
844 { \
845 if ( __builtin_expect(!(assertion), 0) ) \
846 { \
847 goto exceptionLabel; \
848 } \
849 } while ( 0 )
850 #else
851 #define __Require_String(assertion, exceptionLabel, message) \
852 do \
853 { \
854 if ( __builtin_expect(!(assertion), 0) ) \
855 { \
856 DEBUG_ASSERT_MESSAGE( \
857 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
858 #assertion, #exceptionLabel, message, __FILE__, __LINE__, 0); \
859 goto exceptionLabel; \
860 } \
861 } while ( 0 )
862 #endif
b0d623f7
A		 863#endif
864
39236c6e
A		 865#ifndef __nRequire_String
866 #define __nRequire_String(assertion, exceptionLabel, string) \
867 __Require_String(!(assertion), exceptionLabel, string)
868#endif
b0d623f7
A		 869
870/*
39236c6e 871 * __Require_Action_String(assertion, exceptionLabel, action, message)
b0d623f7
A		 872 *
873 * Summary:
874 * Production builds: if the assertion expression evaluates to false,
875 * execute the action statement or compound statement (block), and then
876 * goto exceptionLabel.
877 *
878 * Non-production builds: if the assertion expression evaluates to false,
879 * call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
880 * statement (block), and then goto exceptionLabel.
881 *
882 * Parameters:
883 *
884 * assertion:
885 * The assertion expression.
886 *
887 * exceptionLabel:
888 * The label.
889 *
890 * action:
891 * The statement or compound statement (block).
892 *
893 * message:
894 * The C string to display.
895 */
39236c6e
A		 896#ifndef __Require_Action_String
897 #if DEBUG_ASSERT_PRODUCTION_CODE
898 #define __Require_Action_String(assertion, exceptionLabel, action, message) \
899 do \
900 { \
901 if ( __builtin_expect(!(assertion), 0) ) \
902 { \
903 { \
904 action; \
905 } \
906 goto exceptionLabel; \
907 } \
908 } while ( 0 )
909 #else
910 #define __Require_Action_String(assertion, exceptionLabel, action, message) \
911 do \
912 { \
913 if ( __builtin_expect(!(assertion), 0) ) \
914 { \
915 DEBUG_ASSERT_MESSAGE( \
916 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
917 #assertion, #exceptionLabel, message, __FILE__, __LINE__, 0); \
918 { \
919 action; \
920 } \
921 goto exceptionLabel; \
922 } \
923 } while ( 0 )
924 #endif
b0d623f7
A		 925#endif
926
39236c6e
A		 927#ifndef __nRequire_Action_String
928 #define __nRequire_Action_String(assertion, exceptionLabel, action, message) \
929 __Require_Action_String(!(assertion), exceptionLabel, action, message)
930#endif
b0d623f7
A		 931
932/*
39236c6e 933 * __Require_noErr(errorCode, exceptionLabel)
b0d623f7
A		 934 *
935 * Summary:
936 * Production builds: if the errorCode expression does not equal 0 (noErr),
937 * goto exceptionLabel.
938 *
939 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
940 * call DEBUG_ASSERT_MESSAGE and then goto exceptionLabel.
941 *
942 * Parameters:
943 *
944 * errorCode:
945 * The expression to compare to 0.
946 *
947 * exceptionLabel:
948 * The label.
949 */
39236c6e
A		 950#ifndef __Require_noErr
951 #if DEBUG_ASSERT_PRODUCTION_CODE
952 #define __Require_noErr(errorCode, exceptionLabel) \
953 do \
954 { \
955 if ( __builtin_expect(0 != (errorCode), 0) ) \
956 { \
957 goto exceptionLabel; \
958 } \
959 } while ( 0 )
960 #else
961 #define __Require_noErr(errorCode, exceptionLabel) \
962 do \
963 { \
964 long evalOnceErrorCode = (errorCode); \
965 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
966 { \
967 DEBUG_ASSERT_MESSAGE( \
968 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
969 #errorCode " == 0 ", #exceptionLabel, 0, __FILE__, __LINE__, evalOnceErrorCode); \
970 goto exceptionLabel; \
971 } \
972 } while ( 0 )
973 #endif
b0d623f7
A		 974#endif
975
976/*
39236c6e 977 * __Require_noErr_Action(errorCode, exceptionLabel, action)
b0d623f7
A		 978 *
979 * Summary:
980 * Production builds: if the errorCode expression does not equal 0 (noErr),
981 * execute the action statement or compound statement (block) and
982 * goto exceptionLabel.
983 *
984 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
985 * call DEBUG_ASSERT_MESSAGE, execute the action statement or
986 * compound statement (block), and then goto exceptionLabel.
987 *
988 * Parameters:
989 *
990 * errorCode:
991 * The expression to compare to 0.
992 *
993 * exceptionLabel:
994 * The label.
995 *
996 * action:
997 * The statement or compound statement (block).
998 */
39236c6e
A		 999#ifndef __Require_noErr_Action
1000 #if DEBUG_ASSERT_PRODUCTION_CODE
1001 #define __Require_noErr_Action(errorCode, exceptionLabel, action) \
1002 do \
1003 { \
1004 if ( __builtin_expect(0 != (errorCode), 0) ) \
1005 { \
1006 { \
1007 action; \
1008 } \
1009 goto exceptionLabel; \
1010 } \
1011 } while ( 0 )
1012 #else
1013 #define __Require_noErr_Action(errorCode, exceptionLabel, action) \
1014 do \
1015 { \
1016 long evalOnceErrorCode = (errorCode); \
1017 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
1018 { \
1019 DEBUG_ASSERT_MESSAGE( \
1020 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
1021 #errorCode " == 0 ", #exceptionLabel, 0, __FILE__, __LINE__, evalOnceErrorCode); \
1022 { \
1023 action; \
1024 } \
1025 goto exceptionLabel; \
1026 } \
1027 } while ( 0 )
1028 #endif
b0d623f7
A		 1029#endif
1030
b0d623f7 1031/*
39236c6e 1032 * __Require_noErr_Quiet(errorCode, exceptionLabel)
b0d623f7
A		 1033 *
1034 * Summary:
1035 * If the errorCode expression does not equal 0 (noErr),
1036 * goto exceptionLabel.
1037 *
1038 * Parameters:
1039 *
1040 * errorCode:
1041 * The expression to compare to 0.
1042 *
1043 * exceptionLabel:
1044 * The label.
1045 */
39236c6e
A		 1046#ifndef __Require_noErr_Quiet
1047 #define __Require_noErr_Quiet(errorCode, exceptionLabel) \
1048 do \
1049 { \
1050 if ( __builtin_expect(0 != (errorCode), 0) ) \
1051 { \
1052 goto exceptionLabel; \
1053 } \
1054 } while ( 0 )
1055#endif
b0d623f7
A		 1056
1057/*
39236c6e 1058 * __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action)
b0d623f7
A		 1059 *
1060 * Summary:
1061 * If the errorCode expression does not equal 0 (noErr),
1062 * execute the action statement or compound statement (block) and
1063 * goto exceptionLabel.
1064 *
1065 * Parameters:
1066 *
1067 * errorCode:
1068 * The expression to compare to 0.
1069 *
1070 * exceptionLabel:
1071 * The label.
1072 *
1073 * action:
1074 * The statement or compound statement (block).
1075 */
39236c6e
A		 1076#ifndef __Require_noErr_Action_Quiet
1077 #define __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action) \
1078 do \
1079 { \
1080 if ( __builtin_expect(0 != (errorCode), 0) ) \
1081 { \
1082 { \
1083 action; \
1084 } \
1085 goto exceptionLabel; \
1086 } \
1087 } while ( 0 )
1088#endif
b0d623f7
A		 1089
1090/*
39236c6e 1091 * __Require_noErr_String(errorCode, exceptionLabel, message)
b0d623f7
A		 1092 *
1093 * Summary:
1094 * Production builds: if the errorCode expression does not equal 0 (noErr),
1095 * goto exceptionLabel.
1096 *
1097 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
1098 * call DEBUG_ASSERT_MESSAGE, and then goto exceptionLabel.
1099 *
1100 * Parameters:
1101 *
1102 * errorCode:
1103 * The expression to compare to 0.
1104 *
1105 * exceptionLabel:
1106 * The label.
1107 *
1108 * message:
1109 * The C string to display.
1110 */
39236c6e
A		 1111#ifndef __Require_noErr_String
1112 #if DEBUG_ASSERT_PRODUCTION_CODE
1113 #define __Require_noErr_String(errorCode, exceptionLabel, message) \
1114 do \
1115 { \
1116 if ( __builtin_expect(0 != (errorCode), 0) ) \
1117 { \
1118 goto exceptionLabel; \
1119 } \
1120 } while ( 0 )
1121 #else
1122 #define __Require_noErr_String(errorCode, exceptionLabel, message) \
1123 do \
1124 { \
1125 long evalOnceErrorCode = (errorCode); \
1126 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
1127 { \
1128 DEBUG_ASSERT_MESSAGE( \
1129 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
1130 #errorCode " == 0 ", #exceptionLabel, message, __FILE__, __LINE__, evalOnceErrorCode); \
1131 goto exceptionLabel; \
1132 } \
1133 } while ( 0 )
1134 #endif
b0d623f7
A		 1135#endif
1136
b0d623f7 1137/*
39236c6e 1138 * __Require_noErr_Action_String(errorCode, exceptionLabel, action, message)
b0d623f7
A		 1139 *
1140 * Summary:
1141 * Production builds: if the errorCode expression does not equal 0 (noErr),
1142 * execute the action statement or compound statement (block) and
1143 * goto exceptionLabel.
1144 *
1145 * Non-production builds: if the errorCode expression does not equal 0 (noErr),
1146 * call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
1147 * statement (block), and then goto exceptionLabel.
1148 *
1149 * Parameters:
1150 *
1151 * errorCode:
1152 * The expression to compare to 0.
1153 *
1154 * exceptionLabel:
1155 * The label.
1156 *
1157 * action:
1158 * The statement or compound statement (block).
1159 *
1160 * message:
1161 * The C string to display.
1162 */
39236c6e
A		 1163#ifndef __Require_noErr_Action_String
1164 #if DEBUG_ASSERT_PRODUCTION_CODE
1165 #define __Require_noErr_Action_String(errorCode, exceptionLabel, action, message) \
1166 do \
1167 { \
1168 if ( __builtin_expect(0 != (errorCode), 0) ) \
1169 { \
1170 { \
1171 action; \
1172 } \
1173 goto exceptionLabel; \
1174 } \
1175 } while ( 0 )
1176 #else
1177 #define __Require_noErr_Action_String(errorCode, exceptionLabel, action, message) \
1178 do \
1179 { \
1180 long evalOnceErrorCode = (errorCode); \
1181 if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
1182 { \
1183 DEBUG_ASSERT_MESSAGE( \
1184 DEBUG_ASSERT_COMPONENT_NAME_STRING, \
1185 #errorCode " == 0 ", #exceptionLabel, message, __FILE__, __LINE__, evalOnceErrorCode); \
1186 { \
1187 action; \
1188 } \
1189 goto exceptionLabel; \
1190 } \
1191 } while ( 0 )
1192 #endif
b0d623f7
A		 1193#endif
1194
39236c6e
A		 1195/*
1196 * __Check_Compile_Time(expr)
1197 *
1198 * Summary:
1199 * any build: if the expression is not true, generated a compile time error.
1200 *
1201 * Parameters:
1202 *
1203 * expr:
1204 * The compile time expression that should evaluate to non-zero.
1205 *
1206 * Discussion:
1207 * This declares an array with a size that is determined by a compile-time expression.
1208 * If false, it declares a negatively sized array, which generates a compile-time error.
1209 *
1210 * Examples:
1211 * __Check_Compile_Time( sizeof( int ) == 4 );
1212 * __Check_Compile_Time( offsetof( MyStruct, myField ) == 4 );
1213 * __Check_Compile_Time( ( kMyBufferSize % 512 ) == 0 );
1214 *
1215 * Note: This only works with compile-time expressions.
1216 * Note: This only works in places where extern declarations are allowed (e.g. global scope).
1217 */
1218#ifndef __Check_Compile_Time
1219 #ifdef __GNUC__
1220 #define __Check_Compile_Time( expr ) \
1221 extern int compile_time_assert_failed[ ( expr ) ? 1 : -1 ] __attribute__( ( unused ) )
1222 #else
1223 #define __Check_Compile_Time( expr ) \
1224 extern int compile_time_assert_failed[ ( expr ) ? 1 : -1 ]
1225 #endif
1226#endif
b0d623f7 1227
39236c6e
A		 1228/*
1229 * For time immemorial, Mac OS X has defined version of most of these macros without the __ prefix, which
1230 * could collide with similarly named functions or macros in user code, including new functionality in
1231 * Boost and the C++ standard library.
1232 *
1233 * A future release of Mac OS X will no longer do this, and will require that clients move to the
1234 * new macros as defined above. However, in the interim both the new and old macros will work, unless
1235 * clients define a macro __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES before this file is included
1236 * in their compilations. Clients who do not want the older macros defined can accomplish this by adding
1237 * #define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
1238 * at the top of their sources, or my adding -D__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES=0 to the
1239 * gcc compilation options.
1240 *
1241 * To aid users of these macros in converting their sources, the following tops script will convert usages
1242 * of the old macros into the new equivalents. To do so, in Terminal go into the directory containing the
1243 * sources to be converted and run this command.
1244 *
1245 find . -name '*.[c|cc|cp|cpp|m|mm|h]' -print0 | xargs -0 tops -verbose \
1246 replace "check(<b args>)" with "__Check(<args>)" \
1247 replace "check_noerr(<b args>)" with "__Check_noErr(<args>)" \
1248 replace "check_noerr_string(<b args>)" with "__Check_noErr_String(<args>)" \
1249 replace "check_string(<b args>)" with "__Check_String(<args>)" \
1250 replace "require(<b args>)" with "__Require(<args>)" \
1251 replace "require_action(<b args>)" with "__Require_Action(<args>)" \
1252 replace "require_action_string(<b args>)" with "__Require_Action_String(<args>)" \
1253 replace "require_noerr(<b args>)" with "__Require_noErr(<args>)" \
1254 replace "require_noerr_action(<b args>)" with "__Require_noErr_Action(<args>)" \
1255 replace "require_noerr_action_string(<b args>)" with "__Require_noErr_Action_String(<args>)" \
1256 replace "require_noerr_string(<b args>)" with "__Require_noErr_String(<args>)" \
1257 replace "require_string(<b args>)" with "__Require_String(<args>)" \
1258 replace "verify(<b args>)" with "__Verify(<args>)" \
1259 replace "verify_action(<b args>)" with "__Verify_Action(<args>)" \
1260 replace "verify_noerr(<b args>)" with "__Verify_noErr(<args>)" \
1261 replace "verify_noerr_action(<b args>)" with "__Verify_noErr_Action(<args>)" \
1262 replace "verify_noerr_string(<b args>)" with "__Verify_noErr_String(<args>)" \
1263 replace "verify_string(<b args>)" with "__Verify_String(<args>)" \
1264 replace "ncheck(<b args>)" with "__nCheck(<args>)" \
1265 replace "ncheck_string(<b args>)" with "__nCheck_String(<args>)" \
1266 replace "nrequire(<b args>)" with "__nRequire(<args>)" \
1267 replace "nrequire_action(<b args>)" with "__nRequire_Action(<args>)" \
1268 replace "nrequire_action_quiet(<b args>)" with "__nRequire_Action_Quiet(<args>)" \
1269 replace "nrequire_action_string(<b args>)" with "__nRequire_Action_String(<args>)" \
1270 replace "nrequire_quiet(<b args>)" with "__nRequire_Quiet(<args>)" \
1271 replace "nrequire_string(<b args>)" with "__nRequire_String(<args>)" \
1272 replace "nverify(<b args>)" with "__nVerify(<args>)" \
1273 replace "nverify_string(<b args>)" with "__nVerify_String(<args>)" \
1274 replace "require_action_quiet(<b args>)" with "__Require_Action_Quiet(<args>)" \
1275 replace "require_noerr_action_quiet(<b args>)" with "__Require_noErr_Action_Quiet(<args>)" \
1276 replace "require_noerr_quiet(<b args>)" with "__Require_noErr_Quiet(<args>)" \
1277 replace "require_quiet(<b args>)" with "__Require_Quiet(<args>)" \
1278 replace "check_compile_time(<b args>)" with "__Check_Compile_Time(<args>)" \
1279 replace "debug_string(<b args>)" with "__Debug_String(<args>)"
1280 *
1281 */
1282
1283#ifndef __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES
1284 /* If we haven't set this yet, it defaults to on. In the next release, this will default to off. */
1285 #define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 1
1286#endif
1287
1288#if __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES
1289
1290 #ifndef check
1291 #define check(assertion) __Check(assertion)
1292 #endif
1293
1294 #ifndef check_noerr
1295 #define check_noerr(errorCode) __Check_noErr(errorCode)
1296 #endif
1297
1298 #ifndef check_noerr_string
1299 #define check_noerr_string(errorCode, message) __Check_noErr_String(errorCode, message)
1300 #endif
1301
1302 #ifndef check_string
1303 #define check_string(assertion, message) __Check_String(assertion, message)
1304 #endif
1305
1306 #ifndef require
1307 #define require(assertion, exceptionLabel) __Require(assertion, exceptionLabel)
1308 #endif
1309
1310 #ifndef require_action
1311 #define require_action(assertion, exceptionLabel, action) __Require_Action(assertion, exceptionLabel, action)
1312 #endif
1313
1314 #ifndef require_action_string
1315 #define require_action_string(assertion, exceptionLabel, action, message) __Require_Action_String(assertion, exceptionLabel, action, message)
1316 #endif
1317
1318 #ifndef require_noerr
1319 #define require_noerr(errorCode, exceptionLabel) __Require_noErr(errorCode, exceptionLabel)
1320 #endif
b0d623f7 1321
39236c6e
A		 1322 #ifndef require_noerr_action
1323 #define require_noerr_action(errorCode, exceptionLabel, action) __Require_noErr_Action(errorCode, exceptionLabel, action)
1324 #endif
1325
1326 #ifndef require_noerr_action_string
1327 #define require_noerr_action_string(errorCode, exceptionLabel, action, message) __Require_noErr_Action_String(errorCode, exceptionLabel, action, message)
1328 #endif
1329
1330 #ifndef require_noerr_string
1331 #define require_noerr_string(errorCode, exceptionLabel, message) __Require_noErr_String(errorCode, exceptionLabel, message)
1332 #endif
1333
1334 #ifndef require_string
1335 #define require_string(assertion, exceptionLabel, message) __Require_String(assertion, exceptionLabel, message)
1336 #endif
1337
1338 #ifndef verify
1339 #define verify(assertion) __Verify(assertion)
1340 #endif
1341
1342 #ifndef verify_action
1343 #define verify_action(assertion, action) __Verify_Action(assertion, action)
1344 #endif
1345
1346 #ifndef verify_noerr
1347 #define verify_noerr(errorCode) __Verify_noErr(errorCode)
1348 #endif
1349
1350 #ifndef verify_noerr_action
1351 #define verify_noerr_action(errorCode, action) __Verify_noErr_Action(errorCode, action)
1352 #endif
1353
1354 #ifndef verify_noerr_string
1355 #define verify_noerr_string(errorCode, message) __Verify_noErr_String(errorCode, message)
1356 #endif
1357
1358 #ifndef verify_string
1359 #define verify_string(assertion, message) __Verify_String(assertion, message)
1360 #endif
1361
1362 #ifndef ncheck
1363 #define ncheck(assertion) __nCheck(assertion)
1364 #endif
1365
1366 #ifndef ncheck_string
1367 #define ncheck_string(assertion, message) __nCheck_String(assertion, message)
1368 #endif
1369
1370 #ifndef nrequire
1371 #define nrequire(assertion, exceptionLabel) __nRequire(assertion, exceptionLabel)
1372 #endif
1373
1374 #ifndef nrequire_action
1375 #define nrequire_action(assertion, exceptionLabel, action) __nRequire_Action(assertion, exceptionLabel, action)
1376 #endif
1377
1378 #ifndef nrequire_action_quiet
1379 #define nrequire_action_quiet(assertion, exceptionLabel, action) __nRequire_Action_Quiet(assertion, exceptionLabel, action)
1380 #endif
1381
1382 #ifndef nrequire_action_string
1383 #define nrequire_action_string(assertion, exceptionLabel, action, message) __nRequire_Action_String(assertion, exceptionLabel, action, message)
1384 #endif
1385
1386 #ifndef nrequire_quiet
1387 #define nrequire_quiet(assertion, exceptionLabel) __nRequire_Quiet(assertion, exceptionLabel)
1388 #endif
1389
1390 #ifndef nrequire_string
1391 #define nrequire_string(assertion, exceptionLabel, string) __nRequire_String(assertion, exceptionLabel, string)
1392 #endif
1393
1394 #ifndef nverify
1395 #define nverify(assertion) __nVerify(assertion)
1396 #endif
1397
1398 #ifndef nverify_string
1399 #define nverify_string(assertion, message) __nVerify_String(assertion, message)
1400 #endif
1401
1402 #ifndef require_action_quiet
1403 #define require_action_quiet(assertion, exceptionLabel, action) __Require_Action_Quiet(assertion, exceptionLabel, action)
1404 #endif
1405
1406 #ifndef require_noerr_action_quiet
1407 #define require_noerr_action_quiet(errorCode, exceptionLabel, action) __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action)
1408 #endif
1409
1410 #ifndef require_noerr_quiet
1411 #define require_noerr_quiet(errorCode, exceptionLabel) __Require_noErr_Quiet(errorCode, exceptionLabel)
1412 #endif
1413
1414 #ifndef require_quiet
1415 #define require_quiet(assertion, exceptionLabel) __Require_Quiet(assertion, exceptionLabel)
1416 #endif
1417
1418 #ifndef check_compile_time
1419 #define check_compile_time( expr ) __Check_Compile_Time( expr )
1420 #endif
1421
1422 #ifndef debug_string
1423 #define debug_string(message) __Debug_String(message)
1424 #endif
1425
1426#endif /* ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES */
1427
1428
1429#endif /* __ASSERTMACROS__ */
mirror of XNU