Up

Functions

Authors

Richard Frith-Macdonald

Copyright: (C) 2005 Free Software Foundation, Inc.


Contents -

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

Function index

Function

Macro index

Macro

NSBundle macros

NSLocalizedString

NSLocalizedString(key, comment)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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.

NSDecimal macros

NSDecimalMaxSize

NSDecimalMaxSize
Availability: MacOS-X 10.0.0

Give a precision of at least 38 decimal digits requires 128 bits.

NSException macros

NSAssert

NSAssert(condition, desc)
Availability: OpenStep

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

NSAssert1

NSAssert1(condition, desc, arg1)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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)
Availability: OpenStep

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(aClass, message,...)
Availability: OpenStep

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,...)
Availability: OpenStep

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.

NSDebug functions

GSDebugAllocationActive

BOOL GSDebugAllocationActive(BOOL active);
Availability: OpenStep

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);
Availability: OpenStep

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);
Availability: OpenStep

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

GSDebugAllocationClassList

Class* GSDebugAllocationClassList();
Availability: OpenStep

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);
Availability: OpenStep

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);
Availability: OpenStep

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();
Availability: OpenStep

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);
Availability: OpenStep

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);
Availability: OpenStep

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);
Availability: OpenStep

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

GSDebugAllocationTagRecordedObject

id GSDebugAllocationTagRecordedObject(id object, id tag);
Availability: OpenStep

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);
Availability: OpenStep

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.

GSSetDebugAllocationFunctions

void GSSetDebugAllocationFunctions(void(*) newAddObjectFunc, void(*) newRemoveObjectFunc);
Availability: OpenStep

This functions allows to set own function callbacks for debugging allocation of objects. Useful if you intend to write your own object allocation code.

NSCountFrames

NSUInteger NSCountFrames();
Availability: OpenStep

Retrieve stack information. Use caution: uses built-in gcc functions and currently only works up to 100 frames.

NSFrameAddress

void* NSFrameAddress(NSUInteger offset);
Availability: OpenStep

Retrieve stack information. Use caution: uses built-in gcc functions and currently only works up to 100 frames.

NSReturnAddress

void* NSReturnAddress(NSUInteger offset);
Availability: OpenStep

Retrieve stack information. Use caution: uses built-in gcc functions and currently only works up to 100 frames.

NSDecimal functions

NSDecimalAdd

NSCalculationError NSDecimalAdd(NSDecimal* result, const NSDecimal* left, const NSDecimal* right, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Adds two decimals and returns result to 38-digit precision. See the <NSDecimalNumberBehaviors> protocol for a description of mode and the return value. The result should be preallocated but can be the same as left or right.

NSDecimalCompact

void NSDecimalCompact(NSDecimal* number);
Availability: MacOS-X 10.0.0

Tries to reduce memory used to store number internally.

NSDecimalCompare

NSComparisonResult NSDecimalCompare(const NSDecimal* leftOperand, const NSDecimal* rightOperand);
Availability: MacOS-X 10.0.0

Returns NSOrderedDescending, NSOrderedSame, or NSOrderedAscending depending on whether leftOperand is greater than, equal to, or less than rightOperand.

NSDecimalCopy

void NSDecimalCopy(NSDecimal* destination, const NSDecimal* source);
Availability: MacOS-X 10.0.0

Copies value of decimal number to preallocated destination.

NSDecimalDivide

NSCalculationError NSDecimalDivide(NSDecimal* result, const NSDecimal* l, const NSDecimal* rr, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Divides l by rr and returns result to 38-digit precision. See the <NSDecimalNumberBehaviors> protocol for a description of mode and the return value. The result should be preallocated but can be the same as l or rr.

NSDecimalDouble

double NSDecimalDouble(NSDecimal* number);
Availability: MacOS-X 10.0.0

Give back the value of a NSDecimal as a double in (preallocated) result.

NSDecimalFromComponents

void NSDecimalFromComponents(NSDecimal* result, unsigned long long int mantissa, short int exponent, BOOL negative);
Availability: MacOS-X 10.0.0

Create a NSDecimal with a mantissa, exponent and a negative flag in (preallocated) result.

NSDecimalFromString

void NSDecimalFromString(NSDecimal* result, NSString* numberValue, NSDictionary* locale);
Availability: MacOS-X 10.0.0

Create a NSDecimal from a string using the locale, in (preallocated) result.

NSDecimalIsNotANumber

BOOL NSDecimalIsNotANumber(const NSDecimal* decimal);
Availability: MacOS-X 10.0.0

Returns whether decimal represents an invalid number (i.e., an "NaN" as might result from an overflow or a division by zero).

NSDecimalMax

void NSDecimalMax(NSDecimal* result);
Availability: MacOS-X 10.0.0

Give back the biggest NSDecimal in (preallocated) result.

NSDecimalMin

void NSDecimalMin(NSDecimal* result);
Availability: MacOS-X 10.0.0

Give back the smallest NSDecimal in (preallocated) result.

NSDecimalMultiply

NSCalculationError NSDecimalMultiply(NSDecimal* result, const NSDecimal* l, const NSDecimal* r, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Multiplies two decimals and returns result to 38-digit precision. See the <NSDecimalNumberBehaviors> protocol for a description of mode and the return value. The result should be preallocated but can be the same as l or r.

NSDecimalMultiplyByPowerOf10

NSCalculationError NSDecimalMultiplyByPowerOf10(NSDecimal* result, const NSDecimal* n, short int power, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Multiplies n by 10^power and returns result to 38-digit precision. See the <NSDecimalNumberBehaviors> protocol for a description of mode and the return value. The result should be preallocated but can be the same as n.

NSDecimalNormalize

NSCalculationError NSDecimalNormalize(NSDecimal* n1, NSDecimal* n2, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Sets the exponents of n1 and n2 equal to one another, adjusting mantissas as necessary to preserve values. This makes certain operations quicker.

NSDecimalPower

NSCalculationError NSDecimalPower(NSDecimal* result, const NSDecimal* n, NSUInteger power, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Raises n to power and returns result to 38-digit precision. See the <NSDecimalNumberBehaviors> protocol for a description of mode and the return value. The result should be preallocated but can be the same as n or power.

NSDecimalRound

void NSDecimalRound(NSDecimal* result, const NSDecimal* number, NSInteger scale, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Rounds number to result such that it has at most scale digits to the right of its decimal point, according to mode (see the <NSDecimalNumberBehaviors> protocol). The result should be preallocated but can be the same as number.

NSDecimalString

NSString* NSDecimalString(const NSDecimal* decimal, NSDictionary* locale);
Availability: MacOS-X 10.0.0

Returns a string representing the full decimal value, formatted according to locale (send nil here for default locale).

NSDecimalSubtract

NSCalculationError NSDecimalSubtract(NSDecimal* result, const NSDecimal* left, const NSDecimal* right, NSRoundingMode mode);
Availability: MacOS-X 10.0.0

Subtracts two decimals and returns result to 38-digit precision. See the <NSDecimalNumberBehaviors> protocol for a description of mode and the return value. The result should be preallocated but can be the same as left or right.

NSException functions

NSGetUncaughtExceptionHandler

NSUncaughtExceptionHandler* NSGetUncaughtExceptionHandler();
Availability: OpenStep

Returns the exception handler called when an exception is generated and not caught by the programmer (by enclosing in NS_DURING and NS_HANDLER... NS_ENDHANDLER ). The default prints an error message and exits the program. You can change this behavior by calling NSSetUncaughtExceptionHandler() .

NSSetUncaughtExceptionHandler

void NSSetUncaughtExceptionHandler(NSUncaughtExceptionHandler* handler);
Availability: OpenStep

Sets the exception handler called when an exception is generated and not caught by the programmer (by enclosing in NS_DURING and NS_HANDLER ... NS_ENDHANDLER). The default prints an error message and exits the program. proc should take a single argument of type NSException *.

NB. If the exception handler set by this function does not terminate the process, the process will be terminateed anyway. This is a safety precaution to ensure that, in the event of an exception being raised and not handled, the program does not try to continue running in a confused state (possibly doing horrible things like billing customers who shouldn't be billed etc), but shuts down as cleanly as possible.

Process termination is normally accomplished by calling the standard exit function of the C runtime library, but if the environment variable CRASH_ON_ABORT is set to YES or TRUE or 1 the termination will be accomplished by calling the abort function instead, which should cause a core dump to be made for debugging.

The value of proc should be a pointer to a function taking an NSException instance as an argument.


NSUncaughtExceptionHandler

void NSUncaughtExceptionHandler(NSException* exception);
Availability: OpenStep

This is the type of the exception handler called when an exception is generated and not caught by the programmer. See NSGetUncaughtExceptionHandler() , NSSetUncaughtExceptionHandler() .

_NSAddHandler

void _NSAddHandler(NSHandler* handler);
Availability: OpenStep

Private support routine. Do not call directly.

_NSRemoveHandler

void _NSRemoveHandler(NSHandler* handler);
Availability: OpenStep

Private support routine. Do not call directly.

NSGeometry functions

NSContainsRect

BOOL NSContainsRect(NSRect aRect, NSRect bRect);
Availability: OpenStep

Returns 'YES' iff aRect totally encloses bRect. NOTE: For this to be the case, aRect cannot be empty, nor can any side of bRect go beyond any side of aRect . Note that this behavior is different than the original OpenStep behavior, where the sides of bRect could not touch aRect.

NSDivideRect

void NSDivideRect(NSRect aRect, NSRect* slice, NSRect* remainder, CGFloat amount, NSRectEdge edge);
Availability: OpenStep

Divides aRect into two rectangles (namely slice and remainder) by "cutting" aRect---parallel to, and a distance amount from the given edge of aRect. You may pass 0 in as either of slice or remainder to avoid obtaining either of the created rectangles.

NSEqualPoints

BOOL NSEqualPoints(NSPoint aPoint, NSPoint bPoint);
Availability: OpenStep

Returns 'YES' iff aPoint's and bPoint's x- and y-coordinates are the same.

NSEqualRects

BOOL NSEqualRects(NSRect aRect, NSRect bRect);
Availability: OpenStep

Test geometric relationships...
Returns 'YES' iff aRect's and bRect's origin and size are the same.

NSEqualSizes

BOOL NSEqualSizes(NSSize aSize, NSSize bSize);
Availability: OpenStep

Returns 'YES' iff aSize's and bSize's width and height are the same.

NSHeight

CGFloat NSHeight(NSRect aRect);
Availability: OpenStep

Returns aRect's height.

NSInsetRect

NSRect NSInsetRect(NSRect aRect, CGFloat dX, CGFloat dY);
Availability: OpenStep

Returns the rectangle obtained by moving each of aRect's horizontal sides inward by dy and each of aRect's vertical sides inward by dx.
NB. For MacOS-X compatability, this is permitted to return a rectanglew with nagative width or height, strange as that seems.

NSIntegralRect

NSRect NSIntegralRect(NSRect aRect);
Availability: OpenStep

Returns a rectangle obtained by expanding aRect minimally so that all four of its defining components are integers.

NSIntersectionRect

NSRect NSIntersectionRect(NSRect aRect, NSRect bRect);
Availability: OpenStep

Returns the largest rectangle which lies in both aRect and bRect. If aRect and bRect have empty intersection (or, rather, intersection of measure zero, since this includes having their intersection be only a point or a line), then the empty rectangle is returned.

NSIntersectsRect

BOOL NSIntersectsRect(NSRect aRect, NSRect bRect);
Availability: MacOS-X 10.0.0

Returns YES if aRect and bRect have non-zero intersection area (intersecting at a line or a point doesn't count).

NSIsEmptyRect

BOOL NSIsEmptyRect(NSRect aRect);
Availability: OpenStep

Returns 'YES' iff the area of aRect is zero (i.e., iff either of aRect's width or height is negative or zero).

NSMakePoint

NSPoint NSMakePoint(CGFloat x, CGFloat y);
Availability: OpenStep

Returns an NSPoint having x-coordinate X and y-coordinate Y.

NSMakeRect

NSRect NSMakeRect(CGFloat x, CGFloat y, CGFloat w, CGFloat h);
Availability: OpenStep

Returns an NSRect having point of origin ( x, y) and size {w, h}.

NSMakeSize

NSSize NSMakeSize(CGFloat w, CGFloat h);
Availability: OpenStep

Returns an NSSize having width w and height h.

NSMaxX

CGFloat NSMaxX(NSRect aRect);
Availability: OpenStep

Returns the greatest x-coordinate value still inside aRect.

NSMaxY

CGFloat NSMaxY(NSRect aRect);
Availability: OpenStep

Returns the greatest y-coordinate value still inside aRect.

NSMidX

CGFloat NSMidX(NSRect aRect);
Availability: OpenStep

Returns the x-coordinate of aRect's middle point.

NSMidY

CGFloat NSMidY(NSRect aRect);
Availability: OpenStep

Returns the y-coordinate of aRect's middle point.

NSMinX

CGFloat NSMinX(NSRect aRect);
Availability: OpenStep

Returns the least x-coordinate value still inside aRect.

NSMinY

CGFloat NSMinY(NSRect aRect);
Availability: OpenStep

Returns the least y-coordinate value still inside aRect.

NSMouseInRect

BOOL NSMouseInRect(NSPoint aPoint, NSRect aRect, BOOL flipped);
Availability: OpenStep

Returns 'YES' iff aPoint is inside aRect.

NSOffsetRect

NSRect NSOffsetRect(NSRect aRect, CGFloat dx, CGFloat dy);
Availability: OpenStep

Returns the rectangle obtained by translating aRect horizontally by dx and vertically by dy.

NSPointFromString

NSPoint NSPointFromString(NSString* string);
Availability: OpenStep

Parses point from string of form " {x=a; y=b} ". (0,0) returned if parsing fails.

NSPointInRect

BOOL NSPointInRect(NSPoint aPoint, NSRect aRect);
Availability: OpenStep

Just like 'NSMouseInRect(aPoint, aRect, YES)'.

NSRectFromString

NSRect NSRectFromString(NSString* string);
Availability: OpenStep

Parses point from string of form " {x=a; y=b; width=c; height=d} ". Rectangle of 0 size at origin returned if parsing fails.

NSSizeFromString

NSSize NSSizeFromString(NSString* string);
Availability: OpenStep

Parses size from string of form " {width=a; height=b} ". Size of 0,0 returned if parsing fails.

NSStringFromPoint

NSString* NSStringFromPoint(NSPoint aPoint);
Availability: OpenStep

Returns an NSString of the form "{x=X; y=Y}", where X and Y are the x- and y-coordinates of aPoint, respectively.
Get a String Representation...

NSStringFromRect

NSString* NSStringFromRect(NSRect aRect);
Availability: OpenStep

Returns an NSString of the form "{x=X; y=Y; width=W; height=H}", where X, Y, W, and H are the x-coordinate, y-coordinate, width, and height of aRect, respectively.

NSStringFromSize

NSString* NSStringFromSize(NSSize aSize);
Availability: OpenStep

Returns an NSString of the form "{width=W; height=H}", where W and H are the width and height of aSize, respectively.

NSUnionRect

NSRect NSUnionRect(NSRect aRect, NSRect bRect);
Availability: OpenStep

Returns the smallest rectangle which contains both aRect and bRect (modulo a set of measure zero). If either of aRect or bRect is an empty rectangle, then the other rectangle is returned. If both are empty, then the empty rectangle is returned.

NSWidth

CGFloat NSWidth(NSRect aRect);
Availability: OpenStep

Returns aRect's width.

NSHashTable functions

NSAllHashTableObjects

NSArray* NSAllHashTableObjects(NSHashTable* table);
Availability: OpenStep

Description forthcoming.

NSCompareHashTables

BOOL NSCompareHashTables(NSHashTable* table1, NSHashTable* table2);
Availability: OpenStep

Description forthcoming.

NSCopyHashTableWithZone

NSHashTable* NSCopyHashTableWithZone(NSHashTable* table, NSZone* zone);
Availability: OpenStep

Description forthcoming.

NSCountHashTable

NSUInteger NSCountHashTable(NSHashTable* table);
Availability: OpenStep

Description forthcoming.

NSCreateHashTable

NSHashTable* NSCreateHashTable(NSHashTableCallBacks callBacks, NSUInteger capacity);
Availability: OpenStep

Description forthcoming.

NSCreateHashTableWithZone

NSHashTable* NSCreateHashTableWithZone(NSHashTableCallBacks callBacks, NSUInteger capacity, NSZone* zone);
Availability: OpenStep

Description forthcoming.

NSEndHashTableEnumeration

void NSEndHashTableEnumeration(NSHashEnumerator* enumerator);
Availability: OpenStep

Description forthcoming.

NSEnumerateHashTable

NSHashEnumerator NSEnumerateHashTable(NSHashTable* table);
Availability: OpenStep

Description forthcoming.

NSFreeHashTable

void NSFreeHashTable(NSHashTable* table);
Availability: OpenStep

Description forthcoming.

NSHashGet

void* NSHashGet(NSHashTable* table, const void* element);
Availability: OpenStep

Description forthcoming.

NSHashInsert

void NSHashInsert(NSHashTable* table, const void* element);
Availability: OpenStep

Description forthcoming.

NSHashInsertIfAbsent

void* NSHashInsertIfAbsent(NSHashTable* table, const void* element);
Availability: OpenStep

Description forthcoming.

NSHashInsertKnownAbsent

void NSHashInsertKnownAbsent(NSHashTable* table, const void* element);
Availability: OpenStep

Description forthcoming.

NSHashRemove

void NSHashRemove(NSHashTable* table, const void* element);
Availability: OpenStep

Description forthcoming.

NSNextHashEnumeratorItem

void* NSNextHashEnumeratorItem(NSHashEnumerator* enumerator);
Availability: OpenStep

Description forthcoming.

NSResetHashTable

void NSResetHashTable(NSHashTable* table);
Availability: OpenStep

Description forthcoming.

NSStringFromHashTable

NSString* NSStringFromHashTable(NSHashTable* table);
Availability: OpenStep

Description forthcoming.

NSMapTable functions

NSAllMapTableKeys

NSArray* NSAllMapTableKeys(NSMapTable* table);
Availability: OpenStep

Description forthcoming.

NSAllMapTableValues

NSArray* NSAllMapTableValues(NSMapTable* table);
Availability: OpenStep

Description forthcoming.

NSCompareMapTables

BOOL NSCompareMapTables(NSMapTable* table1, NSMapTable* table2);
Availability: OpenStep

Description forthcoming.

NSCopyMapTableWithZone

NSMapTable* NSCopyMapTableWithZone(NSMapTable* table, NSZone* zone);
Availability: OpenStep

Description forthcoming.

NSCountMapTable

NSUInteger NSCountMapTable(NSMapTable* table);
Availability: OpenStep

Description forthcoming.

NSCreateMapTable

NSMapTable* NSCreateMapTable(NSMapTableKeyCallBacks keyCallBacks, NSMapTableValueCallBacks valueCallBacks, NSUInteger capacity);
Availability: OpenStep

Description forthcoming.

NSCreateMapTableWithZone

NSMapTable* NSCreateMapTableWithZone(NSMapTableKeyCallBacks keyCallBacks, NSMapTableValueCallBacks valueCallBacks, NSUInteger capacity, NSZone* zone);
Availability: OpenStep

Description forthcoming.

NSEndMapTableEnumeration

void NSEndMapTableEnumeration(NSMapEnumerator* enumerator);
Availability: OpenStep

Description forthcoming.

NSEnumerateMapTable

NSMapEnumerator NSEnumerateMapTable(NSMapTable* table);
Availability: OpenStep

Description forthcoming.

NSFreeMapTable

void NSFreeMapTable(NSMapTable* table);
Availability: OpenStep

Description forthcoming.

NSMapGet

void* NSMapGet(NSMapTable* table, const void* key);
Availability: OpenStep

Description forthcoming.

NSMapInsert

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

Description forthcoming.

NSMapInsertIfAbsent

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

Description forthcoming.

NSMapInsertKnownAbsent

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

Description forthcoming.

NSMapMember

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

Description forthcoming.

NSMapRemove

void NSMapRemove(NSMapTable* table, const void* key);
Availability: OpenStep

Description forthcoming.

NSNextMapEnumeratorPair

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

Description forthcoming.

NSResetMapTable

void NSResetMapTable(NSMapTable* table);
Availability: OpenStep

Description forthcoming.

NSStringFromMapTable

NSString* NSStringFromMapTable(NSMapTable* table);
Availability: OpenStep

Description forthcoming.

NSObjCRuntime functions

GSLogLock

NSRecursiveLock* GSLogLock();
Availability: Not in OpenStep/MacOS-X

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);
Availability: OpenStep

Returns the class whose name is supplied in the aClassName argument, or Nil if a nil string is supplied. If no such class has been loaded, the function returns Nil.

NSGetSizeAndAlignment

const char* NSGetSizeAndAlignment(const char* typePtr, NSUInteger* sizep, NSUInteger* alignp);
Availability: OpenStep

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 null pointer, the corresponding data is not extracted.
The function returns a pointer into the type information C string immediately after the decoded information.

NSLog

void NSLog(NSString* format,...);
Availability: OpenStep

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);
Availability: Not in OpenStep/MacOS-X

OpenStep spec states that log messages go to stderr, but just in case someone wants them to go somewhere else, they can implement a function like this and assign a pointer to it to _NSLog_printf_handler.

NSLogv

void NSLogv(NSString* format, va_list args);
Availability: OpenStep

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.

In GNUstep, the GSLogThread user default may be set to YES in order to instruct this function to include the internal ID of the current thread after the process ID. This can help you to track the behavior of a multi-threaded program.

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


NSProtocolFromString

Protocol* NSProtocolFromString(NSString* aProtocolName);
Availability: MacOS-X 10.5.0

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

NSSelectorFromString

SEL NSSelectorFromString(NSString* aSelectorName);
Availability: OpenStep

Returns (creating if necessary) the selector whose name is supplied in the aSelectorName argument, or 0 if a nil string is supplied.

NSStringFromClass

NSString* NSStringFromClass(Class aClass);
Availability: OpenStep

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

NSStringFromProtocol

NSString* NSStringFromProtocol(Protocol* aProtocol);
Availability: MacOS-X 10.5.0

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

NSStringFromSelector

NSString* NSStringFromSelector(SEL aSelector);
Availability: OpenStep

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

NSObject functions

NSAllocateObject

id NSAllocateObject(Class aClass, NSUInteger extraBytes, NSZone* zone);
Availability: OpenStep

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:] method.

NSCopyObject

NSObject* NSCopyObject(NSObject* anObject, NSUInteger extraBytes, NSZone* zone);
Availability: OpenStep

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(id anObject);
Availability: OpenStep

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

NSDecrementExtraRefCountWasZero

BOOL NSDecrementExtraRefCountWasZero(id anObject);
Availability: OpenStep

Description forthcoming.

NSExtraRefCount

NSUInteger NSExtraRefCount(id anObject);
Availability: OpenStep

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);
Availability: OpenStep

Description forthcoming.

NSShouldRetainWithZone

BOOL NSShouldRetainWithZone(NSObject* anObject, NSZone* requestedZone);
Availability: OpenStep

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

GNUstepConfig

NSMutableDictionary* GNUstepConfig(NSDictionary* newConfig);
Availability: Not in OpenStep/MacOS-X

Returns a mutable copy of the system-wide configuration used to determine paths to locate files etc.
If the newConfig argument is non-nil it is used to set the config overriding any other version. You should not change the config after the user defaults system has been initialised as the new config will not be picked up by the defaults system.

A typical sequence of operation might be to
Call the function with a nil argument to obtain the configuration information currently in use (usually obtained from the main GNUstep configuration file).
Modify the dictionary contents.
Call the function again passing back in the modified config.

If you call this function with a non-nil argument before the system configuration file has been read, you will prevent the file from being read. However, you must take care doing this that creation of the config dictionary you are going to pass in to the function does not have any side-effects which would cause the config file to be read earlier.
If you want to prevent the user specific config file from being read, you must set the GNUSTEP_USER_CONFIG_FILE value in the dictionary to be an empty string.

GNUstepUserConfig

void GNUstepUserConfig(NSMutableDictionary* config, NSString* userName);
Availability: Not in OpenStep/MacOS-X

The config dictionary passed to this function should be a system-wide config as provided by GNUstepConfig() ... and this function merges in user specific configuration file information if such a file exists and is owned by the user.
NB. If the GNUSTEP_USER_CONFIG_FILE value in the system-wide config is an empty string, no user-specifc config will be read.

GSDefaultsRootForUser

NSString* GSDefaultsRootForUser(NSString* userName);
Availability: Not in OpenStep/MacOS-X

Returns the location of the defaults database for the specified user. This uses the same information you get from GNUstepConfig() and GNUstepUserConfig() and builds the path to the defaults database fromm it.
Return the path of the defaults directory for userName.
This examines the GNUSTEP_USER_CONFIG_FILE for the specified user, with settings in it over-riding those in the main GNUstep.conf.

GSSetUserName

void GSSetUserName(NSString* aName);
Availability: Not in OpenStep/MacOS-X

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 posses the file access privileges of the new name. This is provided primarily for use by processes that run as system-manager and need to act as particular users. It uses the [NSUserDefaults +resetUserDefaults] extension to reset the defaults system to use the defaults belonging to the new user.

NSFullUserName

NSString* NSFullUserName();
Availability: MacOS-X 10.0.0

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

NSHomeDirectory

NSString* NSHomeDirectory();
Availability: OpenStep

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

NSHomeDirectoryForUser

NSString* NSHomeDirectoryForUser(NSString* loginName);
Availability: OpenStep

Returns loginName's home directory as an NSString object.
On most systems this returns the directory specified in the system's password file (ar at least whatever is returned by the standard operating system API for retrieving password file records), but on ms-windows this is determined by examining the HOMEPATH and HOMEDRIVE environment variables or (if those don't make sense) the USERPROFILE environment variable.

NSOpenStepRootDirectory

NSString* NSOpenStepRootDirectory();
Availability: MacOS-X 10.0.0

Returns the location of the root directory of the file hierarchy. This lets you build paths in a system independent manner (for instance the root on unix is '/' but on windows it is 'C:\') by appending path components to the root.
Don't assume that /System, /Network etc exist in this path (generally they don't)! Use other path utility functions such as NSSearchPathForDirectoriesInDomains() to find standard locations for libraries, applications etc.
Refer to the GNUstep File System Hierarchy documentation for more info.

NSSearchPathForDirectoriesInDomains

NSArray* NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory directoryKey, NSSearchPathDomainMask domainMask, BOOL expandTilde);
Availability: MacOS-X 10.0.0

Returns an array of search paths to look at for resources.
The paths are returned in domain order: USER, LOCAL, NETWORK then SYSTEM.
The presence of a path in this list does not mean that the path actually exists in the filesystem.
If you are wanting to locate an existing resource, you should normally call this function with NSAllDomainsMask, but if you wish to find the path in which you should create a new file, you would generally specify a particular domain, and then create the path in the file system if it does not already exist.

NSStandardApplicationPaths

NSArray* NSStandardApplicationPaths();
Availability: MacOS-X 10.0.0

Returns the standard paths in which applications are stored and should be searched for. Calls NSSearchPathForDirectoriesInDomains()
Refer to the GNUstep File System Hierarchy documentation for more info.

NSStandardLibraryPaths

NSArray* NSStandardLibraryPaths();
Availability: MacOS-X 10.0.0

Returns the standard paths in which resources are stored and should be searched for. Calls NSSearchPathForDirectoriesInDomains()
Refer to the GNUstep File System Hierarchy documentation for more info.

NSTemporaryDirectory

NSString* NSTemporaryDirectory();
Availability: MacOS-X 10.0.0

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.
If a suitable directory can't be found or created, this function raises an NSGenericException.

NSUserName

NSString* NSUserName();
Availability: OpenStep

Return the caller's login name as an NSString object.
Under unix-like systems, the name associated with the current effective user ID is used.
Under ms-windows, the 'LOGNAME' environment is used, or if that fails, the GetUserName() call is used to find the user name.
Raises an exception on failure.

NSProcessInfo functions

GSDebugSet

BOOL GSDebugSet(NSString* level);
Availability: Base
Likely to be changed/moved/removed at 1.17.0

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.

GSInitializeProcess

void GSInitializeProcess(int argc, char** argv, char** envp);
Availability: Base
Likely to be changed/moved/removed at 1.17.0

Fallback/override function.
The developer must call this method to initialize the NSProcessInfo system if none of the system-specific hacks to auto-initialize it are working.
It is also safe to call this function to override the effects of the automatic initialisation, which some applications may need to do when using GNUstep libraries embedded within other frameworks.

NSRange functions

NSEqualRanges

BOOL NSEqualRanges(NSRange range1, NSRange range2);
Availability: OpenStep

Returns whether range1 and range2 have same location and length.

NSIntersectionRange

NSRange NSIntersectionRange(NSRange aRange, NSRange bRange);
Availability: OpenStep

Returns range containing indices existing in both aRange and bRange. If the returned length is 0, the location is undefined and should be ignored.

NSLocationInRange

BOOL NSLocationInRange(NSUInteger location, NSRange range);
Availability: OpenStep

Returns whether location is greater than or equal to range's location and less than its max.

NSMakeRange

NSRange NSMakeRange(NSUInteger location, NSUInteger length);
Availability: OpenStep

Creates new range starting at location and of given length.

NSMaxRange

NSUInteger NSMaxRange(NSRange range);
Availability: OpenStep

Returns top end of range (location + length).

NSRangeFromString

NSRange NSRangeFromString(NSString* aString);
Availability: OpenStep

Parses range from string of form {location=a, length=b}; returns range with 0 location and length if this fails.

NSStringFromRange

NSString* NSStringFromRange(NSRange range);
Availability: OpenStep

Returns string of form {location=a, length=b}.

NSUnionRange

NSRange NSUnionRange(NSRange aRange, NSRange bRange);
Availability: OpenStep

Returns range going from minimum of aRange's and bRange's locations to maximum of their two max's.

_NSRangeExceptionRaise

void _NSRangeExceptionRaise();
Availability: OpenStep

Convenience method for raising an NSRangeException.

NSSet functions

GSUPurge

void GSUPurge(NSUInteger count);
Availability: Not in OpenStep/MacOS-X

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, NSUInteger count);
Availability: Not in OpenStep/MacOS-X

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);
Availability: Not in OpenStep/MacOS-X

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);
Availability: Not in OpenStep/MacOS-X

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

GSRegisterCurrentThread

BOOL GSRegisterCurrentThread();
Availability: Base
Likely to be changed/moved/removed at 0.0.0

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();
Availability: Base
Likely to be changed/moved/removed at 0.0.0

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 (like [NSThread +exit] ) but does not exit the underlying thread.


NSZone functions

GSAssignZeroingWeakPointer

BOOL GSAssignZeroingWeakPointer(void** destination, void* source);
Availability: Not in OpenStep/MacOS-X

This function must be used to assign a value to a zeroing weak pointer.
A zeroing weak pointer is one where, when the garbage collector collects the object pointed to, it also clears the weak pointer.
Assigning zero (nil) will always succeed and has the effect of telling the garbage collector that it no longer needs to track the previously assigned object. Apart from that case, a source needs to be garbage collectable for this function to work, and using a non-garbage collectable value will cause the function to return NO.
If the destination object (the weak pointer watching the source object) belongs to a chunk of memory which may be collected before the source object is collected, it is important that it is finalised and the finalisation code assigns zero to the pointer.
If garbage collection is not in use, this function performs a simple assignment returning YES, unless destination is null in which case it returns NO.

GSMakeWeakPointer

void GSMakeWeakPointer(Class theClass, const char* iVarName);
Availability: Not in OpenStep/MacOS-X

Called during +initialize to tell the class that instances created in future should have the specified instance variable as a weak pointer for garbage collection.
NB. making a pointer weak does not mean that it is automatically zeroed when the object it points to is garbage collected. To get that behavior you must asign values to the pointer using the GSAssignZeroingWeakPointer() function.
This function has no effect if the system is not built for garbage collection.

GSOutOfMemory

void* GSOutOfMemory(NSUInteger size, BOOL retry);
Availability: Not in OpenStep/MacOS-X

Try to get more memory - the normal process has failed. If we can't do anything, just return a null pointer. Try to do some logging if possible.

NSAllocateCollectable

void* NSAllocateCollectable(NSUInteger size, NSUInteger options);
Availability: MacOS-X 10.4.0

Allocate memory. If garbage collection is not enabled this uses the default malloc zone and the options are ignored.
If garbage collection is enabled, the allocate memory is normally not scanned for pointers but is itsself garbage collectable. The options argument is a bitmask in which NSScannedOption sets the memory to be scanned for pointers by the garbage collector, and NSCollectorDisabledOption causes the memory to be excempt from being garbage collected itsself.
In any case the memory returned is zero'ed.

NSAllocateMemoryPages

void* NSAllocateMemoryPages(NSUInteger bytes);
Availability: OpenStep

Allocate memory for this process and return a pointer to it (or a null pointer on failure). The allocated memory is page aligned and the actual size of memory allocated is a multiple of the page size.

NSCopyMemoryPages

void NSCopyMemoryPages(const void* src, void* dest, NSUInteger bytes);
Availability: OpenStep

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(NSUInteger start, NSUInteger gran, BOOL canFree);
Availability: OpenStep

Creates a new zone of start bytes, which will grow and shrink by granularity bytes. If canFree is 0, memory in zone is allocated but never freed, meaning allocation will be very fast. The whole zone can still be freed with NSRecycleZone() , and you should still call NSZoneFree on memory in the zone that is no longer needed, since a count of allocated pointers is kept and must reach zero before freeing the zone.
If Garbage Collection is enabled, this function does nothing other than log a warning and return the same value as the NSDefaultMallocZone() function.

NSDeallocateMemoryPages

void NSDeallocateMemoryPages(void* ptr, NSUInteger bytes);
Availability: OpenStep

Deallocate memory which was previously allocated using the NSAllocateMemoryPages() function.
The bytes argument should be the same as the value passed to the NSAllocateMemoryPages() function.

NSDefaultMallocZone

NSZone* NSDefaultMallocZone();
Availability: OpenStep

Returns the default zone for memory allocation. Memory created in this zone is the same as memory allocates using the system malloc() function.

NSLogPageSize

NSUInteger NSLogPageSize();
Availability: OpenStep

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

NSPageSize

NSUInteger NSPageSize();
Availability: OpenStep

Return the number of bytes in a memory page.

NSRealMemoryAvailable

NSUInteger NSRealMemoryAvailable();
Availability: OpenStep

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

NSReallocateCollectable

void* NSReallocateCollectable(void* ptr, NSUInteger size, NSUInteger options);
Availability: MacOS-X 10.4.0

Reallocate memory to be of a different size and/or to have different options settings. The behavior of options is as for the NSAllocateCollectable() function.

NSRecycleZone

void NSRecycleZone(NSZone* zone);
Availability: OpenStep

Return memory for an entire zone to system. In fact, this will not be done unless all memory in the zone has been explicitly freed (by calls to NSZoneFree()). For "non-freeable" zones, the number of NSZoneFree() calls must simply equal the number of allocation calls. The default zone, on the other hand, cannot be recycled.
If Garbage Collection is enabled, this function has not effect.

NSRoundDownToMultipleOfPageSize

NSUInteger NSRoundDownToMultipleOfPageSize(NSUInteger bytes);
Availability: OpenStep

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

NSRoundUpToMultipleOfPageSize

NSUInteger NSRoundUpToMultipleOfPageSize(NSUInteger bytes);
Availability: OpenStep

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

NSSetZoneName

void NSSetZoneName(NSZone* zone, NSString* name);
Availability: OpenStep

Sets name of the given zone (useful for debugging and logging).

NSZoneCalloc

void* NSZoneCalloc(NSZone* zone, NSUInteger elems, NSUInteger bytes);
Availability: OpenStep

Allocates and returns cleared memory for elems items of size bytes, in the given zone. Returns NULL if allocation of size 0 requested. Raises NSMallocException if not enough free memory in zone to allocate and no more can be obtained from system, unless using the default zone, in which case NULL is returned.
If Garbage Collection is enabled, this function always allocates non-scanned, non-collectable memory in the NSDefaultMallocZone() and the zone argument is ignored.

NSZoneCheck

BOOL NSZoneCheck(NSZone* zone);
Availability: Not in OpenStep/MacOS-X

Deprecated...
Checks integrity of a zone. Not defined by OpenStep or OS X.

NSZoneFree

void NSZoneFree(NSZone* zone, void* ptr);
Availability: OpenStep

Frees memory pointed to by ptr (which should have been allocated by a previous call to NSZoneMalloc() , NSZoneCalloc() , or NSZoneRealloc()) and returns it to zone. Note, if this is a nonfreeable zone, the memory is not actually freed, but the count of number of free()s is updated.
If Garbage Collection is enabled, the zone argument is ignored and this function causes ptr to be deallocated immediately.

NSZoneFromPointer

NSZone* NSZoneFromPointer(void* ptr);
Availability: OpenStep

Searches and finds the zone ptr was allocated from. The speed depends upon the number of zones and their size.
If Garbage Collection is enabled, this function always returns the same as the NSDefaultMallocZone() function.

NSZoneMalloc

void* NSZoneMalloc(NSZone* zone, NSUInteger size);
Availability: OpenStep

Allocates and returns memory for elems items of size bytes, in the given zone. Returns NULL if allocation of size 0 requested. Raises NSMallocException if not enough free memory in zone to allocate and no more can be obtained from system, unless using the default zone, in which case NULL is returned.
If Garbage Collection is enabled, this function always allocates non-scanned, non-collectable memory in the NSDefaultMallocZone() and the zone argument is ignored.

NSZoneName

NSString* NSZoneName(NSZone* zone);
Availability: OpenStep

Returns the name of the given zone (useful for debugging and logging).

NSZoneRealloc

void* NSZoneRealloc(NSZone* zone, void* ptr, NSUInteger size);
Availability: OpenStep

Reallocates the chunk of memory in zone pointed to by ptr to a new one of size bytes. Existing contents in ptr are copied over. Raises an NSMallocException if insufficient memory is available in the zone and no more memory can be obtained from the system, unless using the default zone, in which case NULL is returned.
If Garbage Collection is enabled, the zone argument is ignored.

NSZoneStats

struct NSZoneStats NSZoneStats(NSZone* zone);
Availability: Not in OpenStep/MacOS-X

Deprecated...
Obtain statistics about the zone. Implementation emphasis is on correctness, not speed. Not defined by OpenStep or OS X.


Up