/*
- File: AssertMacros.h
-
- Contains: This file defines structured error handling and assertion macros for
- programming in C. Originally used in QuickDraw GX and later enhanced.
- These macros are used throughout Apple's software.
-
- See "Living In an Exceptional World" by Sean Parent
- (develop, The Apple Technical Journal, Issue 11, August/September 1992)
- <http://developer.apple.com/dev/techsupport/develop/issue11toc.shtml>
- for the methodology behind these error handling and assertion macros.
-
- Copyright: © 2002-2007 by Apple Inc., all rights reserved.
-
- Bugs?: For bug reports, consult the following page on
- the World Wide Web:
+ * Copyright (c) 2002-2008 by Apple Inc.. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+
+/*
+ File: AssertMacros.h
- http://developer.apple.com/bugreporter/
+ Contains: This file defines structured error handling and assertion macros for
+ programming in C. Originally used in QuickDraw GX and later enhanced.
+ These macros are used throughout Apple's software.
+
+ New code may not want to begin adopting these macros and instead use
+ existing language functionality.
+
+ See "Living In an Exceptional World" by Sean Parent
+ (develop, The Apple Technical Journal, Issue 11, August/September 1992)
+ <http://developer.apple.com/dev/techsupport/develop/issue11toc.shtml> or
+ <http://www.mactech.com/articles/develop/issue_11/Parent_final.html>
+ for the methodology behind these error handling and assertion macros.
+
+ Bugs?: For bug reports, consult the following page on
+ the World Wide Web:
+
+ http://developer.apple.com/bugreporter/
*/
#ifndef __ASSERTMACROS__
#define __ASSERTMACROS__
-
/*
* Macro overview:
*
* By default, all messages write to stderr. If you would like to write a custom
* error message formater, defined DEBUG_ASSERT_MESSAGE to your function name.
*
+ * Each individual macro will only be defined if it is not already defined, so
+ * you can redefine their behavior singly by providing your own definition before
+ * this file is included.
+ *
+ * If you define __ASSERTMACROS__ before this file is included, then nothing in
+ * this file will take effect.
+ *
+ * Prior to Mac OS X 10.6 the macro names used in this file conflicted with some
+ * user code, including libraries in boost and the proposed C++ standards efforts,
+ * and there was no way for a client of this header to resolve this conflict. Because
+ * of this, most of the macros have been changed so that they are prefixed with
+ * __ and contain at least one capital letter, which should alleviate the current
+ * and future conflicts. However, to allow current sources to continue to compile,
+ * compatibility macros are defined at the end with the old names. A tops script
+ * at the end of this file will convert all of the old macro names used in a directory
+ * to the new names. Clients are recommended to migrate over to these new macros as
+ * they update their sources because a future release of Mac OS X will remove the
+ * old macro definitions ( without the double-underscore prefix ). Clients who
+ * want to compile without the old macro definitions can define the macro
+ * __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES to 0 before this file is
+ * included.
*/
/*
- * debug_string(message)
+ * __Debug_String(message)
*
* Summary:
* Production builds: does nothing and produces no code.
* The C string to display.
*
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define debug_string(message)
-#else
- #define debug_string(message) \
- do \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- "", \
- 0, \
- message, \
- __FILE__, \
- __LINE__, \
- 0); \
- } while ( 0 )
+#ifndef __Debug_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Debug_String(message)
+ #else
+ #define __Debug_String(message) \
+ do \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ "", \
+ 0, \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ 0); \
+ } while ( 0 )
+ #endif
#endif
-
/*
- * check(assertion)
+ * __Check(assertion)
*
* Summary:
* Production builds: does nothing and produces no code.
* assertion:
* The assertion expression.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define check(assertion)
-#else
- #define check(assertion) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- 0, \
- 0, \
- __FILE__, \
- __LINE__, \
- 0); \
- } \
- } while ( 0 )
+#ifndef __Check
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Check(assertion)
+ #else
+ #define __Check(assertion) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, 0, 0, __FILE__, __LINE__, 0 ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define ncheck(assertion) \
- check(!(assertion))
-
+#ifndef __nCheck
+ #define __nCheck(assertion) __Check(!(assertion))
+#endif
/*
- * check_string(assertion, message)
+ * __Check_String(assertion, message)
*
* Summary:
* Production builds: does nothing and produces no code.
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define check_string(assertion, message)
-#else
- #define check_string(assertion, message) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- 0, \
- message, \
- __FILE__, \
- __LINE__, \
- 0); \
- } \
- } while ( 0 )
+#ifndef __Check_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Check_String(assertion, message)
+ #else
+ #define __Check_String(assertion, message) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, 0, message, __FILE__, __LINE__, 0 ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define ncheck_string(assertion, message) \
- check_string(!(assertion), message)
-
+#ifndef __nCheck_String
+ #define __nCheck_String(assertion, message) __Check_String(!(assertion), message)
+#endif
/*
- * check_noerr(errorCode)
+ * __Check_noErr(errorCode)
*
* Summary:
* Production builds: does nothing and produces no code.
* errorCode:
* The errorCode expression to compare with 0.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define check_noerr(errorCode)
-#else
- #define check_noerr(errorCode) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- 0, \
- 0, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- } \
- } while ( 0 )
+#ifndef __Check_noErr
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Check_noErr(errorCode)
+ #else
+ #define __Check_noErr(errorCode) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, evalOnceErrorCode ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
-
/*
- * check_noerr_string(errorCode, message)
+ * __Check_noErr_String(errorCode, message)
*
* Summary:
* Production builds: check_noerr_string() does nothing and produces
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define check_noerr_string(errorCode, message)
-#else
- #define check_noerr_string(errorCode, message) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- 0, \
- message, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- } \
- } while ( 0 )
+#ifndef __Check_noErr_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Check_noErr_String(errorCode, message)
+ #else
+ #define __Check_noErr_String(errorCode, message) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", 0, message, __FILE__, __LINE__, evalOnceErrorCode ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
-
/*
- * verify(assertion)
+ * __Verify(assertion)
*
* Summary:
* Production builds: evaluate the assertion expression, but ignore
* assertion:
* The assertion expression.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define verify(assertion) \
- do \
- { \
- if ( !(assertion) ) \
- { \
- } \
- } while ( 0 )
-#else
- #define verify(assertion) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- 0, \
- 0, \
- __FILE__, \
- __LINE__, \
- 0); \
- } \
- } while ( 0 )
+#ifndef __Verify
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Verify(assertion) \
+ do \
+ { \
+ if ( !(assertion) ) \
+ { \
+ } \
+ } while ( 0 )
+ #else
+ #define __Verify(assertion) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, 0, 0, __FILE__, __LINE__, 0 ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define nverify(assertion) \
- verify(!(assertion))
-
+#ifndef __nVerify
+ #define __nVerify(assertion) __Verify(!(assertion))
+#endif
/*
- * verify_string(assertion, message)
+ * __Verify_String(assertion, message)
*
* Summary:
* Production builds: evaluate the assertion expression, but ignore
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define verify_string(assertion, message) \
- do \
- { \
- if ( !(assertion) ) \
- { \
- } \
- } while ( 0 )
-#else
- #define verify_string(assertion, message) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- 0, \
- message, \
- __FILE__, \
- __LINE__, \
- 0); \
- } \
- } while ( 0 )
+#ifndef __Verify_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Verify_String(assertion, message) \
+ do \
+ { \
+ if ( !(assertion) ) \
+ { \
+ } \
+ } while ( 0 )
+ #else
+ #define __Verify_String(assertion, message) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, 0, message, __FILE__, __LINE__, 0 ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define nverify_string(assertion, message) \
- verify_string(!(assertion), message)
-
+#ifndef __nVerify_String
+ #define __nVerify_String(assertion, message) __Verify_String(!(assertion), message)
+#endif
/*
- * verify_noerr(errorCode)
+ * __Verify_noErr(errorCode)
*
* Summary:
* Production builds: evaluate the errorCode expression, but ignore
* errorCode:
* The expression to compare to 0.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define verify_noerr(errorCode) \
- do \
- { \
- if ( 0 != (errorCode) ) \
- { \
- } \
- } while ( 0 )
-#else
- #define verify_noerr(errorCode) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- 0, \
- 0, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- } \
- } while ( 0 )
+#ifndef __Verify_noErr
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Verify_noErr(errorCode) \
+ do \
+ { \
+ if ( 0 != (errorCode) ) \
+ { \
+ } \
+ } while ( 0 )
+ #else
+ #define __Verify_noErr(errorCode) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, evalOnceErrorCode ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
-
/*
- * verify_noerr_string(errorCode, message)
+ * __Verify_noErr_String(errorCode, message)
*
* Summary:
* Production builds: evaluate the errorCode expression, but ignore
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define verify_noerr_string(errorCode, message) \
- do \
- { \
- if ( 0 != (errorCode) ) \
- { \
- } \
- } while ( 0 )
-#else
- #define verify_noerr_string(errorCode, message) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- 0, \
- message, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- } \
- } while ( 0 )
+#ifndef __Verify_noErr_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Verify_noErr_String(errorCode, message) \
+ do \
+ { \
+ if ( 0 != (errorCode) ) \
+ { \
+ } \
+ } while ( 0 )
+ #else
+ #define __Verify_noErr_String(errorCode, message) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", 0, message, __FILE__, __LINE__, evalOnceErrorCode ); \
+ } \
+ } while ( 0 )
+ #endif
#endif
+/*
+ * __Verify_noErr_Action(errorCode, action)
+ *
+ * Summary:
+ * Production builds: if the errorCode expression does not equal 0 (noErr),
+ * execute the action statement or compound statement (block).
+ *
+ * Non-production builds: if the errorCode expression does not equal 0 (noErr),
+ * call DEBUG_ASSERT_MESSAGE and then execute the action statement or compound
+ * statement (block).
+ *
+ * Parameters:
+ *
+ * errorCode:
+ * The expression to compare to 0.
+ *
+ * action:
+ * The statement or compound statement (block).
+ */
+#ifndef __Verify_noErr_Action
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Verify_noErr_Action(errorCode, action) \
+ if ( 0 != (errorCode) ) { \
+ action; \
+ } \
+ else do {} while (0)
+ #else
+ #define __Verify_noErr_Action(errorCode, action) \
+ do { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, 0 ); \
+ action; \
+ } \
+ } while (0)
+ #endif
+#endif
/*
- * verify_action(assertion, action)
+ * __Verify_Action(assertion, action)
*
* Summary:
* Production builds: if the assertion expression evaluates to false,
* action:
* The statement or compound statement (block).
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define verify_action(assertion, action) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- action; \
- } \
- } while ( 0 )
-#else
- #define verify_action(assertion, action) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- 0, \
- 0, \
- __FILE__, \
- __LINE__, \
- 0); \
- { action; } \
- } \
- } while ( 0 )
+#ifndef __Verify_Action
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Verify_Action(assertion, action) \
+ if ( __builtin_expect(!(assertion), 0) ) { \
+ action; \
+ } \
+ else do {} while (0)
+ #else
+ #define __Verify_Action(assertion, action) \
+ if ( __builtin_expect(!(assertion), 0) ) { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, 0, 0, __FILE__, __LINE__, 0 ); \
+ action; \
+ } \
+ else do {} while (0)
+ #endif
#endif
-
/*
- * require(assertion, exceptionLabel)
+ * __Require(assertion, exceptionLabel)
*
* Summary:
* Production builds: if the assertion expression evaluates to false,
* exceptionLabel:
* The label.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require(assertion, exceptionLabel) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require(assertion, exceptionLabel) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- #exceptionLabel, \
- 0, \
- __FILE__, \
- __LINE__, \
- 0); \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require(assertion, exceptionLabel) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require(assertion, exceptionLabel) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, #exceptionLabel, 0, __FILE__, __LINE__, 0); \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define nrequire(assertion, exceptionLabel) \
- require(!(assertion), exceptionLabel)
-
+#ifndef __nRequire
+ #define __nRequire(assertion, exceptionLabel) __Require(!(assertion), exceptionLabel)
+#endif
/*
- * require_action(assertion, exceptionLabel, action)
+ * __Require_Action(assertion, exceptionLabel, action)
*
* Summary:
* Production builds: if the assertion expression evaluates to false,
* action:
* The statement or compound statement (block).
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require_action(assertion, exceptionLabel, action) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require_action(assertion, exceptionLabel, action) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- #exceptionLabel, \
- 0, \
- __FILE__, \
- __LINE__, \
- 0); \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require_Action
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require_Action(assertion, exceptionLabel, action) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require_Action(assertion, exceptionLabel, action) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, #exceptionLabel, 0, __FILE__, __LINE__, 0); \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define nrequire_action(assertion, exceptionLabel, action) \
- require_action(!(assertion), exceptionLabel, action)
-
+#ifndef __nRequire_Action
+ #define __nRequire_Action(assertion, exceptionLabel, action) \
+ __Require_Action(!(assertion), exceptionLabel, action)
+#endif
/*
- * require_quiet(assertion, exceptionLabel)
+ * __Require_Quiet(assertion, exceptionLabel)
*
* Summary:
* If the assertion expression evaluates to false, goto exceptionLabel.
* exceptionLabel:
* The label.
*/
-#define require_quiet(assertion, exceptionLabel) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-
-#define nrequire_quiet(assertion, exceptionLabel) \
- require_quiet(!(assertion), exceptionLabel)
+#ifndef __Require_Quiet
+ #define __Require_Quiet(assertion, exceptionLabel) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+#endif
+#ifndef __nRequire_Quiet
+ #define __nRequire_Quiet(assertion, exceptionLabel) __Require_Quiet(!(assertion), exceptionLabel)
+#endif
/*
- * require_action_quiet(assertion, exceptionLabel, action)
+ * __Require_Action_Quiet(assertion, exceptionLabel, action)
*
* Summary:
* If the assertion expression evaluates to false, execute the action
* action:
* The statement or compound statement (block).
*/
-#define require_action_quiet(assertion, exceptionLabel, action) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-
-#define nrequire_action_quiet(assertion, exceptionLabel, action) \
- require_action_quiet(!(assertion), exceptionLabel, action)
+#ifndef __Require_Action_Quiet
+ #define __Require_Action_Quiet(assertion, exceptionLabel, action) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+#endif
+#ifndef __nRequire_Action_Quiet
+ #define __nRequire_Action_Quiet(assertion, exceptionLabel, action) \
+ __Require_Action_Quiet(!(assertion), exceptionLabel, action)
+#endif
/*
- * require_string(assertion, exceptionLabel, message)
+ * __Require_String(assertion, exceptionLabel, message)
*
* Summary:
* Production builds: if the assertion expression evaluates to false,
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require_string(assertion, exceptionLabel, message) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require_string(assertion, exceptionLabel, message) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- #exceptionLabel, \
- message, \
- __FILE__, \
- __LINE__, \
- 0); \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require_String(assertion, exceptionLabel, message) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require_String(assertion, exceptionLabel, message) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, #exceptionLabel, message, __FILE__, __LINE__, 0); \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define nrequire_string(assertion, exceptionLabel, string) \
- require_string(!(assertion), exceptionLabel, string)
-
+#ifndef __nRequire_String
+ #define __nRequire_String(assertion, exceptionLabel, string) \
+ __Require_String(!(assertion), exceptionLabel, string)
+#endif
/*
- * require_action_string(assertion, exceptionLabel, action, message)
+ * __Require_Action_String(assertion, exceptionLabel, action, message)
*
* Summary:
* Production builds: if the assertion expression evaluates to false,
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require_action_string(assertion, exceptionLabel, action, message) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require_action_string(assertion, exceptionLabel, action, message) \
- do \
- { \
- if ( __builtin_expect(!(assertion), 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #assertion, \
- #exceptionLabel, \
- message, \
- __FILE__, \
- __LINE__, \
- 0); \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require_Action_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require_Action_String(assertion, exceptionLabel, action, message) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require_Action_String(assertion, exceptionLabel, action, message) \
+ do \
+ { \
+ if ( __builtin_expect(!(assertion), 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #assertion, #exceptionLabel, message, __FILE__, __LINE__, 0); \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
-#define nrequire_action_string(assertion, exceptionLabel, action, message) \
- require_action_string(!(assertion), exceptionLabel, action, message)
-
+#ifndef __nRequire_Action_String
+ #define __nRequire_Action_String(assertion, exceptionLabel, action, message) \
+ __Require_Action_String(!(assertion), exceptionLabel, action, message)
+#endif
/*
- * require_noerr(errorCode, exceptionLabel)
+ * __Require_noErr(errorCode, exceptionLabel)
*
* Summary:
* Production builds: if the errorCode expression does not equal 0 (noErr),
* exceptionLabel:
* The label.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require_noerr(errorCode, exceptionLabel) \
- do \
- { \
- if ( __builtin_expect(0 != (errorCode), 0) ) \
- { \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require_noerr(errorCode, exceptionLabel) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- #exceptionLabel, \
- 0, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require_noErr
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require_noErr(errorCode, exceptionLabel) \
+ do \
+ { \
+ if ( __builtin_expect(0 != (errorCode), 0) ) \
+ { \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require_noErr(errorCode, exceptionLabel) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", #exceptionLabel, 0, __FILE__, __LINE__, evalOnceErrorCode); \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
/*
- * require_noerr_action(errorCode, exceptionLabel, action)
+ * __Require_noErr_Action(errorCode, exceptionLabel, action)
*
* Summary:
* Production builds: if the errorCode expression does not equal 0 (noErr),
* action:
* The statement or compound statement (block).
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require_noerr_action(errorCode, exceptionLabel, action) \
- do \
- { \
- if ( __builtin_expect(0 != (errorCode), 0) ) \
- { \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require_noerr_action(errorCode, exceptionLabel, action) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- #exceptionLabel, \
- 0, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require_noErr_Action
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require_noErr_Action(errorCode, exceptionLabel, action) \
+ do \
+ { \
+ if ( __builtin_expect(0 != (errorCode), 0) ) \
+ { \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require_noErr_Action(errorCode, exceptionLabel, action) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", #exceptionLabel, 0, __FILE__, __LINE__, evalOnceErrorCode); \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
-
/*
- * require_noerr_quiet(errorCode, exceptionLabel)
+ * __Require_noErr_Quiet(errorCode, exceptionLabel)
*
* Summary:
* If the errorCode expression does not equal 0 (noErr),
* exceptionLabel:
* The label.
*/
-#define require_noerr_quiet(errorCode, exceptionLabel) \
- do \
- { \
- if ( __builtin_expect(0 != (errorCode), 0) ) \
- { \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-
+#ifndef __Require_noErr_Quiet
+ #define __Require_noErr_Quiet(errorCode, exceptionLabel) \
+ do \
+ { \
+ if ( __builtin_expect(0 != (errorCode), 0) ) \
+ { \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+#endif
/*
- * require_noerr_action_quiet(errorCode, exceptionLabel, action)
+ * __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action)
*
* Summary:
* If the errorCode expression does not equal 0 (noErr),
* action:
* The statement or compound statement (block).
*/
-#define require_noerr_action_quiet(errorCode, exceptionLabel, action) \
- do \
- { \
- if ( __builtin_expect(0 != (errorCode), 0) ) \
- { \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-
+#ifndef __Require_noErr_Action_Quiet
+ #define __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action) \
+ do \
+ { \
+ if ( __builtin_expect(0 != (errorCode), 0) ) \
+ { \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+#endif
/*
- * require_noerr_string(errorCode, exceptionLabel, message)
+ * __Require_noErr_String(errorCode, exceptionLabel, message)
*
* Summary:
* Production builds: if the errorCode expression does not equal 0 (noErr),
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require_noerr_string(errorCode, exceptionLabel, message) \
- do \
- { \
- if ( __builtin_expect(0 != (errorCode), 0) ) \
- { \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require_noerr_string(errorCode, exceptionLabel, message) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- #exceptionLabel, \
- message, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require_noErr_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require_noErr_String(errorCode, exceptionLabel, message) \
+ do \
+ { \
+ if ( __builtin_expect(0 != (errorCode), 0) ) \
+ { \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require_noErr_String(errorCode, exceptionLabel, message) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", #exceptionLabel, message, __FILE__, __LINE__, evalOnceErrorCode); \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
-
/*
- * require_noerr_action_string(errorCode, exceptionLabel, action, message)
+ * __Require_noErr_Action_String(errorCode, exceptionLabel, action, message)
*
* Summary:
* Production builds: if the errorCode expression does not equal 0 (noErr),
* message:
* The C string to display.
*/
-#if DEBUG_ASSERT_PRODUCTION_CODE
- #define require_noerr_action_string(errorCode, exceptionLabel, action, message)\
- do \
- { \
- if ( __builtin_expect(0 != (errorCode), 0) ) \
- { \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
-#else
- #define require_noerr_action_string(errorCode, exceptionLabel, action, message) \
- do \
- { \
- long evalOnceErrorCode = (errorCode); \
- if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
- { \
- DEBUG_ASSERT_MESSAGE( \
- DEBUG_ASSERT_COMPONENT_NAME_STRING, \
- #errorCode " == 0 ", \
- #exceptionLabel, \
- message, \
- __FILE__, \
- __LINE__, \
- evalOnceErrorCode); \
- { \
- action; \
- } \
- goto exceptionLabel; \
- } \
- } while ( 0 )
+#ifndef __Require_noErr_Action_String
+ #if DEBUG_ASSERT_PRODUCTION_CODE
+ #define __Require_noErr_Action_String(errorCode, exceptionLabel, action, message) \
+ do \
+ { \
+ if ( __builtin_expect(0 != (errorCode), 0) ) \
+ { \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #else
+ #define __Require_noErr_Action_String(errorCode, exceptionLabel, action, message) \
+ do \
+ { \
+ long evalOnceErrorCode = (errorCode); \
+ if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) \
+ { \
+ DEBUG_ASSERT_MESSAGE( \
+ DEBUG_ASSERT_COMPONENT_NAME_STRING, \
+ #errorCode " == 0 ", #exceptionLabel, message, __FILE__, __LINE__, evalOnceErrorCode); \
+ { \
+ action; \
+ } \
+ goto exceptionLabel; \
+ } \
+ } while ( 0 )
+ #endif
#endif
+/*
+ * __Check_Compile_Time(expr)
+ *
+ * Summary:
+ * any build: if the expression is not true, generated a compile time error.
+ *
+ * Parameters:
+ *
+ * expr:
+ * The compile time expression that should evaluate to non-zero.
+ *
+ * Discussion:
+ * This declares an array with a size that is determined by a compile-time expression.
+ * If false, it declares a negatively sized array, which generates a compile-time error.
+ *
+ * Examples:
+ * __Check_Compile_Time( sizeof( int ) == 4 );
+ * __Check_Compile_Time( offsetof( MyStruct, myField ) == 4 );
+ * __Check_Compile_Time( ( kMyBufferSize % 512 ) == 0 );
+ *
+ * Note: This only works with compile-time expressions.
+ * Note: This only works in places where extern declarations are allowed (e.g. global scope).
+ */
+#ifndef __Check_Compile_Time
+ #ifdef __GNUC__
+ #define __Check_Compile_Time( expr ) \
+ extern int compile_time_assert_failed[ ( expr ) ? 1 : -1 ] __attribute__( ( unused ) )
+ #else
+ #define __Check_Compile_Time( expr ) \
+ extern int compile_time_assert_failed[ ( expr ) ? 1 : -1 ]
+ #endif
+#endif
-#endif /* __ASSERTMACROS__ */
+/*
+ * For time immemorial, Mac OS X has defined version of most of these macros without the __ prefix, which
+ * could collide with similarly named functions or macros in user code, including new functionality in
+ * Boost and the C++ standard library.
+ *
+ * A future release of Mac OS X will no longer do this, and will require that clients move to the
+ * new macros as defined above. However, in the interim both the new and old macros will work, unless
+ * clients define a macro __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES before this file is included
+ * in their compilations. Clients who do not want the older macros defined can accomplish this by adding
+ * #define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+ * at the top of their sources, or my adding -D__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES=0 to the
+ * gcc compilation options.
+ *
+ * To aid users of these macros in converting their sources, the following tops script will convert usages
+ * of the old macros into the new equivalents. To do so, in Terminal go into the directory containing the
+ * sources to be converted and run this command.
+ *
+ find . -name '*.[c|cc|cp|cpp|m|mm|h]' -print0 | xargs -0 tops -verbose \
+ replace "check(<b args>)" with "__Check(<args>)" \
+ replace "check_noerr(<b args>)" with "__Check_noErr(<args>)" \
+ replace "check_noerr_string(<b args>)" with "__Check_noErr_String(<args>)" \
+ replace "check_string(<b args>)" with "__Check_String(<args>)" \
+ replace "require(<b args>)" with "__Require(<args>)" \
+ replace "require_action(<b args>)" with "__Require_Action(<args>)" \
+ replace "require_action_string(<b args>)" with "__Require_Action_String(<args>)" \
+ replace "require_noerr(<b args>)" with "__Require_noErr(<args>)" \
+ replace "require_noerr_action(<b args>)" with "__Require_noErr_Action(<args>)" \
+ replace "require_noerr_action_string(<b args>)" with "__Require_noErr_Action_String(<args>)" \
+ replace "require_noerr_string(<b args>)" with "__Require_noErr_String(<args>)" \
+ replace "require_string(<b args>)" with "__Require_String(<args>)" \
+ replace "verify(<b args>)" with "__Verify(<args>)" \
+ replace "verify_action(<b args>)" with "__Verify_Action(<args>)" \
+ replace "verify_noerr(<b args>)" with "__Verify_noErr(<args>)" \
+ replace "verify_noerr_action(<b args>)" with "__Verify_noErr_Action(<args>)" \
+ replace "verify_noerr_string(<b args>)" with "__Verify_noErr_String(<args>)" \
+ replace "verify_string(<b args>)" with "__Verify_String(<args>)" \
+ replace "ncheck(<b args>)" with "__nCheck(<args>)" \
+ replace "ncheck_string(<b args>)" with "__nCheck_String(<args>)" \
+ replace "nrequire(<b args>)" with "__nRequire(<args>)" \
+ replace "nrequire_action(<b args>)" with "__nRequire_Action(<args>)" \
+ replace "nrequire_action_quiet(<b args>)" with "__nRequire_Action_Quiet(<args>)" \
+ replace "nrequire_action_string(<b args>)" with "__nRequire_Action_String(<args>)" \
+ replace "nrequire_quiet(<b args>)" with "__nRequire_Quiet(<args>)" \
+ replace "nrequire_string(<b args>)" with "__nRequire_String(<args>)" \
+ replace "nverify(<b args>)" with "__nVerify(<args>)" \
+ replace "nverify_string(<b args>)" with "__nVerify_String(<args>)" \
+ replace "require_action_quiet(<b args>)" with "__Require_Action_Quiet(<args>)" \
+ replace "require_noerr_action_quiet(<b args>)" with "__Require_noErr_Action_Quiet(<args>)" \
+ replace "require_noerr_quiet(<b args>)" with "__Require_noErr_Quiet(<args>)" \
+ replace "require_quiet(<b args>)" with "__Require_Quiet(<args>)" \
+ replace "check_compile_time(<b args>)" with "__Check_Compile_Time(<args>)" \
+ replace "debug_string(<b args>)" with "__Debug_String(<args>)"
+ *
+ */
+
+#ifndef __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES
+ /* If we haven't set this yet, it defaults to on. In the next release, this will default to off. */
+ #define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 1
+#endif
+
+#if __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES
+
+ #ifndef check
+ #define check(assertion) __Check(assertion)
+ #endif
+
+ #ifndef check_noerr
+ #define check_noerr(errorCode) __Check_noErr(errorCode)
+ #endif
+
+ #ifndef check_noerr_string
+ #define check_noerr_string(errorCode, message) __Check_noErr_String(errorCode, message)
+ #endif
+
+ #ifndef check_string
+ #define check_string(assertion, message) __Check_String(assertion, message)
+ #endif
+
+ #ifndef require
+ #define require(assertion, exceptionLabel) __Require(assertion, exceptionLabel)
+ #endif
+
+ #ifndef require_action
+ #define require_action(assertion, exceptionLabel, action) __Require_Action(assertion, exceptionLabel, action)
+ #endif
+
+ #ifndef require_action_string
+ #define require_action_string(assertion, exceptionLabel, action, message) __Require_Action_String(assertion, exceptionLabel, action, message)
+ #endif
+
+ #ifndef require_noerr
+ #define require_noerr(errorCode, exceptionLabel) __Require_noErr(errorCode, exceptionLabel)
+ #endif
+ #ifndef require_noerr_action
+ #define require_noerr_action(errorCode, exceptionLabel, action) __Require_noErr_Action(errorCode, exceptionLabel, action)
+ #endif
+
+ #ifndef require_noerr_action_string
+ #define require_noerr_action_string(errorCode, exceptionLabel, action, message) __Require_noErr_Action_String(errorCode, exceptionLabel, action, message)
+ #endif
+
+ #ifndef require_noerr_string
+ #define require_noerr_string(errorCode, exceptionLabel, message) __Require_noErr_String(errorCode, exceptionLabel, message)
+ #endif
+
+ #ifndef require_string
+ #define require_string(assertion, exceptionLabel, message) __Require_String(assertion, exceptionLabel, message)
+ #endif
+
+ #ifndef verify
+ #define verify(assertion) __Verify(assertion)
+ #endif
+
+ #ifndef verify_action
+ #define verify_action(assertion, action) __Verify_Action(assertion, action)
+ #endif
+
+ #ifndef verify_noerr
+ #define verify_noerr(errorCode) __Verify_noErr(errorCode)
+ #endif
+
+ #ifndef verify_noerr_action
+ #define verify_noerr_action(errorCode, action) __Verify_noErr_Action(errorCode, action)
+ #endif
+
+ #ifndef verify_noerr_string
+ #define verify_noerr_string(errorCode, message) __Verify_noErr_String(errorCode, message)
+ #endif
+
+ #ifndef verify_string
+ #define verify_string(assertion, message) __Verify_String(assertion, message)
+ #endif
+
+ #ifndef ncheck
+ #define ncheck(assertion) __nCheck(assertion)
+ #endif
+
+ #ifndef ncheck_string
+ #define ncheck_string(assertion, message) __nCheck_String(assertion, message)
+ #endif
+
+ #ifndef nrequire
+ #define nrequire(assertion, exceptionLabel) __nRequire(assertion, exceptionLabel)
+ #endif
+
+ #ifndef nrequire_action
+ #define nrequire_action(assertion, exceptionLabel, action) __nRequire_Action(assertion, exceptionLabel, action)
+ #endif
+
+ #ifndef nrequire_action_quiet
+ #define nrequire_action_quiet(assertion, exceptionLabel, action) __nRequire_Action_Quiet(assertion, exceptionLabel, action)
+ #endif
+
+ #ifndef nrequire_action_string
+ #define nrequire_action_string(assertion, exceptionLabel, action, message) __nRequire_Action_String(assertion, exceptionLabel, action, message)
+ #endif
+
+ #ifndef nrequire_quiet
+ #define nrequire_quiet(assertion, exceptionLabel) __nRequire_Quiet(assertion, exceptionLabel)
+ #endif
+
+ #ifndef nrequire_string
+ #define nrequire_string(assertion, exceptionLabel, string) __nRequire_String(assertion, exceptionLabel, string)
+ #endif
+
+ #ifndef nverify
+ #define nverify(assertion) __nVerify(assertion)
+ #endif
+
+ #ifndef nverify_string
+ #define nverify_string(assertion, message) __nVerify_String(assertion, message)
+ #endif
+
+ #ifndef require_action_quiet
+ #define require_action_quiet(assertion, exceptionLabel, action) __Require_Action_Quiet(assertion, exceptionLabel, action)
+ #endif
+
+ #ifndef require_noerr_action_quiet
+ #define require_noerr_action_quiet(errorCode, exceptionLabel, action) __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action)
+ #endif
+
+ #ifndef require_noerr_quiet
+ #define require_noerr_quiet(errorCode, exceptionLabel) __Require_noErr_Quiet(errorCode, exceptionLabel)
+ #endif
+
+ #ifndef require_quiet
+ #define require_quiet(assertion, exceptionLabel) __Require_Quiet(assertion, exceptionLabel)
+ #endif
+
+ #ifndef check_compile_time
+ #define check_compile_time( expr ) __Check_Compile_Time( expr )
+ #endif
+
+ #ifndef debug_string
+ #define debug_string(message) __Debug_String(message)
+ #endif
+
+#endif /* ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES */
+
+
+#endif /* __ASSERTMACROS__ */
projects / apple / xnu.git / blobdiff