Up

Functions

Authors

Richard Frith-Macdonald

Contents -

  1. Function index
  2. Macro index
  3. NSBundle macros
  4. NSDebug macros
  5. NSException macros
  6. NSInvocation macros
  7. NSLock macros
  8. NSObject macros
  9. NSCalendarDate functions
  10. NSDebug functions
  11. NSDecimal functions
  12. NSException functions
  13. NSGeometry functions
  14. NSHashTable functions
  15. NSMapTable functions
  16. NSNotificationQueue functions
  17. NSObjCRuntime functions
  18. NSObject functions
  19. NSPathUtilities functions
  20. NSProcessInfo functions
  21. NSRange functions
  22. NSSet functions
  23. NSThread functions
  24. NSValue functions
  25. NSZone functions

Function index

Function

Macro index

Macro

NSBundle macros

GSLocalizedString

GSLocalizedString(key, comment)

Warning - the following should never be used.


NSLocalizedStaticString

NSLocalizedStaticString(key, comment)

This function (macro) is a GNUstep extensions, and it is used to localize static strings. Here is an example of a static string:

NSString *message = @"Hi there";... some code... NSLog (message);

This string can not be localized using the standard openstep functions/macros. By using this gnustep extension, you can localize it as follows:

NSString *message = NSLocalizedStaticString (@"Hi there", @"Greeting");... some code... NSLog (NSLocalizedString (message, @""));

When the tools generate the Localizable.strings file from the source code, they will ignore the NSLocalizedString call while they will extract the string (and the comment) to localize from the NSLocalizedStaticString call.

When the code is compiled, instead, the NSLocalizedStaticString call is ignored (discarded, it is a macro which simply expands to key), while the NSLocalizedString will actually look up the string for translation in the Localizable.strings file.

Please note that there is currently no macro/function to localize static strings using different tables. If you need that functionality, you have either to prepare the localization tables by hand, or to rewrite your code in such a way as not to use static strings.


NSLocalizedString

NSLocalizedString(key, comment)

This function (macro) is used to get the localized translation of the string key. key is looked up in the Localizable.strings file for the current language. The current language is determined by the available languages in which the application is translated, and by using the NSLanguages user defaults (which should contain an array of the languages preferred by the user, in order of preference).

Technically, the function works by calling localizedStringForKey:value:table: on the main bundle, using @"" as value, and nil as the table. The comment is ignored when the macro is expanded; but when we have tools which can generate the Localizable.strings files automatically from source code, the comment will be used by the tools and added as a comment before the string to translate. Upon finding something like

NSLocalizedString (@"My useful string", @"My useful comment about the string");

in the source code, the tools will generate a comment and the line

" My useful string" = "My useful string";

in the Localizable.strings file (the translator then can use this as a skeleton for the Localizable.strings for his/her own language, where she/he can replace the right hand side with the translation in her/his own language). The comment can help the translator to decide how to translate when it is not clear how to translate (because the original string is now out of context, and out of context might not be so clear what the string means). The comment is totally ignored by the library code.

If you don't have a comment (because the string is so self-explanatory that it doesn't need it), you can leave it blank, by using @"" as a comment. If the string might be unclear out of context, it is recommended that you add a comment (even if it is unused for now).


NSLocalizedStringFromTable

NSLocalizedStringFromTable(key, tbl, comment)

This function (macro) does the same as NSLocalizedString, but uses the table table rather than the default table. This means that the string to translate will be looked up in a different file than Localizable.strings. For example, if you pass DatabaseErrors as the table, the string will be looked up for translation in the file DatabaseErrors.strings. This allows you to have the same string translated in different ways, by having a different translation in different tables, and choosing between the different translation by choosing a different table.


NSLocalizedStringFromTableInBundle

NSLocalizedStringFromTableInBundle(key, tbl, bundle, comment)

This function is the full-blown localization function (it is actually a macro). It looks up the string key for translation in the table table of the bundle bundle (please refer to the NSBundle documentation for more information on how this lookup is done). comment is a comment, which is ignored by the library (it is discarded when the macro is expanded) but which can be used by tools which parse the source code and generate strings table to provide a comment which the translator can use when translating the string.


_

_(X)

This function (macro) is a GNUstep extension.

_(@"My string to translate")

is exactly the same as

NSLocalizedString (@"My string to translate", @"")

It is useful when you need to translate an application very quickly, as you just need to enclose all strings inside _() . But please note that when you use this macro, you are not taking advantage of comments for the translator, so consider using NSLocalizedString instead when you need a comment.


__

__(X)

This function (macro) is a GNUstep extension.

__(@"My string to translate")

is exactly the same as

NSLocalizedStaticString (@"My string to translate", @"")

It is useful when you need to translate an application very quickly. You would use it as follows for static strings:

NSString *message = __(@"Hello there");... more code... NSLog (_(messages));

But please note that when you use this macro, you are not taking advantage of comments for the translator, so consider using NSLocalizedStaticString instead when you need a comment.


NSDebug macros

NSDebugFLLog

NSDebugFLLog(level, format, args,...)

This macro is like NSDebugLLog() but includes the name and location of the function in which the macro is used as part of the log output.


NSDebugFLog

NSDebugFLog(format, args,...)

This macro is a shorthand for NSDebugFLLog() using then default debug level... 'dflt'


NSDebugFRLog

NSDebugFRLog(object, msg)

This macro saves the name and location of the function in which the macro is used, along with a short string msg as the tag associated with a recorded object.


NSDebugLLog

NSDebugLLog(level, format, args,...)

NSDebugLLog() is the basic debug logging macro used to display log messages using NSLog() , if debug logging was enabled at compile time and the appropriate logging level was set at runtime.

Debug logging which can be enabled/disabled by defining GSDIAGNOSE when compiling and also setting values in the mutable set which is set up by NSProcessInfo. GSDIAGNOSE is defined automatically unless diagnose=no is specified in the make arguments.

NSProcess initialises a set of strings that are the names of active debug levels using the '--GNU-Debug=...' command line argument. Each command-line argument of that form is removed from NSProcessInfos list of arguments and the variable part (...) is added to the set. This means that as far as the program proper is concerned, it is running with the same arguments as if debugging had not been enabled.

For instance, to debug the NSBundle class, run your program with '--GNU-Debug=NSBundle' You can of course supply multiple '--GNU-Debug=...' arguments to output debug information on more than one thing.

NSUserDefaults also adds debug levels from the array given by the GNU-Debug key... but these values will not take effect until the +standardUserDefaults method is called... so they are useless for debugging NSUserDefaults itsself or for debugging any code executed before the defaults system is used.

To embed debug logging in your code you use the NSDebugLLog() or NSDebugLog() macro. NSDebugLog() is just NSDebugLLog() with the debug level set to 'dflt'. So, to activate debug statements that use NSDebugLog() , you supply the '--GNU-Debug=dflt' argument to your program.

You can also change the active debug levels under your programs control - NSProcessInfo has a [-debugSet] method that returns the mutable set that contains the active debug levels - your program can modify this set.

Two debug levels have a special effect - 'dflt' is the level used for debug logs statements where no debug level is specified, and 'NoWarn' is used to *disable* warning messages.

As a convenience, there are four more logging macros you can use - NSDebugFLog() , NSDebugFLLog() , NSDebugMLog() and NSDebugMLLog() . These are the same as the other macros, but are specifically for use in either functions or methods and prepend information about the file, line and either function or class/method in which the message was generated.


NSDebugLog

NSDebugLog(format, args,...)

This macro is a shorthand for NSDebugLLog() using then default debug level... 'dflt'


NSDebugMLLog

NSDebugMLLog(level, format, args,...)

This macro is like NSDebugLLog() but includes the name and location of the method in which the macro is used as part of the log output.


NSDebugMLog

NSDebugMLog(format, args,...)

This macro is a shorthand for NSDebugMLLog() using then default debug level... 'dflt'


NSDebugMRLog

NSDebugMRLog(object, msg)

This macro saves the name and location of the method in which the macro is used, along with a short string msg as the tag associated with a recorded object.


NSWarnFLog

NSWarnFLog(format, args,...)

This macro is like NSWarnLog() but includes the name and location of the function in which the macro is used as part of the log output.


NSWarnLog

NSWarnLog(format, args,...)

NSWarnLog() is the basic debug logging macro used to display warning messages using NSLog() , if warn logging was not disabled at compile time and the disabling logging level was not set at runtime.

Warning messages which can be enabled/disabled by defining GSWARN when compiling.

You can also disable these messages at runtime by supplying a '--GNU-Debug=NoWarn' argument to the program, or by adding 'NoWarn' to the user default array named 'GNU-Debug'.

These logging macros are intended to be used when the software detects something that it not necessarily fatal or illegal, but looks like it might be a programming error. eg. attempting to remove 'nil' from an NSArray, which the Spec/documentation does not prohibit, but which a well written progam should not be attempting (since an NSArray object cannot contain a 'nil').

NB. The 'warn=yes' option is understood by the GNUstep make package to mean that GSWARN should be defined, and the 'warn=no' means that GSWARN should be undefined. Default is to define it.

To embed debug logging in your code you use the NSWarnLog() macro.

As a convenience, there are two more logging macros you can use - NSWarnLog() , and NSWarnMLog() . These are specifically for use in either functions or methods and prepend information about the file, line and either function or class/method in which the message was generated.


NSWarnMLog

NSWarnMLog(format, args,...)

This macro is like NSWarnLog() but includes the name and location of the method in which the macro is used as part of the log output.


NSException macros

NSAssert

NSAssert(condition, desc)

Used in an ObjC method body.
See NSAssertionHandler for details.
When condition is false, raise an exception using desc


NSAssert1

NSAssert1(condition, desc, arg1)

Used in an ObjC method body.
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1


NSAssert2

NSAssert2(condition, desc, arg1, arg2)

Used in an ObjC method body.
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2


NSAssert3

NSAssert3(condition, desc, arg1, arg2, arg3)

Used in an ObjC method body.
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2, arg3


NSAssert4

NSAssert4(condition, desc, arg1, arg2, arg3, arg4)

Used in an ObjC method body.
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2, arg3, arg4


NSAssert5

NSAssert5(condition, desc, arg1, arg2, arg3, arg4, arg5)

Used in an ObjC method body.
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2, arg3, arg4, arg5


NSCAssert

NSCAssert(condition, desc)

Used in plain C code (not in an ObjC method body).
See NSAssertionHandler for details.
When condition is false, raise an exception using desc


NSCAssert1

NSCAssert1(condition, desc, arg1)

Used in plain C code (not in an ObjC method body).
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1


NSCAssert2

NSCAssert2(condition, desc, arg1, arg2)

Used in plain C code (not in an ObjC method body).
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2


NSCAssert3

NSCAssert3(condition, desc, arg1, arg2, arg3)

Used in plain C code (not in an ObjC method body).
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2, arg3


NSCAssert4

NSCAssert4(condition, desc, arg1, arg2, arg3, arg4)

Used in plain C code (not in an ObjC method body).
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2, arg3, arg4


NSCAssert5

NSCAssert5(condition, desc, arg1, arg2, arg3, arg4, arg5)

Used in plain C code (not in an ObjC method body).
See NSAssertionHandler for details.
When condition is false, raise an exception using desc and arg1, arg2, arg3, arg4, arg5


NSCParameterAssert

NSCParameterAssert(condition)

Used in plain C code (not in an ObjC method body).
See NSAssertionHandler for details.
When condition is false, raise an exception saying that an invalid parameter was supplied to the method.


NSParameterAssert

NSParameterAssert(condition)

Used in an ObjC method body.
See NSAssertionHandler for details.
When condition is false, raise an exception saying that an invalid parameter was supplied to the method.


NSInvocation macros

NS_INVOCATION

NS_INVOCATION(class, message,...)

Creates and returns an autoreleased invocation containing a message to an instance of the class. The 'message' consists of selector and arguments like a standard ObjectiveC method call.
Before using the returned invocation, you need to set its target.


NS_MESSAGE

NS_MESSAGE(target, message,...)

Creates and returns an autoreleased invocation containing a message to the target object. The 'message' consists of selector and arguments like a standard ObjectiveC method call.


NSLock macros

GS_INITIALIZED_LOCK

GS_INITIALIZED_LOCK(IDENT, CLASSNAME)

Returns IDENT which will be initialized to an instance of a CLASSNAME in a thread safe manner. If IDENT has been previoulsy initilized this macro merely returns IDENT. IDENT is considered uninitialzed, if it contains nil. CLASSNAME must be either NSLock, NSRecursiveLock or one of thier subclasses. See [NSLock +newLockAt:] for details. This macro is intended for code that cannot insure that a lock can be initialized in thread safe manner otherwise.

 NSLock *my_lock = nil;

 void function (void)
 {
   [GS_INITIALIZED_LOCK(my_lock, NSLock) lock];
   do_work ();
   [my_lock unlock];
 }

 


NSObject macros

ASSIGN

ASSIGN(object, value)

ASSIGN(object,value) assigns the value to the object with appropriate retain and release operations.


ASSIGNCOPY

ASSIGNCOPY(object, value)

ASSIGNCOPY(object,value) assigns a copy of the value to the object with release of the original.


AUTORELEASE

AUTORELEASE(object)

Basic autorelease operation... calls [NSObject -autorelease]


CREATE_AUTORELEASE_POOL

CREATE_AUTORELEASE_POOL(X)

Declares an autorelease pool variable and creates and initialises an autorelease pool object.


DESTROY

DESTROY(object)

DESTROY() is a release operation which also sets the variable to be a nil pointer for tidyness - we can't accidentally use a DESTROYED object later. It also makes sure to set the variable to nil before releasing the object - to avoid side-effects of the release trying to reference the object being released through the variable.


RECREATE_AUTORELEASE_POOL

RECREATE_AUTORELEASE_POOL(X)

Similar, but allows reuse of variables. Be sure to use DESTROY() so the object variable stays nil.


RELEASE

RELEASE(object)

Basic release operation... calls [NSObject -release]


RETAIN

RETAIN(object)

Basic retain operation... calls [NSObject -retain]


TEST_AUTORELEASE

TEST_AUTORELEASE(object)

Tested autorelease - only invoke the objective-c method if the receiver is not nil.


TEST_RELEASE

TEST_RELEASE(object)

Tested release - only invoke the objective-c method if the receiver is not nil.


TEST_RETAIN

TEST_RETAIN(object)

Tested retain - only invoke the objective-c method if the receiver is not nil.


NSCalendarDate functions

GSBreakTime

void GSBreakTime(NSTimeInterval when, int* year, int* month, int* day, int* hour, int* minute, int* second, int* mil);

Convert a time interval since the reference date into broken out elements.
External - so NSDate and others can use it.


GSTime

NSTimeInterval GSTime(int day, int month, int year, int hour, int minute, int second, int mil);

Convert a broken out time specification into a time interval since the reference date.
External - so NSDate and others can use it.


NSDebug functions

GSDebugAllocationActive

BOOL GSDebugAllocationActive(BOOL active);

Activates or deactivates object allocation debugging. Returns previous state.
This function activates or deactivates object allocation debugging.
Returns the previous state.
You should call this function to activate allocation debugging before using any of the other allocation debugging functions such as GSDebugAllocationList() or GSDebugAllocationTotal() .
Object allocation debugging should not affect performance too much, and is very useful as it allows you to monitor how many objects of each class your application has allocated.


GSDebugAllocationActiveRecordingObjects

void GSDebugAllocationActiveRecordingObjects(Class c);

Starts recording all allocated objects of a certain class.
Use with extreme care... this could slow down your application enormously.
This function activates tracking all allocated instances of the specified class c.
This tracking can slow your application down, so you should use it only when you are into serious debugging. Usually, you will monitor your application by using the functions GSDebugAllocationList() and similar, which do not slow things down much and return the number of allocated instances; when (if) by studying the reports generated by these functions you have found a leak of objects of a certain class, and if you can't figure out how to fix it by looking at the code, you can use this function to start tracking allocated instances of that class, and the following one can sometime allow you to list the leaked objects directly.


GSDebugAllocationAdd

void GSDebugAllocationAdd(Class c, id o);

Used internally by NSAllocateObject() ... you probably don't need this.


GSDebugAllocationClassList

Class* GSDebugAllocationClassList();

Returns a NULL terminated array listing all the classes for which statistical information has been collected.
This function returns a NULL terminated array listing all the classes for which statistical information has been collected. Usually, you call this function, and then loop on all the classes returned, and for each one you get current, peak and total count by using GSDebugAllocationCount() , GSDebugAllocationPeak() and GSDebugAllocationTotal() .


GSDebugAllocationCount

int GSDebugAllocationCount(Class c);

Returns the number of instances of the specified class which are currently allocated.

Returns the number of instances of the specified class which are currently allocated. This number is very important to detect memory leaks. If you notice that this number is constantly increasing without apparent reason, it is very likely a memory leak - you need to check that you are correctly releasing objects of this class, otherwise when your application runs for a long time, it will eventually allocate so many objects as to eat up all your system's memory...

This function, like the ones below, returns the number of objects allocated/released from the time when GSDebugAllocationActive() was first called. A negative number means that in total, there are less objects of this class allocated now than there were when you called GSDebugAllocationActive() ; a positive one means there are more.


GSDebugAllocationList

const char* GSDebugAllocationList(BOOL changeFlag);

Returns a newline separated list of the classes which have instances allocated, and the instance counts. If 'changeFlag' is YES then the list gives the number of instances allocated/deallocated since the function was last called.
This function returns a newline separated list of the classes which have instances allocated, and the instance counts. If the 'changeFlag' argument is YES then the list gives the number of instances allocated/deallocated since the function was last called. This function only returns the current count of instances (not the peak or total count), but its output is ready to be displayed or logged.


GSDebugAllocationListAll

const char* GSDebugAllocationListAll();

Returns a newline separated list of the classes which have had instances allocated at any point, and the total count of the number of instances allocated for each class.
This function returns a newline separated list of the classes which have had instances allocated at any point, and the total count of the number of instances allocated for each class. The difference with GSDebugAllocationList() is that this function returns also classes which have no objects allocated at the moment, but which had in the past.


GSDebugAllocationListRecordedObjects

NSArray* GSDebugAllocationListRecordedObjects(Class c);

Returns an array containing all the allocated objects of a certain class which have been recorded. Presumably, you will immediately call [NSObject -description] on them to find out the objects you are leaking. Warning - the objects are put in an array, so until the array is autoreleased, the objects are not released.
This function returns an array containing all the allocated objects of a certain class which have been recorded... to start the recording, you need to invoke GSDebugAllocationActiveRecordingObjects() . Presumably, you will immediately call [NSObject -description] on them to find out the objects you are leaking. The objects are returned in an array, so until the array is autoreleased, the objects are not released.


GSDebugAllocationPeak

int GSDebugAllocationPeak(Class c);

Returns the peak number of instances of the specified class which have been concurrently allocated.
Returns the peak number of instances of the specified class which have been concurrently allocated. If this number is very high, it means at some point in time you had a situation with a huge number of objects of this class allocated - this is an indicator that probably at some point in time your application was using a lot of memory - so you might want to investigate whether you can prevent this problem by inserting autorelease pools in your application's processing loops.


GSDebugAllocationRemove

void GSDebugAllocationRemove(Class c, id o);

Used internally by NSDeallocateObject() ... you probably don't need this.


GSDebugAllocationTagRecordedObject

id GSDebugAllocationTagRecordedObject(id object, id tag);

This function associates the supplied tag with a recorded object and returns the tag which was previously associated with it (if any).
If the object was not recorded, the method returns nil
The tag is retained while it is associated with the object.
See also the NSDebugFRLog() and NSDebugMRLog() macros.
This function associates the supplied tag with a recorded object and returns the tag which was previously associated with it (if any).
If the object was not recorded, the method returns nil
The tag is retained while it is associated with the object.


GSDebugAllocationTotal

int GSDebugAllocationTotal(Class c);

Returns the total number of instances of the specified class which have been allocated.
Returns the total number of instances of the specified class c which have been allocated - basically the number of times you have allocated an object of this class. If this number is very high, it means you are creating a lot of objects of this class; even if you are releasing them correctly, you must not forget that allocating and deallocating objects is usually one of the slowest things you can do, so you might want to consider whether you can reduce the number of allocations and deallocations that you are doing - for example, by recycling objects of this class, uniquing them, and/or using some sort of flyweight pattern. It might also be possible that you are unnecessarily creating too many objects of this class. Well - of course some times there is nothing you can do about it.


GSDebugFunctionMsg

NSString* GSDebugFunctionMsg(const char* func, const char* file, int line, NSString* fmt);

Used to produce a format string for logging a message with function location details.


GSDebugMethodMsg

NSString* GSDebugMethodMsg(id obj, SEL sel, const char* file, int line, NSString* fmt);

Used to produce a format string for logging a message with method location details.


GSSetDebugAllocationFunctions

void GSSetDebugAllocationFunctions(void(*) newAddObjectFunc, void(*) newRemoveObjectFunc);

This functions allows to set own function backcalls for debugging allocation of objects. Useful if you intend to write your own objectalloc.


NSCountFrames

unsigned int NSCountFrames();

Description forthcoming.


NSFrameAddress

void* NSFrameAddress(int offset);

Description forthcoming.


NSReturnAddress

void* NSReturnAddress(int offset);

Description forthcoming.


NSDecimal functions

NSDecimalAdd

NSCalculationError NSDecimalAdd(NSDecimal* result, const NSDecimal* left, const NSDecimal* right, NSRoundingMode mode);

Description forthcoming.


NSDecimalCompact

void NSDecimalCompact(NSDecimal* number);

Description forthcoming.


NSDecimalCompare

NSComparisonResult NSDecimalCompare(const NSDecimal* leftOperand, const NSDecimal* rightOperand);

Description forthcoming.


NSDecimalCopy

void NSDecimalCopy(NSDecimal* destination, const NSDecimal* source);

Description forthcoming.


NSDecimalDivide

NSCalculationError NSDecimalDivide(NSDecimal* result, const NSDecimal* l, const NSDecimal* rr, NSRoundingMode mode);

Description forthcoming.


NSDecimalDouble

double NSDecimalDouble(NSDecimal* number);

Description forthcoming.


NSDecimalFromComponents

void NSDecimalFromComponents(NSDecimal* result, unsigned long long int mantissa, short int exponent, BOOL negative);

Description forthcoming.


NSDecimalFromString

void NSDecimalFromString(NSDecimal* result, NSString* numberValue, NSDictionary* locale);

Description forthcoming.


NSDecimalIsNotANumber

BOOL NSDecimalIsNotANumber(const NSDecimal* decimal);

Description forthcoming.


NSDecimalMax

void NSDecimalMax(NSDecimal* result);

Description forthcoming.


NSDecimalMin

void NSDecimalMin(NSDecimal* result);

Description forthcoming.


NSDecimalMultiply

NSCalculationError NSDecimalMultiply(NSDecimal* result, const NSDecimal* l, const NSDecimal* r, NSRoundingMode mode);

Description forthcoming.


NSDecimalMultiplyByPowerOf10

NSCalculationError NSDecimalMultiplyByPowerOf10(NSDecimal* result, const NSDecimal* n, short int power, NSRoundingMode mode);

Description forthcoming.


NSDecimalNormalize

NSCalculationError NSDecimalNormalize(NSDecimal* n1, NSDecimal* n2, NSRoundingMode mode);

Description forthcoming.


NSDecimalPower

NSCalculationError NSDecimalPower(NSDecimal* result, const NSDecimal* n, unsigned int power, NSRoundingMode mode);

Description forthcoming.


NSDecimalRound

void NSDecimalRound(NSDecimal* result, const NSDecimal* number, int scale, NSRoundingMode mode);

Description forthcoming.


NSDecimalString

NSString* NSDecimalString(const NSDecimal* decimal, NSDictionary* locale);

Description forthcoming.


NSDecimalSubtract

NSCalculationError NSDecimalSubtract(NSDecimal* result, const NSDecimal* left, const NSDecimal* right, NSRoundingMode mode);

Description forthcoming.


NSException functions

NSUncaughtExceptionHandler

void NSUncaughtExceptionHandler(NSException* exception);

Description forthcoming.


_NSAddHandler

void _NSAddHandler(NSHandler* handler);

Description forthcoming.


_NSRemoveHandler

void _NSRemoveHandler(NSHandler* handler);

Description forthcoming.


NSGeometry functions

NSContainsRect

BOOL NSContainsRect(NSRect aRect, NSRect bRect);

Description forthcoming.


NSDivideRect

void NSDivideRect(NSRect aRect, NSRect* slice, NSRect* remainder, float amount, NSRectEdge edge);

Description forthcoming.


NSEqualPoints

BOOL NSEqualPoints(NSPoint aPoint, NSPoint bPoint);

Description forthcoming.


NSEqualRects

BOOL NSEqualRects(NSRect aRect, NSRect bRect);

Description forthcoming.


NSEqualSizes

BOOL NSEqualSizes(NSSize aSize, NSSize bSize);

Description forthcoming.


NSHeight

float NSHeight(NSRect aRect);

Description forthcoming.


NSInsetRect

NSRect NSInsetRect(NSRect aRect, float dX, float dY);

Description forthcoming.


NSIntegralRect

NSRect NSIntegralRect(NSRect aRect);

Description forthcoming.


NSIntersectionRect

NSRect NSIntersectionRect(NSRect aRect, NSRect bRect);

Description forthcoming.


NSIntersectsRect

BOOL NSIntersectsRect(NSRect aRect, NSRect bRect);

Description forthcoming.


NSIsEmptyRect

BOOL NSIsEmptyRect(NSRect aRect);

Description forthcoming.


NSMakePoint

NSPoint NSMakePoint(float x, float y);

Description forthcoming.


NSMakeRect

NSRect NSMakeRect(float x, float y, float w, float h);

Description forthcoming.


NSMakeSize

NSSize NSMakeSize(float w, float h);

Description forthcoming.


NSMaxX

float NSMaxX(NSRect aRect);

Description forthcoming.


NSMaxY

float NSMaxY(NSRect aRect);

Description forthcoming.


NSMidX

float NSMidX(NSRect aRect);

Description forthcoming.


NSMidY

float NSMidY(NSRect aRect);

Description forthcoming.


NSMinX

float NSMinX(NSRect aRect);

Description forthcoming.


NSMinY

float NSMinY(NSRect aRect);

Description forthcoming.


NSMouseInRect

BOOL NSMouseInRect(NSPoint aPoint, NSRect aRect, BOOL flipped);

Description forthcoming.


NSOffsetRect

NSRect NSOffsetRect(NSRect aRect, float dx, float dy);

Description forthcoming.


NSPointFromString

NSPoint NSPointFromString(NSString* string);

Description forthcoming.


NSPointInRect

BOOL NSPointInRect(NSPoint aPoint, NSRect aRect);

Description forthcoming.


NSRectFromString

NSRect NSRectFromString(NSString* string);

Description forthcoming.


NSSizeFromString

NSSize NSSizeFromString(NSString* string);

Description forthcoming.


NSStringFromPoint

NSString* NSStringFromPoint(NSPoint aPoint);

Get a String Representation...


NSStringFromRect

NSString* NSStringFromRect(NSRect aRect);

Description forthcoming.


NSStringFromSize

NSString* NSStringFromSize(NSSize aSize);

Description forthcoming.


NSUnionRect

NSRect NSUnionRect(NSRect aRect, NSRect bRect);

Description forthcoming.


NSWidth

float NSWidth(NSRect aRect);

Description forthcoming.


NSHashTable functions

NSAllHashTableObjects

NSArray* NSAllHashTableObjects(NSHashTable* table);

Returns an array of all the objects in the table. NB. The table must contain objects, not pointers or integers.


NSCompareHashTables

BOOL NSCompareHashTables(NSHashTable* table1, NSHashTable* table2);

Compares the two hash tables for equality. If the tables are different sizes, returns NO. Otherwise, compares the values in the two tables and returns NO if they differ.
The GNUstep implementation enumerates the values in table1 and uses the hash and isEqual functions of table2 for comparison.


NSCopyHashTableWithZone

NSHashTable* NSCopyHashTableWithZone(NSHashTable* table, NSZone* zone);

Copy the supplied map table creating the new table in the specified zone.


NSCountHashTable

unsigned int NSCountHashTable(NSHashTable* table);

Returns the number of objects in the table .


NSCreateHashTable

NSHashTable* NSCreateHashTable(NSHashTableCallBacks callBacks, unsigned int capacity);

Create a new hash table by calling NSCreateHashTableWithZone() using NSDefaultMallocZone() .
If capacity is small or 0, then the returned table has a reasonable (but still small) capacity.


NSCreateHashTableWithZone

NSHashTable* NSCreateHashTableWithZone(NSHashTableCallBacks callBacks, unsigned int capacity, NSZone* zone);

Create a new hash table using the supplied callbacks structure. If any functions in the callback structure is null the default values are used... as for non-owned pointers. The table will be created with the specified capacity... ie ready to hold at lest that many items.


NSEndHashTableEnumeration

void NSEndHashTableEnumeration(NSHashEnumerator* enumerator);

Function to be called when finished with the enumerator. This permits memory used by the enumerator to be released.


NSEnumerateHashTable

NSHashEnumerator NSEnumerateHashTable(NSHashTable* table);

Return an enumerator for stepping through a map table using the NSNextHashEnumeratorItem() function.


NSFreeHashTable

void NSFreeHashTable(NSHashTable* table);

Releases all the keys and values of table (using the callbacks specified at the time of table's creation), and then proceeds to deallocate the space allocated for table itself.


NSHashGet

void* NSHashGet(NSHashTable* table, const void* element);

Returns the value for the specified element, or a null pointer if the element is not found in the table .


NSHashInsert

void NSHashInsert(NSHashTable* table, const void* element);

Adds the element to table.
If an equal element is already in table, replaces it with the new one.
If element is null raises an NSInvalidArgumentException.


NSHashInsertIfAbsent

void* NSHashInsertIfAbsent(NSHashTable* table, const void* element);

Adds the element to table and returns nul.
If an equal element is already in table, returns the old element instead of adding the new one.
If element is nul, raises an NSInvalidArgumentException.


NSHashInsertKnownAbsent

void NSHashInsertKnownAbsent(NSHashTable* table, const void* element);

Adds the element to table and returns nul.
If an equal element is already present, raises NSInvalidArgumentException.
If element is null raises an NSInvalidArgumentException.


NSHashRemove

void NSHashRemove(NSHashTable* table, const void* element);

Remove the specified element from the table.


NSNextHashEnumeratorItem

void* NSNextHashEnumeratorItem(NSHashEnumerator* enumerator);

Step through the hash table... return the next item or return nulif we hit the of the table.


NSResetHashTable

void NSResetHashTable(NSHashTable* table);

Empty the hash table (releasing all elements), but preserve its capacity.


NSStringFromHashTable

NSString* NSStringFromHashTable(NSHashTable* table);

Returns a string describing the table contents.
For each item, a string of the form "value;\n" is appended. The appropriate describe function is used to generate the strings for each item.


NSMapTable functions

NSAllMapTableKeys

NSArray* NSAllMapTableKeys(NSMapTable* table);

Returns an array of all the keys in the table. NB. The table must contain objects for its keys.


NSAllMapTableValues

NSArray* NSAllMapTableValues(NSMapTable* table);

Returns an array of all the values in the table. NB. The table must contain objects for its values.


NSCompareMapTables

BOOL NSCompareMapTables(NSMapTable* table1, NSMapTable* table2);

Compares the two map tables for equality. If the tables are different sizes, returns NO. Otherwise, compares the keys (not the values) in the two map tables and returns NO if they differ.
The GNUstep implementation enumerates the keys in table1 and uses the hash and isEqual functions of table2 for comparison.


NSCopyMapTableWithZone

NSMapTable* NSCopyMapTableWithZone(NSMapTable* table, NSZone* zone);

Copy the supplied map table.
Returns a map table, space for which is allocated in zone, which has (newly retained) copies of table's keys and values. As always, if zone is 0, then NSDefaultMallocZone() is used.


NSCountMapTable

unsigned int NSCountMapTable(NSMapTable* table);

Returns the number of key/value pairs in the table.


NSCreateMapTable

NSMapTable* NSCreateMapTable(NSMapTableKeyCallBacks keyCallBacks, NSMapTableValueCallBacks valueCallBacks, unsigned int capacity);

Create a new map table by calling NSCreateMapTableWithZone() using NSDefaultMallocZone() .
Returns a (pointer to) an NSMapTable space for which is allocated in the default zone. If capacity is small or 0, then the returned table has a reasonable capacity.


NSCreateMapTableWithZone

NSMapTable* NSCreateMapTableWithZone(NSMapTableKeyCallBacks keyCallBacks, NSMapTableValueCallBacks valueCallBacks, unsigned int capacity, NSZone* zone);

Create a new map table using the supplied callbacks structures. If any functions in the callback structures are null the default values are used... as for non-owned pointers.
Of course, if you send 0 for zone, then the map table will be created in NSDefaultMallocZone() .
The table will be created with the specified capacity... ie ready to hold at least that many items.


NSEndMapTableEnumeration

void NSEndMapTableEnumeration(NSMapEnumerator* enumerator);

Function to be called when finished with the enumerator. This permits memory used by the enumerator to be released!


NSEnumerateMapTable

NSMapEnumerator NSEnumerateMapTable(NSMapTable* table);

Return an enumerator for stepping through a map table using the NSNextMapEnumeratorPair() function.


NSFreeMapTable

void NSFreeMapTable(NSMapTable* table);

Destroy the map table and relase its contents.
Releases all the keys and values of table (using the key and value callbacks specified at the time of table's creation), and then proceeds to deallocate the space allocated for table itself.


NSMapGet

void* NSMapGet(NSMapTable* table, const void* key);

Returns the value for the specified key, or a null pointer if the key is not found in the table.


NSMapInsert

void NSMapInsert(NSMapTable* table, const void* key, const void* value);

Adds the key and value to table.
If an equal key is already in table, replaces its mapped value with the new one, without changing the key itsself.
If key is equal to the notAKeyMarker field of the table's NSMapTableKeyCallBacks, raises an NSInvalidArgumentException.


NSMapInsertIfAbsent

void* NSMapInsertIfAbsent(NSMapTable* table, const void* key, const void* value);

Adds the key and value to table and returns nul.
If an equal key is already in table, returns the old key instead of adding the new key-value pair.
If key is equal to the notAKeyMarker field of the table's NSMapTableKeyCallBacks, raises an NSInvalidArgumentException.


NSMapInsertKnownAbsent

void NSMapInsertKnownAbsent(NSMapTable* table, const void* key, const void* value);

Adds the key and value to table and returns nul.
If an equal key is already in table, raises an NSInvalidArgumentException.
If key is equal to the notAKeyMarker field of the table's NSMapTableKeyCallBacks, raises an NSInvalidArgumentException.


NSMapMember

BOOL NSMapMember(NSMapTable* table, const void* key, void** originalKey, void** value);

Returns a flag to say whether the table contains the specified key. Returns the original key and the value it maps to.
The GNUstep implementation checks originalKey and value to see if they are null pointers, and only updates them if non-null.


NSMapRemove

void NSMapRemove(NSMapTable* table, const void* key);

Remove the specified key from the table (if present).
Causes the key and its associated value to be released.


NSNextMapEnumeratorPair

BOOL NSNextMapEnumeratorPair(NSMapEnumerator* enumerator, void** key, void** value);

Step through the map table... return the next key-value pair and return YES, or hit the end of the table and return NO.
The enumerator parameter is a value supplied by NSEnumerateMapTable() and must be destroyed using NSEndMapTableEnumeration() .
The GNUstep implementation permits either key or value to be a null pointer, and refrains from attempting to return the appropriate result in that case.


NSResetMapTable

void NSResetMapTable(NSMapTable* table);

Empty the map table (releasing every key and value), but preserve its capacity.


NSStringFromMapTable

NSString* NSStringFromMapTable(NSMapTable* table);

Returns a string describing the table contents.
For each key-value pair, a string of the form "key = value;\n" is appended. The appropriate describe functions are used to generate the strings for each key and value.


NSNotificationQueue functions

GSNotifyASAP

void GSNotifyASAP();

Description forthcoming.


GSNotifyIdle

void GSNotifyIdle();

Description forthcoming.


GSNotifyMore

BOOL GSNotifyMore();

Description forthcoming.


NSObjCRuntime functions

GSLogLock

NSRecursiveLock* GSLogLock();

Returns the lock used to protect the GNUstep NSLogv() implementation. Use this to protect changes to _NSLogDescriptor and _NSLog_printf_handler


NSClassFromString

Class NSClassFromString(NSString* aClassName);

Returns the class whose name is supplied in the aClassName argument, or 0 if a nil string is supplied.


NSGetSizeAndAlignment

const char* NSGetSizeAndAlignment(const char* typePtr, unsigned int* sizep, unsigned int* alignp);

When provided with a C string containing encoded type information, this method extracts size and alignment information for the specified type into the buffers pointed to by sizep and alignp.
If either sizep or alignp is a nil pointer, the corresponding data is not extracted.
The function returns a pointer to the type information C string.


NSLog

void NSLog(NSString* format,...);

Provides the standard OpenStep logging facility. For details see the lower level NSLogv() function (which this function uses).

GNUstep provides powerful alternatives for logging ... see NSDebugLog() , NSWarnLog() and GSPrintf() for example. We recommend the use of NSDebugLog() and its relatives for debug purposes, and GSPrintf() for general log messages, with NSLog() being reserved for reporting possible/likely errors. GSPrintf() is declared in GSObjCRuntime.h.


NSLog_printf_handler

void NSLog_printf_handler(NSString* message);

Description forthcoming.


NSLogv

void NSLogv(NSString* format, va_list args);

The core logging function...

The function generates a standard log entry by prepending process ID and date/time information to your message, and ensuring that a newline is present at the end of the message.

The resulting message is then passed to a handler function to perform actual output. Locking is performed around the call to the function actually writing the message out, to ensure that logging is thread-safe. However, the actual creation of the message written is only as safe as the [NSObject -description] methods of the arguments you supply.

The function to write the data is pointed to by _NSLog_printf_handler


NSSelectorFromString

SEL NSSelectorFromString(NSString* aSelectorName);

Returns a selector for the method whose name is supplied in the aSelectorName argument, or 0 if a nil string is supplied.


NSStringFromClass

NSString* NSStringFromClass(Class aClass);

Returns an NSString object containing the class name for aClass. If aClass is 0, returns nil.


NSStringFromSelector

NSString* NSStringFromSelector(SEL aSelector);

Returns a string object containing the method name for aSelector. If aSelector is 0, returns nil.


NSObject functions

NSAllocateObject

NSObject* NSAllocateObject(Class aClass, unsigned int extraBytes, NSZone* zone);

Used to allocate memory to hold an object, and initialise the class of the object to be aClass etc. The allocated memory will be extraBytes larger than the space actually needed to hold the instance variables of the object.
This function is used by the [NSObject +allocWithZone:] mnethod.


NSCopyObject

NSObject* NSCopyObject(NSObject* anObject, unsigned int extraBytes, NSZone* zone);

Used to copy anObject. This makes a bitwise copy of anObject to memory allocated from zone. The allocated memory will be extraBytes longer than that necessary to actually store the instance variables of the copied object.
This is used by the NSObject implementation of the [<NSCopying>-copyWithZone:] method.


NSDeallocateObject

void NSDeallocateObject(NSObject* anObject);

Used to release the memory used by an object.
This function is used by the [NSObject -dealloc] mnethod.


NSDecrementExtraRefCountWasZero

BOOL NSDecrementExtraRefCountWasZero(id anObject);

Examines the extra reference count for the object and, if non-zero decrements it, otherwise leaves it unchanged.
Returns a flag to say whether the count was zero (and hence whether the extra refrence count was decremented).
This function is used by the [NSObject -release] method.


NSExtraRefCount

unsigned int NSExtraRefCount(id anObject);

Return the extra reference count of anObject (a value in the range from 0 to the maximum unsigned integer value minus one).
The retain count for an object is this value plus one.


NSIncrementExtraRefCount

void NSIncrementExtraRefCount(id anObject);

Increments the extra reference count for anObject.
The GNUstep version raises an exception if the reference count would be incremented to too large a value.
This is used by the [NSObject -retain] method.


NSShouldRetainWithZone

BOOL NSShouldRetainWithZone(NSObject* anObject, NSZone* requestedZone);

Returns a flag to indicate whether anObject should be retained or copied in order to make a copy in the specified zone.
Basically, this tests to see if anObject was allocated from requestedZone and returns YES if it was.


NSPathUtilities functions

GSDefaultsRootForUser

NSString* GSDefaultsRootForUser(NSString* userName);

Return the path of the defaults directory for name.
This examines the.GNUsteprc file in the home directory of the user for the GNUSTEP_DEFAULTS_ROOT or the GNUSTEP_USER_ROOT directory definitions.


GSSetUserName

void GSSetUserName(NSString* name);

This extension permits a change of username from that specified in the LOGNAME environment variable. Using it will almost certainly cause trouble if the process does not posess the file access priviliges of the new name. This is provided primarily for use by processes that run as system-manager and need to act as particular users. If uses the [NSUserDefaults +resetUserDefaults] extension to reset the defaults system to use the defaults belonging to the new user.
Sets the user name for this process. This method is supplied to enable setuid programs to run properly as the user indicated by their effective user Id.
This function calls [NSUserDefaults +resetStandardUserDefaults] as well as changing the value returned by NSUserName() and modifying the user root directory for the process.


GSStandardPathPrefixes

NSArray* GSStandardPathPrefixes();

Returns an array of strings which contain paths that should be in the standard search order for resources, etc. If the environment variable GNUSTEP_PATHPREFIX_LIST is set. It returns the list of paths set in that variable. Otherwise, it returns the user, local, network, and system paths, in that order. This function is guarenteed to return a non-nil answer (unless something is seriously wrong, in which case the application will probably crash anyway)


GSSystemRootDirectory

NSString* GSSystemRootDirectory();

Returns a string containing the path to the GNUstep system installation directory. This function is guarenteed to return a non-nil answer (unless something is seriously wrong, in which case the application will probably crash anyway)


NSFullUserName

NSString* NSFullUserName();

Returns the full username of the current user. If unable to determine this, returns the standard user name.


NSHomeDirectory

NSString* NSHomeDirectory();

Return the caller's home directory as an NSString object. Calls NSHomeDirectoryForUser() to do this.


NSHomeDirectoryForUser

NSString* NSHomeDirectoryForUser(NSString* loginName);

Returns loginName's home directory as an NSString object.


NSOpenStepRootDirectory

NSString* NSOpenStepRootDirectory();

Returns the root directory for the OpenStep (GNUstep) installation. This si determined by the GNUSTEP_ROOT environment variable if available.


NSSearchPathForDirectoriesInDomains

NSArray* NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory directoryKey, NSSearchPathDomainMask domainMask, BOOL expandTilde);

Returns an array of search paths to look at for resources.


NSStandardApplicationPaths

NSArray* NSStandardApplicationPaths();

Returns the standard paths in which applications are stored and should be searched for. Calls NSSearchPathForDirectoriesInDomains()


NSStandardLibraryPaths

NSArray* NSStandardLibraryPaths();

Returns the standard paths in which libraries are stored and should be searched for. Calls NSSearchPathForDirectoriesInDomains()


NSTemporaryDirectory

NSString* NSTemporaryDirectory();

Returns the name of a directory in which temporary files can be stored. Under GNUstep this is a location which is not readable by other users.


NSUserName

NSString* NSUserName();

Return the caller's login name as an NSString object.
Under ms-windows, the 'LOGNAME' environment variable is used as the user name.
Under unix-like systems, the name associated with the current effective user ID is used.


NSProcessInfo functions

GSDebugSet

BOOL GSDebugSet(NSString* level);

Function for rapid testing to see if a debug level is set.
This is used by the debugging macros.
If debug logging has been turned off, this returns NO even if the specified level exists in the set of debug levels.


NSRange functions

NSEqualRanges

BOOL NSEqualRanges(NSRange range1, NSRange range2);

Description forthcoming.


NSIntersectionRange

NSRange NSIntersectionRange(NSRange aRange, NSRange bRange);

Description forthcoming.


NSLocationInRange

BOOL NSLocationInRange(unsigned int location, NSRange range);

Description forthcoming.


NSMakeRange

NSRange NSMakeRange(unsigned int location, unsigned int length);

Description forthcoming.


NSMaxRange

unsigned int NSMaxRange(NSRange range);

Description forthcoming.


NSRangeFromString

NSRange NSRangeFromString(NSString* aString);

Description forthcoming.


NSStringFromRange

NSString* NSStringFromRange(NSRange range);

Description forthcoming.


NSUnionRange

NSRange NSUnionRange(NSRange aRange, NSRange bRange);

Description forthcoming.


_NSRangeExceptionRaise

void _NSRangeExceptionRaise();

Description forthcoming.


NSSet functions

GSUPurge

void GSUPurge(unsigned int count);

This function purges the global NSCountedSet object used for uniquing. It handles locking as necessary. It can be used to purge the set even when uniquing is turned off.


GSUSet

id GSUSet(id anObject, unsigned int count);

This function sets the count for the specified object. If the count for the object is set to zero then the object is removed from the global uniquing set. The object is added to the set if necessary. The object returned is the one stored in the set. The function handles locking as necessary. It can be used to alter the set even when uniquing is turned off.


GSUnique

id GSUnique(id anObject);

This function uniques the supplied argument, returning the result. It works by using the [-unique:] method of a global NSCountedSet object. It handles locking as necessary. If uniquing is turned off, it simply returns its argument.


GSUniquing

void GSUniquing(BOOL flag);

This function sets the state of a flag that determines the behavior of the GSUnique() function. If the flag is on, uniquing is performed, if it is off the function has no effect. The default is for uniquing to be turned off.


NSThread functions

GSCurrentThread

NSThread* GSCurrentThread();

This function is a GNUstep extension. It pretty much duplicates the functionality of [NSThread +currentThread] but is more efficient and is used internally throughout GNUstep.

Returns the current thread. Could perhaps return nil if executing a thread that was started outside the GNUstep environment and not registered (this should not happen in a well-coded application).


GSCurrentThreadDictionary

NSMutableDictionary* GSCurrentThreadDictionary();

Fast access function for thread dictionary of current thread.


GSRegisterCurrentThread

BOOL GSRegisterCurrentThread();

This function is provided to let threads started by some other software library register themselves to be used with the GNUstep system. All such threads should call this function before attempting to use any GNUstep objects.

Returns YES if the thread can be registered, NO if it is already registered.

Sends out a NSWillBecomeMultiThreadedNotification if the process was not already multithreaded.


GSUnregisterCurrentThread

void GSUnregisterCurrentThread();

This function is provided to let threads started by some other software library unregister themselves from the GNUstep threading system.

Calling this function causes a NSThreadWillExitNotification to be sent out, and destroys the GNUstep NSThread object associated with the thread.


NSValue functions

GSNumberInfoFromObject

GSNumberInfo* GSNumberInfoFromObject(NSNumber* o);

Description forthcoming.


GSSmallHash

unsigned int GSSmallHash(int n);

Description forthcoming.


NSZone functions

GSAtomicMallocZone

NSZone* GSAtomicMallocZone();

Description forthcoming.


GSOutOfMemory

void* GSOutOfMemory(size_t size, BOOL retry);

Description forthcoming.


NSAllocateMemoryPages

void* NSAllocateMemoryPages(unsigned int bytes);

Allocate memory for this process and return a pointer to it (or a nul pointer on failure).


NSCopyMemoryPages

void NSCopyMemoryPages(const void* src, void* dest, unsigned int bytes);

Perform an efficient large scale copy of data from src to dest. The value bytes specifies the length of the data copied.


NSCreateZone

NSZone* NSCreateZone(size_t start, size_t gran, BOOL canFree);

Description forthcoming.


NSDeallocateMemoryPages

void NSDeallocateMemoryPages(void* ptr, unsigned int bytes);

Deallocate memory which was previously allocated using the NSAllocateMemoryPages() function.


NSDefaultMallocZone

NSZone* NSDefaultMallocZone();

Description forthcoming.


NSLogPageSize

unsigned int NSLogPageSize();

Return log base 2 of the number of bytes in a memory page.


NSPageSize

unsigned int NSPageSize();

Return the number of bytes in a memory page.


NSRealMemoryAvailable

unsigned int NSRealMemoryAvailable();

Return the number of bytes of real (physical) memory available.


NSRecycleZone

void NSRecycleZone(NSZone* zone);

Description forthcoming.


NSRoundDownToMultipleOfPageSize

unsigned int NSRoundDownToMultipleOfPageSize(unsigned int bytes);

Round bytes down to the nearest multiple of the memory page size, and return it.


NSRoundUpToMultipleOfPageSize

unsigned int NSRoundUpToMultipleOfPageSize(unsigned int bytes);

Round bytes up to the nearest multiple of the memory page size, and return it.


NSSetZoneName

void NSSetZoneName(NSZone* zone, NSString* name);

Description forthcoming.


NSZoneCalloc

void* NSZoneCalloc(NSZone* zone, size_t elems, size_t bytes);

Description forthcoming.


NSZoneCheck

BOOL NSZoneCheck(NSZone* zone);

Description forthcoming.


NSZoneFree

void NSZoneFree(NSZone* zone, void* ptr);

Description forthcoming.


NSZoneFromPointer

NSZone* NSZoneFromPointer(void* ptr);

Description forthcoming.


NSZoneMalloc

void* NSZoneMalloc(NSZone* zone, size_t size);

Description forthcoming.


NSZoneMallocAtomic

void* NSZoneMallocAtomic(NSZone* zone, size_t size);

Description forthcoming.


NSZoneName

NSString* NSZoneName(NSZone* zone);

Description forthcoming.


NSZoneRealloc

void* NSZoneRealloc(NSZone* zone, void* ptr, size_t size);

Description forthcoming.


NSZoneStats

struct NSZoneStats NSZoneStats(NSZone* zone);

Description forthcoming.



Up