DEC C
Run-Time Library Reference Manual for OpenVMS Systems
1.5 Feature-Test Macros for Header-File Control
Feature-test macros provide a means for writing portable programs. They
ensure that the DEC C RTL symbolic names used by a program do not clash
with the symbolic names supplied by the implementation.
The DEC C Run-time Library header files are coded to support the use of
a number of feature-test macros. When an application defines a
feature-test macro, the DEC C RTL header files supply the symbols and
prototypes defined by that feature-test macro and nothing else. If a
program does not define such a macro, the DEC C RTL header files define
symbols without restriction.
The feature-test macros supported by the DEC C Run-time Library fall
into three broad categories for controlling the visibility of symbols
in header files according to the following:
- Standards
- Multiple-version support
- Compatibility
1.5.1 Standards Macros
The DEC C Run-time Library implements parts of the following standards:
- X/Open CAE Specification, System Interfaces and Headers, Issue 4,
Version 2, also known as XPG4 V2.
- X/Open CAE Specification, System Interfaces and Headers, Issue 4,
also known as XPG4.
- Standard for Information Technology - Portable Operating System
Interface (POSIX) - Part 1: System Application Program Interface
(API)---Amendment 2: Threads Extension [C Language], also known as
POSIX 1003.1c-1995 or IEEE 1003.1c-1995.
- ISO/IEC 9945-2:1993 - Information Technology - Portable Operating
System Interface (POSIX) - Part 2: Shell and Utilities, also known as
ISO POSIX-2.
- ISO/IEC 9945-1:1990 - Information Technology - Portable Operating
System Interface (POSIX) - Part 1: System Application Programming
Interface (API) (C Language), also known as ISO POSIX-1.
- ISO/IEC 9899:1990-1994 - Programming Languages - C, Amendment 1:
Integrity, also known as ISO C, Amendment 1.
- ISO/IEC 9899:1990 - Programming Languages - C, also known as ISO C.
The normative part is the same as X3.159-1989, American National
Standard for Information Systems - Programming Language C, also known
as ANSI C.
1.5.2 Selecting a Standard
You can define a feature-test macro to select each standard. You can do
this either with a
#define
preprocessor directive in your C source before the inclusion of any
header file, or with the /DEFINE qualifier on the CC command line.
Table 1-4 lists and describes the DEC C RTL feature-test macros
that control standards support.
macro)
Table 1-4 Feature Test Macros - Standards
Macro Name |
Standard Selected |
Other Standards Implied |
Description |
_xopen_source_extended
|
XPG4 V2
|
XPG4, ISO POSIX-2, ISO POSIX-1, ANSI C
|
Makes visible XPG4-extended features, including traditional UNIX-based
interfaces not previously adopted by X/Open.
|
_xopen_source
|
XPG4
|
ISO POSIX-2, ISO POSIX-1, ANSI C
|
Makes visible XPG4 standard symbols and causes
_posix_c_source
to be set to 2 if it is not already defined with a value greater than 2.
1,
2
|
_posix_c_source
:=,=199506
|
IEEE 1003.1c-1995
|
ISO POSIX-2, ISO POSIX-1, ANSI C
|
Header files defined by ANSI C make visible those symbols required by
IEEE 1003.1c-1995.
|
_posix_c_source
:=,= 2
|
ISO POSIX-2
|
ISO POSIX-1, ANSI C
|
Header files defined by ANSI C make visible those symbols required by
ISO POSIX-2 plus those required by ISO POSIX-1.
|
_posix_c_source
:=,= 1
|
ISO POSIX-1
|
ANSI C
|
Header files defined by ANSI C make visible those symbols required by
ISO POSIX-1.
|
__stdc_version__
:=,=199409
|
ISO C amdt 1
|
ANSI C
|
Makes ISO C amendment 1 symbols visible.
|
_ansi_c_source
|
ANSI C
|
---
|
Makes ANSI C standard symbols visible.
|
1Where the ISO C Amendment 1 includes symbols not specified
by XPG4, defining __stdc_version__ :=,=
199409 and _xopen_source (or _xopen_source_extended) selects both ISO C and
XPG4 APIs. Conflicts that arise when compiling with both XPG4 and ISO C
Amendment 1 resolve in favor of ISO C Amendment 1.
2Where XPG4 extends the ISO C Amendment 1, defining _xopen_source or _xopen_source_extended selects ISO C APIs as
well as the XPG4 extensions available in the header file. This mode of
compilation makes XPG4 extensions visible.
Features not defined by one of the previously named standards are
considered DEC C extensions and are selected by not defining any
standards-related, feature-test macros.
If you do not explicitly define feature test macros to control header
file definitions, you implicitly include all defined symbols as well as
DEC C extensions.
1.5.3 Interactions with the /STANDARD Qualifier
The /STANDARD qualifier selects the dialect of the C language supported.
With the exception of /STANDARD=ANSI89 and /STANDARD=ISOC94, the
selection of C dialect and the selection of DEC C RTL APIs to use are
independent choices. All other values for /STANDARD cause the entire
set of APIs to be available, including extensions.
Specifying /STANDARD=ANSI89 restricts the default API set to the ANSI C
set. In this case, to select a broader set of APIs, you must also
specify the appropriate feature-test macro. To select the ANSI C
dialect and all APIs, including extensions, undefine
__hide_forbidden_names
before including any header file.
Compiling with /STANDARD=ISOC94 sets
__stdc_version__
to 199409. Conflicts that arise when compiling with both XPG4 and ISO C
Amendment 1 resolve in favor of ISO C Amendment 1. XPG4 extensions to
ISO C Amendment 1 are selected by defining
_xopen_source
.
The following examples help clarify these rules:
- The
fdopen
function is an ISO POSIX-1 extension to
<stdio.h>
. Therefore,
<stdio.h>
defines
fdopen
only if one or more of the following is true:
- The program including it is not compiled in strict ANSI C mode
(/STANDARD=ANSI89).
-
_posix_c_source
is defined as 1 or greater.
-
_xopen_source
is defined.
-
_xopen_source_extended
is defined.
- The
popen
function is an ISO POSIX-2 extension to
<stdio.h>
. Therefore,
<stdio.h>
defines
popen
only if one or more of the following is true:
- The program including it is not compiled in strict ANSI C mode
(/STANDARD=ANSI89).
-
_posix_c_source
is defined as 2 or greater.
-
_xopen_source
is defined.
-
_xopen_source_extended
is defined.
- The
getw
function is an X/Open extension to
<stdio.h>
. Therefore,
<stdio.h>
defines
getw
only if one or more of the following is true:
- The program is not compiled in strict ANSI C mode
(/STANDARD=ANSI89).
-
_xopen_source
is defined.
-
_xopen_source_extended
is defined.
- The X/Open Extended symbolic constants _SC_PAGESIZE, _SC_PAGE_SIZE,
_SC_ATEXIT_MAX, and _SC_IOV_MAX were added to
<unistd.h>
to support the
sysconf
function. However, these constants are not defined by
_posix_c_source
.
The
<unistd.h>
header file defines these constants only if a program does not define
_posix_c_source
and does define
_xopen_source_extended
.
If
_posix_c_source
is defined, these constants are not visible in
<unistd.h>
. Note that
_posix_c_source
is defined only for programs compiled in strict ANSI C mode.
- The
fgetname
function is a DEC C RTL extension to
<stdio.h>
. Therefore,
<stdio.h>
defines
fgetname
only if the program is not compiled in strict ANSI C mode
(/STANDARD=ANSI89).
- The macro _PTHREAD_KEYS_MAX is defined by POSIX 1003.1c-1995. This
macro is made visible in
<limits.h>
when compiling for this standard with
_posix_c_source
:=,= 199506 defined, or by default when compiling without any
standards-defining, feature-test macros.
- The macro WCHAR_MAX defined in
<wchar.h>
is required by ISO C Amendment 1 but not by XPG4. Therefore:
- Compiling for ISO C Amendment 1 makes this symbol visible, but
compiling for XPG4 compliance does not.
- Compiling for both ISO C Amendment 1 and XPG4 makes this symbol
visible.
Similarly, the functions
wcsftime
and
wcstok
in
<wchar.h>
are defined slightly differently by the ISO C Amendment 1 and XPG4:
- Compiling for ISO C Amendment 1 makes the ISO C Amendment 1
prototypes visible.
- Compiling for XPG4 compliance makes the XPG4 prototypes visible.
- Compiling for both ISO C Amendment 1 and XPG4 selects the ISO C
prototypes because conflicts resulting from this mode of compilation
resolve in favor of ISO C.
- Compiling without any standard selecting feature test macros makes
ISO C Amendment 1 features visible.
So in this example, compiling with no standard-selecting
feature-test macros makes WCHAR_MAX and the ISO C Amendment 1
prototypes for
wcsftime
and
wcstok
visible.
- The
wcswidth
and
wcwidth
functions are XPG4 extensions to ISO C Amendment 1. Their prototypes
are in
<wchar.h>
.
These symbols are visible if:
- Compiling for XPG4 compliance by defining
_xopen_source
or
_xopen_source_extended.
- Compiling for DEC C Version 4.0 compatibility or on pre-OpenVMS
Version 7.0 systems.
- Compiling with no standard selecting feature test macros.
- Compiling for both ISO C Amendment 1 and XPG4 compilance because
these symbols are XPG4 extensions to ISO C Amendment 1.
Compiling for strict ISO C Amendment 1 does not make them visible.
1.5.4 Multiple-Version-Support Macro
By default, the header files enable APIs in the DEC C RTL provided by
the version of the operating system on which the compilation occurs.
This is accomplished by the predefined setting of the
__vms_ver
macro, as described in the DEC C User's Guide for OpenVMS Systems. For example, compiling on
OpenVMS Version 6.2 causes only DEC C RTL APIs from Version 6.2 and
earlier to be made available.
Another example of the use of the
__vms_ver
macro is support for the 64-bit versions of DEC C RTL functions
available with OpenVMS Alpha Version 7.0 and higher. In all header
files, functions that provide 64-bit support are conditionalized so
that they are visible only if
__vms_ver
indicates a version of OpenVMS that is greater than or equal to 7.0.
To target an older version of the operating system, do the following:
- Define a logical DECC$SHR to point to the old version of DECC$SHR.
The compiler uses a table from DECC$SHR to perform routine name
prefixing.
- Define
__vms_ver
appropriately, either with the /DEFINE qualifier or with a combination
of the
#undef
and
#define
preprocessor directives. With /DEFINE, you may need to disable the
warning regarding redefinition of a predefined macro.
Targeting a newer version of the operating system might not always be
possible. For some versions, you can expect that the new DECC$SHR.EXE
will require new features of the operating system that are not present.
For such versions, the defining if the logical DECC$SHR in Step 1 would
cause the compilation to fail.
1.5.5 Compatibility Modes
The following predefined macros are used to select header-file
compatibility with previous versions of DEC C or the OpenVMS operating
system:
-
_decc_v4_source
-
_vms_v6_source
There are two types of incompatibilities that can be controlled in the
header files:
- To conform to standards, some changes are source-code incompatible
but binary compatible. To select DEC C Version 4.0 source
compatibility, use the
_decc_v4_source
macro.
- Other changes to conform to standards introduce a binary or
run-time incompatibility.
In general, programs that recompile get
new behaviors.
In these cases, use the
_vms_v6_source
feature test macro to retain previous behaviors.
However, for the
exit
,
kill
, and
wait
functions, the OpenVMS Version 7.0 changes to make these routines ISO
POSIX-1 compliant were considered too incompatible to become the
default. Therefore, in these cases the default behavior is the same as
on pre-OpenVMS Version 7.0 systems. To access the versions of these
routines that comply with ISO POSIX-1, use the
_posix_exit
feature test macro.
The following examples help clarify the use of these macros:
- To conform to the ISO POSIX-1 standard,
typedefs
for the following have been added to
<types.h>
:
-
dev_t
-
gid_t
-
ino_t
-
mode_t
-
nlink_t
-
off_t
-
pid_t
-
size_t
-
ssize_t
-
uid_t
Previous development environments using a version of DEC C earlier
than Version 5.2 may have compensated for the lack of these
typedef
s in
<types.h>
by adding them to another module. If this is the case on your system,
then compiling with the
<types.h>
provided with DEC C Version 5.2 might cause compilation errors.
To
maintain your current environment and include the DEC C Version 5.2
<types.h>
, then compile with
_decc_v4_source
defined. This will omit incompatible references from the DEC C Version
5.2 headers. In
<types.h>
, for example, the previously listed
typedefs
will not be visible.
- As of OpenVMS Version 7.0, the DEC C RTL
getuid
and
geteuid
functions are defined to return an OpenVMS UIC (user identification
code) that contains both the group and member portions of the UIC. In
previous versions of the DEC C RTL, these functions returned only the
member number from the UIC code.
Note that the prototypes for
getuid
and
geteuid
in
<unistd.h>
(as required by the ISO POSIX-1 standard) and in
<unixlib.h>
(for DEC C RTL compatibility) have not changed. By default, newly
compiled programs that call
getuid
and
geteuid
get the new definitions. That is, these functions will return an
OpenVMS UIC.
To let programs retain the pre-OpenVMS Version 7.0
behavior of
getuid
and
geteuid
, compile with the
_vms_v6_source
feature-test macro defined.
- As of OpenVMS Version 7.0, the DEC C RTL
exit
function is defined with ISO POSIX-1 semantics. As a result, the input
status argument to
exit
takes a number between 0 and 255. (Prior to this,
exit
could take an OpenVMS condition code in its status parameter.)
By
default, the behavior for
exit
on OpenVMS systems is the same as before ---
exit
accepts an OpenVMS condition code. To enable the ISO POSIX-1 compatible
exit
function, compile with the
_posix_exit
feature-test macro defined.
1.5.6 Curses and Socket Compatibility Macros
The following feature-test macros are used to control the curses and
socket subsets of the DEC C RTL library:
-
_bsd44_curses
This macro selects the curses package from the 4.4BSD Berkeley
Software Distribution.
-
_vms_curses
This macro selects a curses package based on the VAX C compiler
from Digital. This is the default curses package.
-
_sockaddr_len
This macro is used to select 4.4BSD-compatible and XPG4
V2-compatible socket interfaces. These interfaces require support in
your underlying TCP/IP software. Contact your TCP/IP vendor to inquire
if the version of TCP/IP software you run supports 4.4BSD sockets.
Strict XPG4 V2 compliance requires the 4.4BSD-compatible socket
interface. Therefore, if
_xopen_source_extended
is defined on OpenVMS Version 7.0 or higher,
_sockaddr_len
is defined to be 1.
The following examples help clarify the use of these macros:
- Symbolic constants like AE, AL, AS, AM, BC, which represent
pointers to termcap fields used by the BSD curses package, are only
visible in
<curses.h>
if
_bsd44_curses
is defined.
- The
<socket.h>
header file defines a 4.4BSD
sockaddr
structure only if
_sockaddr_len
or
_xopen_source_extended
is defined. Otherwise,
<socket.h>
defines a pre-4.4BSD
sockaddr
structure. If
_sockaddr_len
is defined and
_xopen_source_extended
is not defined,
The
<socket.h>
header file also defines an
osockaddr
structure, which is a 4.3BSD
sockaddr
structure to be used for compatibility purposes. Since XPG4 V2 does not
define an
osockaddr
structure, it is not visible in
_xopen_source_extended
mode.
1.6 Input and Output on OpenVMS Systems
After you learn how to link with the DEC C RTL and call
DEC C functions and macros, you can use the DEC C RTL for
its primary purpose: input/output (I/O).
Since every system has different methods of I/O, familiarize yourself
with the OpenVMS-specific methods of file access. In this way, you will
be equipped to predict functional differences when porting your source
program from one operating system to another.
Figure 1-2 shows the I/O methods available with the DEC C RTL.
The OpenVMS system services communicate directly with the OpenVMS
operating system, so they are closest to the operating system. The
OpenVMS Record Management Services (RMS) functions use the system
services, which manipulate the operating system. The DEC C
Standard I/O and UNIX I/O functions and macros use the RMS functions.
Since the DEC C RTL Standard I/O and UNIX I/O functions and macros
must go through several layers of function calls before the system is
manipulated, they are furthest from the operating system.
Figure 1-2 I/O Interface from C Programs
The C programming language was developed on the UNIX operating system,
and the Standard I/O functions were designed to provide a convenient
method of I/O that would be powerful enough to be efficient for most
applications, and also be portable so that the functions could be used
on any system running C language compilers.
The DEC C RTL adds functionality to this original specification.
Since, as implemented in the DEC C RTL, the Standard I/O functions
recognize line terminators, the DEC C RTL Standard I/O functions
are particularly useful for text manipulation. The DEC C RTL also
implements some of the Standard I/O functions as preprocessor defined
macros.
In a similar manner, the UNIX I/O functions originally were designed to
provide a more direct access to the UNIX operating systems. These
functions were meant to use a numeric file descriptor to represent a
file. A UNIX system represents all peripheral devices as files to
provide a uniform method of access.
The DEC C RTL adds functionality to the original specification. The
UNIX I/O functions, as implemented in DEC C, are particularly
useful for manipulating binary data. The DEC C RTL also implements
some of the UNIX I/O functions as preprocessor defined macros.
The DEC C RTL includes the Standard I/O functions that should exist
on all C compilers, and also the UNIX I/O functions to maintain
compatibility with as many other implementations of C as possible.
However, both Standard I/O and UNIX I/O use RMS to access files. To
understand how the Standard I/O and UNIX I/O functions manipulate RMS
formatted files, learn the fundamentals of RMS. See Section 1.6.1 for
more information about Standard I/O and UNIX I/O in relationship to RMS
files. For an introduction to RMS, see the Guide to OpenVMS File Applications.
Before deciding which method is appropriate for you, first ask this
question: Are you concerned with UNIX compatibility or with developing
code that will run solely under the OpenVMS operating system?
- If UNIX compatibility is important, you probably want to use the
highest levels of I/O---Standard I/O and UNIX I/O---because that level
is largely independent of the operating system. Also, the highest level
is easier to learn quickly, an important consideration if you are a new
programmer.
- If UNIX compatibility is not important to you or if you require the
sophisticated file processing that the Standard I/O and UNIX I/O
methods do not provide, you might find RMS desirable.
If you are writing system-level software, you may need to access the
OpenVMS operating system directly through calls to system services. For
example, you may need to access a user-written device driver directly
through the Queue I/O Request System Service ($QIO). To do this, use
the OpenVMS level of I/O; this level is recommended if you are an
experienced OpenVMS programmer. For examples of programs that call
OpenVMS system services, see the DEC C User's Guide for OpenVMS Systems.
You may never use the RMS or the OpenVMS system services. The Standard
I/O and UNIX I/O functions are efficient enough for a large number of
applications. Figure 1-3 shows the dependency of the Standard I/O
and the UNIX I/O functions on RMS, and the various methods of I/O
available to you.
Figure 1-3 Mapping Standard I/O and UNIX I/O to RMS