1429 lines
58 KiB
C
1429 lines
58 KiB
C
/*
|
|
* 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
|
|
|
|
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:
|
|
*
|
|
* check(assertion)
|
|
* In production builds, pre-processed away
|
|
* In debug builds, if assertion evaluates to false, calls DEBUG_ASSERT_MESSAGE
|
|
*
|
|
* verify(assertion)
|
|
* In production builds, evaluates assertion and does nothing
|
|
* In debug builds, if assertion evaluates to false, calls DEBUG_ASSERT_MESSAGE
|
|
*
|
|
* require(assertion, exceptionLabel)
|
|
* In production builds, if the assertion expression evaluates to false, goto exceptionLabel
|
|
* In debug builds, if the assertion expression evaluates to false, calls DEBUG_ASSERT_MESSAGE
|
|
* and jumps to exceptionLabel
|
|
*
|
|
* In addition the following suffixes are available:
|
|
*
|
|
* _noerr Adds "!= 0" to assertion. Useful for asserting and OSStatus or OSErr is noErr (zero)
|
|
* _action Adds statement to be executued if assertion fails
|
|
* _quiet Suppress call to DEBUG_ASSERT_MESSAGE
|
|
* _string Allows you to add explanitory message to DEBUG_ASSERT_MESSAGE
|
|
*
|
|
* For instance, require_noerr_string(resultCode, label, msg) will do nothing if
|
|
* resultCode is zero, otherwise it will call DEBUG_ASSERT_MESSAGE with msg
|
|
* and jump to label.
|
|
*
|
|
* Configuration:
|
|
*
|
|
* By default all macros generate "production code" (i.e non-debug). If
|
|
* DEBUG_ASSERT_PRODUCTION_CODE is defined to zero or DEBUG is defined to non-zero
|
|
* while this header is included, the macros will generated debug code.
|
|
*
|
|
* If DEBUG_ASSERT_COMPONENT_NAME_STRING is defined, all debug messages will
|
|
* be prefixed with it.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
|
|
/*
|
|
* Before including this file, #define DEBUG_ASSERT_COMPONENT_NAME_STRING to
|
|
* a C-string containing the name of your client. This string will be passed to
|
|
* the DEBUG_ASSERT_MESSAGE macro for inclusion in any assertion messages.
|
|
*
|
|
* If you do not define DEBUG_ASSERT_COMPONENT_NAME_STRING, the default
|
|
* DEBUG_ASSERT_COMPONENT_NAME_STRING value, an empty string, will be used by
|
|
* the assertion macros.
|
|
*/
|
|
#ifndef DEBUG_ASSERT_COMPONENT_NAME_STRING
|
|
#define DEBUG_ASSERT_COMPONENT_NAME_STRING ""
|
|
#endif
|
|
|
|
|
|
/*
|
|
* To activate the additional assertion code and messages for non-production builds,
|
|
* #define DEBUG_ASSERT_PRODUCTION_CODE to zero before including this file.
|
|
*
|
|
* If you do not define DEBUG_ASSERT_PRODUCTION_CODE, the default value 1 will be used
|
|
* (production code = no assertion code and no messages).
|
|
*/
|
|
#ifndef DEBUG_ASSERT_PRODUCTION_CODE
|
|
#define DEBUG_ASSERT_PRODUCTION_CODE !DEBUG
|
|
#endif
|
|
|
|
|
|
/*
|
|
* DEBUG_ASSERT_MESSAGE(component, assertion, label, error, file, line, errorCode)
|
|
*
|
|
* Summary:
|
|
* All assertion messages are routed through this macro. If you wish to use your
|
|
* own routine to display assertion messages, you can override DEBUG_ASSERT_MESSAGE
|
|
* by #defining DEBUG_ASSERT_MESSAGE before including this file.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* componentNameString:
|
|
* A pointer to a string constant containing the name of the
|
|
* component this code is part of. This must be a string constant
|
|
* (and not a string variable or NULL) because the preprocessor
|
|
* concatenates it with other string constants.
|
|
*
|
|
* assertionString:
|
|
* A pointer to a string constant containing the assertion.
|
|
* This must be a string constant (and not a string variable or
|
|
* NULL) because the Preprocessor concatenates it with other
|
|
* string constants.
|
|
*
|
|
* exceptionLabelString:
|
|
* A pointer to a string containing the exceptionLabel, or NULL.
|
|
*
|
|
* errorString:
|
|
* A pointer to the error string, or NULL. DEBUG_ASSERT_MESSAGE macros
|
|
* must not attempt to concatenate this string with constant
|
|
* character strings.
|
|
*
|
|
* fileName:
|
|
* A pointer to the fileName or pathname (generated by the
|
|
* preprocessor __FILE__ identifier), or NULL.
|
|
*
|
|
* lineNumber:
|
|
* The line number in the file (generated by the preprocessor
|
|
* __LINE__ identifier), or 0 (zero).
|
|
*
|
|
* errorCode:
|
|
* A value associated with the assertion, or 0.
|
|
*
|
|
* Here is an example of a DEBUG_ASSERT_MESSAGE macro and a routine which displays
|
|
* assertion messsages:
|
|
*
|
|
* #define DEBUG_ASSERT_COMPONENT_NAME_STRING "MyCoolProgram"
|
|
*
|
|
* #define DEBUG_ASSERT_MESSAGE(componentNameString, assertionString, \
|
|
* exceptionLabelString, errorString, fileName, lineNumber, errorCode) \
|
|
* MyProgramDebugAssert(componentNameString, assertionString, \
|
|
* exceptionLabelString, errorString, fileName, lineNumber, errorCode)
|
|
*
|
|
* static void
|
|
* MyProgramDebugAssert(const char *componentNameString, const char *assertionString,
|
|
* const char *exceptionLabelString, const char *errorString,
|
|
* const char *fileName, long lineNumber, int errorCode)
|
|
* {
|
|
* if ( (assertionString != NULL) && (*assertionString != '\0') )
|
|
* fprintf(stderr, "Assertion failed: %s: %s\n", componentNameString, assertionString);
|
|
* else
|
|
* fprintf(stderr, "Check failed: %s:\n", componentNameString);
|
|
* if ( exceptionLabelString != NULL )
|
|
* fprintf(stderr, " %s\n", exceptionLabelString);
|
|
* if ( errorString != NULL )
|
|
* fprintf(stderr, " %s\n", errorString);
|
|
* if ( fileName != NULL )
|
|
* fprintf(stderr, " file: %s\n", fileName);
|
|
* if ( lineNumber != 0 )
|
|
* fprintf(stderr, " line: %ld\n", lineNumber);
|
|
* if ( errorCode != 0 )
|
|
* fprintf(stderr, " error: %d\n", errorCode);
|
|
* }
|
|
*
|
|
* If you do not define DEBUG_ASSERT_MESSAGE, a simple printf to stderr will be used.
|
|
*/
|
|
#ifndef DEBUG_ASSERT_MESSAGE
|
|
#ifdef KERNEL
|
|
#include <libkern/libkern.h>
|
|
#define DEBUG_ASSERT_MESSAGE(name, assertion, label, message, file, line, value) \
|
|
printf( "AssertMacros: %s, %s file: %s, line: %d\n", assertion, (message!=0) ? message : "", file, line);
|
|
#else
|
|
#include <stdio.h>
|
|
#define DEBUG_ASSERT_MESSAGE(name, assertion, label, message, file, line, value) \
|
|
fprintf(stderr, "AssertMacros: %s, %s file: %s, line: %d\n", assertion, (message!=0) ? message : "", file, line);
|
|
#endif
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
* __Debug_String(message)
|
|
*
|
|
* Summary:
|
|
* Production builds: does nothing and produces no code.
|
|
*
|
|
* Non-production builds: call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* Production builds: does nothing and produces no code.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nCheck
|
|
#define __nCheck(assertion) __Check(!(assertion))
|
|
#endif
|
|
|
|
/*
|
|
* __Check_String(assertion, message)
|
|
*
|
|
* Summary:
|
|
* Production builds: does nothing and produces no code.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nCheck_String
|
|
#define __nCheck_String(assertion, message) __Check_String(!(assertion), message)
|
|
#endif
|
|
|
|
/*
|
|
* __Check_noErr(errorCode)
|
|
*
|
|
* Summary:
|
|
* Production builds: does nothing and produces no code.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The errorCode expression to compare with 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)
|
|
*
|
|
* Summary:
|
|
* Production builds: check_noerr_string() does nothing and produces
|
|
* no code.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The errorCode expression to compare to 0.
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* Production builds: evaluate the assertion expression, but ignore
|
|
* the result.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nVerify
|
|
#define __nVerify(assertion) __Verify(!(assertion))
|
|
#endif
|
|
|
|
/*
|
|
* __Verify_String(assertion, message)
|
|
*
|
|
* Summary:
|
|
* Production builds: evaluate the assertion expression, but ignore
|
|
* the result.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nVerify_String
|
|
#define __nVerify_String(assertion, message) __Verify_String(!(assertion), message)
|
|
#endif
|
|
|
|
/*
|
|
* __Verify_noErr(errorCode)
|
|
*
|
|
* Summary:
|
|
* Production builds: evaluate the errorCode expression, but ignore
|
|
* the result.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 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)
|
|
*
|
|
* Summary:
|
|
* Production builds: evaluate the errorCode expression, but ignore
|
|
* the result.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 0.
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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__, evalOnceErrorCode ); \
|
|
action; \
|
|
} \
|
|
} while (0)
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
* __Verify_Action(assertion, action)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the assertion expression evaluates to false,
|
|
* then execute the action statement or compound statement (block).
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE and then execute the action statement or compound
|
|
* statement (block).
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* action:
|
|
* The statement or compound statement (block).
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the assertion expression evaluates to false,
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nRequire
|
|
#define __nRequire(assertion, exceptionLabel) __Require(!(assertion), exceptionLabel)
|
|
#endif
|
|
|
|
/*
|
|
* __Require_Action(assertion, exceptionLabel, action)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the assertion expression evaluates to false,
|
|
* execute the action statement or compound statement (block) and then
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
|
|
* statement (block), and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* action:
|
|
* The statement or compound statement (block).
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nRequire_Action
|
|
#define __nRequire_Action(assertion, exceptionLabel, action) \
|
|
__Require_Action(!(assertion), exceptionLabel, action)
|
|
#endif
|
|
|
|
/*
|
|
* __Require_Quiet(assertion, exceptionLabel)
|
|
*
|
|
* Summary:
|
|
* If the assertion expression evaluates to false, goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* If the assertion expression evaluates to false, execute the action
|
|
* statement or compound statement (block), and goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* action:
|
|
* The statement or compound statement (block).
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the assertion expression evaluates to false,
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE, and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nRequire_String
|
|
#define __nRequire_String(assertion, exceptionLabel, string) \
|
|
__Require_String(!(assertion), exceptionLabel, string)
|
|
#endif
|
|
|
|
/*
|
|
* __Require_Action_String(assertion, exceptionLabel, action, message)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the assertion expression evaluates to false,
|
|
* execute the action statement or compound statement (block), and then
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the assertion expression evaluates to false,
|
|
* call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
|
|
* statement (block), and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* assertion:
|
|
* The assertion expression.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* action:
|
|
* The statement or compound statement (block).
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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
|
|
|
|
#ifndef __nRequire_Action_String
|
|
#define __nRequire_Action_String(assertion, exceptionLabel, action, message) \
|
|
__Require_Action_String(!(assertion), exceptionLabel, action, message)
|
|
#endif
|
|
|
|
/*
|
|
* __Require_noErr(errorCode, exceptionLabel)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 0.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* execute the action statement or compound statement (block) and
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE, execute the action statement or
|
|
* compound statement (block), and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 0.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* action:
|
|
* The statement or compound statement (block).
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* If the errorCode expression does not equal 0 (noErr),
|
|
* goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 0.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* If the errorCode expression does not equal 0 (noErr),
|
|
* execute the action statement or compound statement (block) and
|
|
* goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 0.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* action:
|
|
* The statement or compound statement (block).
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE, and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 0.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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)
|
|
*
|
|
* Summary:
|
|
* Production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* execute the action statement or compound statement (block) and
|
|
* goto exceptionLabel.
|
|
*
|
|
* Non-production builds: if the errorCode expression does not equal 0 (noErr),
|
|
* call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
|
|
* statement (block), and then goto exceptionLabel.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* errorCode:
|
|
* The expression to compare to 0.
|
|
*
|
|
* exceptionLabel:
|
|
* The label.
|
|
*
|
|
* action:
|
|
* The statement or compound statement (block).
|
|
*
|
|
* message:
|
|
* The C string to display.
|
|
*/
|
|
#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
|
|
|
|
/*
|
|
* 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__ */
|