Copyright: (C) 2005 Free Software Foundation, Inc.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the
version number of the next minor release after the
most recent one.
As a general principle you
should not change the API with changing
subminor version numbers... as that tends to
confuse people (though Apple has sometimes done
it).
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the
version number of the next minor release after the
most recent one.
As a general principle you
should not change the API with changing
subminor version numbers... as that tends to
confuse people (though Apple has sometimes done
it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
Macro to check a defined GNUstep version number (GS_GNUSTEP_V) against the supplied arguments. Returns true if no GNUstep version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use the predefined constants... GS_API_NONE , GS_API_LATEST ,
Also see OS_API_VERSION
NB. If you are changing the API (eg adding a new
feature) you need to control the visibility io the
new header file code using
#if GS_API_VERSION(ADD,GS_API_LATEST)
where ADD is the version number
of the next minor release after the most recent one.
As a general principle you should
not change the API with changing subminor
version numbers... as that tends to confuse people
(though Apple has sometimes done it).
Macro to check a defined OpenStep/OPENSTEP/MacOS-X version against the supplied arguments. Returns true if no version is specified, or if ADD <= version < REM, where ADD is the version number at which a feature guarded by the macro was introduced and REM is the version number at which it was removed.
The version number arguments are six digit integers where the first two digits are the major version number, the second two are the minor version number and the last two are the subminor number (all left padded with a zero where necessary). However, for convenience you can also use any of several predefined constants... GS_API_NONE , GS_API_LATEST , GS_API_OSSPEC , GS_API_OPENSTEP , GS_API_MACOSX
Also see GS_API_VERSION
For OSX compatibility, this macro also supports the use of Apple's symbolic constants for version numbering. Their contants are currently four digit values (two digits for the major version, one for the minor, and one for the subminor).
A constant which is the lowest possible version number (0)
so that when used as the removal version (second argument
of the GS_API_VERSION or OS_API_VERSION macro) represents
a feature which is not present in any version.
eg.
#if
OS_API_VERSION
(GS_API_NONE, GS_API_NONE)
denotes code
not present in OpenStep/OPENSTEP/MacOS-X
A
constant to represent a feature which is still
present in the latest version. This is the highest
possible version number.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
The version number of the initial OpenStep
specification.
eg.
#if
OS_API_VERSION
(GS_API_OSSPEC, GS_API_LATEST)
denotes
code present from the OpenStep specification onwards.
The version number of the first OPENSTEP
implementation.
eg.
#if
OS_API_VERSION
(GS_API_OPENSTEP, GS_API_LATEST)
denotes code present from the initial OPENSTEP
version onwards.
The version number of the
first MacOS-X implementation.
eg.
#if
OS_API_VERSION
(GS_API_MACOSX, GS_API_LATEST)
denotes
code present from the initial MacOS-X version onwards.
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) 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 (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.
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.
YES then the list gives the number of
instances allocated/deallocated since the function
was last called with that setting. 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.
nil
NSOrderedDescending,
NSOrderedSame, or
NSOrderedAscending depending on whether
leftOperand is greater than, equal to, or
less than rightOperand.
nil here for
default locale).
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()
.
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.
YES if aRect and
bRect have non-zero intersection area
(intersecting at a line or a point doesn't
count).
{x=a; y=b} ". (0,0) returned if parsing
fails.
YES)'.
{x=a; y=b; width=c; height=d} ".
Rectangle of 0 size at origin returned if parsing
fails.
{width=a; height=b} ". Size of 0,0
returned if parsing fails.
nil string is supplied. If no such class
has been loaded, the function returns Nil.
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.
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 name (if any) of the current thread after
the process ID. This can help you to track the behavior
of a multi-threaded program.
Also the GSLogOffset
user default may be set to YES in order
to instruct this function to include the time zone
offset in the timestamp it logs (good when examining
debug logs from systems running in different
countries).
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
nil string is supplied.
nil string is
supplied.
nil.
nil.
nil.
YES
if it was.
nil
argument to obtain the configuration information
currently in use (usually obtained from the main
GNUstep configuration file).
NO even if the
specified level exists in the set of
debug levels.
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 (like
[NSThread +exit]
) but does not exit the underlying thread.
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. YES, unless
destination is null in which case it returns
NO.
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. 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. 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.