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