1 /* 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 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 /* 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 * 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. 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 /* 229 * __Debug_String(message) 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 */ 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 259 #endif 260 261 /* 262 * __Check(assertion) 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 */ 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 290 #endif 291 292 #ifndef __nCheck 293 #define __nCheck(assertion) __Check(!(assertion)) 294 #endif 295 296 /* 297 * __Check_String(assertion, message) 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 */ 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 328 #endif 329 330 #ifndef __nCheck_String 331 #define __nCheck_String(assertion, message) __Check_String(!(assertion), message) 332 #endif 333 334 /* 335 * __Check_noErr(errorCode) 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 */ 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 364 #endif 365 366 /* 367 * __Check_noErr_String(errorCode, message) 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 */ 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 400 #endif 401 402 /* 403 * __Verify(assertion) 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 */ 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 438 #endif 439 440 #ifndef __nVerify 441 #define __nVerify(assertion) __Verify(!(assertion)) 442 #endif 443 444 /* 445 * __Verify_String(assertion, message) 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 */ 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 483 #endif 484 485 #ifndef __nVerify_String 486 #define __nVerify_String(assertion, message) __Verify_String(!(assertion), message) 487 #endif 488 489 /* 490 * __Verify_noErr(errorCode) 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 */ 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 526 #endif 527 528 /* 529 * __Verify_noErr_String(errorCode, message) 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 */ 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 568 #endif 569 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__, evalOnceErrorCode ); \ 604 action; \ 605 } \ 606 } while (0) 607 #endif 608 #endif 609 610 /* 611 * __Verify_Action(assertion, action) 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 */ 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 646 #endif 647 648 /* 649 * __Require(assertion, exceptionLabel) 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 */ 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 688 #endif 689 690 #ifndef __nRequire 691 #define __nRequire(assertion, exceptionLabel) __Require(!(assertion), exceptionLabel) 692 #endif 693 694 /* 695 * __Require_Action(assertion, exceptionLabel, action) 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 */ 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 746 #endif 747 748 #ifndef __nRequire_Action 749 #define __nRequire_Action(assertion, exceptionLabel, action) \ 750 __Require_Action(!(assertion), exceptionLabel, action) 751 #endif 752 753 /* 754 * __Require_Quiet(assertion, exceptionLabel) 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 */ 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 777 778 #ifndef __nRequire_Quiet 779 #define __nRequire_Quiet(assertion, exceptionLabel) __Require_Quiet(!(assertion), exceptionLabel) 780 #endif 781 782 /* 783 * __Require_Action_Quiet(assertion, exceptionLabel, action) 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 */ 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 813 814 #ifndef __nRequire_Action_Quiet 815 #define __nRequire_Action_Quiet(assertion, exceptionLabel, action) \ 816 __Require_Action_Quiet(!(assertion), exceptionLabel, action) 817 #endif 818 819 /* 820 * __Require_String(assertion, exceptionLabel, message) 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 */ 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 863 #endif 864 865 #ifndef __nRequire_String 866 #define __nRequire_String(assertion, exceptionLabel, string) \ 867 __Require_String(!(assertion), exceptionLabel, string) 868 #endif 869 870 /* 871 * __Require_Action_String(assertion, exceptionLabel, action, message) 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 */ 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 925 #endif 926 927 #ifndef __nRequire_Action_String 928 #define __nRequire_Action_String(assertion, exceptionLabel, action, message) \ 929 __Require_Action_String(!(assertion), exceptionLabel, action, message) 930 #endif 931 932 /* 933 * __Require_noErr(errorCode, exceptionLabel) 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 */ 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 974 #endif 975 976 /* 977 * __Require_noErr_Action(errorCode, exceptionLabel, action) 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 */ 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 1029 #endif 1030 1031 /* 1032 * __Require_noErr_Quiet(errorCode, exceptionLabel) 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 */ 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 1056 1057 /* 1058 * __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action) 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 */ 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 1089 1090 /* 1091 * __Require_noErr_String(errorCode, exceptionLabel, message) 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 */ 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 1135 #endif 1136 1137 /* 1138 * __Require_noErr_Action_String(errorCode, exceptionLabel, action, message) 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 */ 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 1193 #endif 1194 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 1227 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 1321 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__ */ 1430