Warning - the following should never be used.
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.
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).
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.
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.
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.
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.
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.
This macro is a shorthand for NSDebugFLLog() using then default debug level... 'dflt'
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.
This macro is a shorthand for NSDebugLLog() using then default debug level... 'dflt'
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.
This macro is a shorthand for NSDebugMLLog() using then default debug level... 'dflt'
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() 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.
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.
Used in an ObjC method body.
See
NSAssertionHandler
for details.
When condition is false,
raise an exception using desc
Used in an ObjC method body.
See
NSAssertionHandler
for details.
When condition is false,
raise an exception using desc and
arg1
Used in an ObjC method body.
See
NSAssertionHandler
for details.
When condition is false,
raise an exception using desc and
arg1, arg2
Used in an ObjC method body.
See
NSAssertionHandler
for details.
When condition is false,
raise an exception using desc and
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,
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, 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
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
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
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
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
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
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.
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.
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.
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.
ASSIGN(object,value) assigns the value to the object with appropriate retain and release operations.
ASSIGNCOPY(object,value) assigns a copy of the value to the object with release of the original.
Basic autorelease operation... calls [NSObject -autorelease]
Declares an autorelease pool variable and creates and initialises an autorelease pool 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.
Similar, but allows reuse of variables. Be sure to
use DESTROY()
so
the object variable stays nil
.
Basic release operation... calls [NSObject -release]
Basic retain operation... calls [NSObject -retain]
Tested autorelease - only invoke the objective-c
method if the receiver is not nil
.
Tested release - only invoke the objective-c method if
the receiver is not nil
.
Tested retain - only invoke the objective-c method if
the receiver is not nil
.
Convert a time interval since the reference date into
broken out elements.
External - so NSDate and
others can use it.
Convert a broken out time specification into a time
interval since the reference date.
External -
so NSDate and others can use it.
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.
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.
Used internally by NSAllocateObject() ... you probably don't need this.
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()
.
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.
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.
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.
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.
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.
Used internally by NSDeallocateObject() ... you probably don't need this.
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.
Used to produce a format string for logging a message with function location details.
Used to produce a format string for logging a message with method location details.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Get a String Representation...
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Returns an array of all the objects in the table. NB. The table must contain objects, not pointers or integers.
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.
Copy the supplied map table creating the new table in the specified zone.
Returns the number of objects in the table .
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.
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.
Function to be called when finished with the enumerator. This permits memory used by the enumerator to be released.
Return an enumerator for stepping through a map table using the NSNextHashEnumeratorItem() function.
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.
Returns the value for the specified element, or a null pointer if the element is not found in the table .
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.
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.
Adds the element to table and
returns nul.
If an equal element is
already present, raises NSInvalidArgumentException.
If element is null raises an
NSInvalidArgumentException.
Remove the specified element from the table.
Step through the hash table... return the next item or return nulif we hit the of the table.
Empty the hash table (releasing all elements), but preserve its capacity.
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.
Returns an array of all the keys in the table. NB. The table must contain objects for its keys.
Returns an array of all the values in the table. NB. The table must contain objects for its values.
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.
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.
Returns the number of key/value pairs in the table.
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.
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.
Function to be called when finished with the enumerator. This permits memory used by the enumerator to be released!
Return an enumerator for stepping through a map table using the NSNextMapEnumeratorPair() function.
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.
Returns the value for the specified key, or a null pointer if the key is not found in the table.
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.
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.
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.
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.
Remove the specified key from the
table (if present).
Causes the
key and its associated value to be released.
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.
Empty the map table (releasing every key and value), but preserve its capacity.
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.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Returns the lock used to protect the GNUstep NSLogv() implementation. Use this to protect changes to _NSLogDescriptor and _NSLog_printf_handler
Returns the class whose name is supplied in the
aClassName argument, or 0 if a
nil
string is supplied.
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.
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.
Description forthcoming.
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
Returns a selector for the method whose name is
supplied in the aSelectorName argument,
or 0 if a nil
string is supplied.
Returns an
NSString
object containing the class name for
aClass. If aClass is 0, returns
nil
.
Returns a string object containing the method name
for aSelector. If aSelector is 0,
returns nil
.
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.
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.
Used to release the memory used by an object.
This function is used by the
[NSObject -dealloc]
mnethod.
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.
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.
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.
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.
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.
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.
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)
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)
Returns the full username of the current user. If unable to determine this, returns the standard user name.
Return the caller's home directory as an NSString object. Calls NSHomeDirectoryForUser() to do this.
Returns loginName's home directory as an NSString object.
Returns the root directory for the OpenStep (GNUstep) installation. This si determined by the GNUSTEP_ROOT environment variable if available.
Returns an array of search paths to look at for resources.
Returns the standard paths in which applications are stored and should be searched for. Calls NSSearchPathForDirectoriesInDomains()
Returns the standard paths in which libraries are stored and should be searched for. Calls NSSearchPathForDirectoriesInDomains()
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.
Return the caller's login name as an NSString object. The 'LOGNAME' environment variable is our primary source, but we use other system-dependent sources if LOGNAME is not set. This function is intended to return the name under which the user logged in rather than the name associated with their numeric user ID (though the two are usually the same). If you have a setuid program and want to change the user to reflect the uid, use GSSetUserName()
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.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
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.
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.
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.
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.
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).
Fast access function for thread dictionary of current thread.
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.
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.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Allocate memory for this process and return a pointer to it (or a nul pointer on failure).
Perform an efficient large scale copy of data from src to dest. The value bytes specifies the length of the data copied.
Description forthcoming.
Deallocate memory which was previously allocated using the NSAllocateMemoryPages() function.
Description forthcoming.
Return log base 2 of the number of bytes in a memory page.
Return the number of bytes in a memory page.
Return the number of bytes of real (physical) memory available.
Description forthcoming.
Round bytes down to the nearest multiple of the memory page size, and return it.
Round bytes up to the nearest multiple of the memory page size, and return it.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.
Description forthcoming.