[an error occurred while processing this directive]

HP OpenVMS Systems Documentation

HP C

HP C
Run-Time Library Reference Manual for OpenVMS Systems

Contents

Index

With DECC$NO_ROOTED_SEARCH_LISTS enabled:

If a logical is detected in a file specification, and it is a search list, then a colon (:) is appended when forming the OpenVMS file specification.
If it is not a search list, the behavior is the same as with DECC$NO_ROOTED_SEARCH_LISTS disabled.

Enabling this feature logical provides the pre-Version 7.3-1 behavior for search list logicals.

With DECC$NO_ROOTED_SEARCH_LISTS disabled:

If a logical is detected in a file specification, and it is a rooted logical (or a search list whose first element is a rooted logical), then ":[000000]" is appended when forming the OpenVMS file specification.
If it is a nonrooted logical (or a search list whose first element is a nonrooted logical), then just a colon (:) is appended.

Disabling this feature logical provides the behavior for OpenVMS Version 7.3-1 and later.

DECC$PIPE_BUFFER_SIZE

The system default buffer size of 512 bytes for pipe write operations can limit performance and generate extra line feeds when handling messages longer than 512 bytes.

DECC$PIPE_BUFFER_SIZE allows a larger buffer size to be used for pipe functions such as pipe and popen . A value of 512 to 65535 bytes can be specified.

If DECC$PIPE_BUFFER_SIZE is not specified, the default buffer size 512 is used.

Default: 512

Minimum: 512

Maximum: 65535

DECC$PIPE_BUFFER_QUOTA

OpenVMS Version 7.3-2 adds an optional fourth argument of type int to the pipe function to specify the buffer quota of the pipe's mailbox. In previous OpenVMS versions, the buffer quota was equal to the buffer size.

DECC$PIPE_BUFFER_QUOTA lets you specify a buffer quota to use for the pipe function if the optional fourth argument of that function is omitted.

If the optional pipe fourth argument is omitted and DECC$PIPE_BUFFER_QUOTA is not defined, then the buffer quota defaults to the buffer size, as before.

Default: 512

Minimum: 512

Maximum: 2147483647

DECC$POSIX_SEEK_STREAM_FILE

With DECC$POSIX_SEEK_STREAM_FILE enabled, positioning beyond end-of-file on STREAM files does not write to the file until the next write. If the write is beyond the current end-of-file, this positions beyond the old end-of-file, and the start position for the write is filled with zeros.

With DECC$POSIX_SEEK_STREAM_FILE disabled, positioning beyond end-of-file will immediately write zeros to the file from the current end-of-file to the new position.

DECC$POSIX_STYLE_UID

With DECC$POSIX_STYLE_UID enabled, 32-bit UIDs and GIDs are interpreted as POSIX style identifiers.

With this logical name disabled, UIDs and GIDs are derived from the process UIC.

This feature is only available on OpenVMS systems providing POSIX style UID and GID support.

DECC$READDIR_DROPDOTNOTYPE

With DECC$READDIR_DROPDOTNOTYPE enabled, readdir when reporting files in UNIX style only reports the trailing period (.) for files with no file type when the file name contains a period.

With this logical name disabled, all files without a file type are reported with a trailing period.

DECC$READDIR_KEEPDOTDIR

The default behavior when reporting files in UNIX style from readdir is to report directories without a file type.

With DECC$READDIR_KEEPDOTDIR enabled, directories are reported in UNIX style with a file type of ".DIR".

DECC$RENAME_NO_INHERIT

DECC$RENAME_NO_INHERIT provides more UNIX compliant behavior in the rename function. With DECC$RENAME_NO_INHERIT enabled, the following behaviors are enforced:

If the old argument points to the pathname of a file that is not a directory, the new argument will not point to the pathname of a directory.
The new argument cannot point to a directory that exists.
If the old argument points to the pathname of a directory, the new argument will not point to the pathname of a file that is not a directory.
The new name for the file does not inherit anything from the old name. The new name must be specified completely. For example:
Renaming "A.A" to "B" yields "B"

With this logical name disabled, you get the expected OpenVMS behavior. For example:

Renaming "A.A" to "B" yields "B.A"

DECC$RENAME_ALLOW_DIR

Enabling DECC$RENAME_ALLOW_DIR restores the prior OpenVMS behavior of the rename function by allowing conversion to a directory specification when the second argument is an ambiguous file specification passed as a logical name. The ambiguity is whether the logical name is a UNIX or OpenVMS file specification. Consider the following example with DECC$RENAME_ALLOW_DIR enabled:

rename("file.ext", "logical_name")  /* where logical_name = dev:[dir.subdir] */
                                    /* and :[dir.subdir] exists              */

This results in:

dev:[dir.subdir]file.ext

This example renames a file from one directory into another directory, which is the same behavior as in legacy versions of OpenVMS (versions before 7.3-1). Also in this example, if dev:[dir.subdir] does not exist, rename returns an error.

Disabling DECC$RENAME_ALLOW_DIR provides a more UNIX compliant conversion of the "logical_name" argument of rename . Consider the following example with DECC$RENAME_ALLOW_DIR disabled:

rename("file.ext", "logical_name")   /* where logical_name = dev:[dir.subdir] */

This results in:

dev:[dir]subdir.ext

This example renames the file using the subdir part of the "logical_name" argument as the new file name because on UNIX systems, renaming a file to a directory is not allowed. So rename internally converts the "logical_name" to a file name, and dev:[dir]subdir is the most reasonable conversion it can perform.

This new feature switch has a side effect of causing rename to a directory to take precedence over rename to a file. Consider this example:

rename ( "file1.ext", "dir2" )      /* dir2 is not a logical */

With DECC$RENAME_ALLOW_DIR disabled, this example results in dir2.ext , regardless of whether or not subdirectory [.dir2] exists.

With DECC$RENAME_ALLOW_DIR enabled, this example results in dir2.ext only if subdirectory [.dir2] does not exist. If subdirectory [.dir2] does exist, the result is [.dir2]file1.ext .

Note

If DECC$RENAME_NO_INHERIT is enabled, UNIX compliant behavior is expected, so DECC$RENAME_ALLOW_DIR is ignored, and renaming a file to a directory is not allowed.

DECC$SELECT_IGNORES_INVALID_FD

With DECC$SELECT_IGNORES_INVALID_FD enabled, select fails with errno set to EBADF when an invalid file descriptor is specified in one of the descriptor sets.

With DECC$SELECT_IGNORES_INVALID_FD disabled, select ignores invalid file descriptors.

DECC$STDIO_CTX_EOL

With DECC$STDIO_CTX_EOL enabled, writing to stdout and stderr for stream access is deferred until a terminator is seen or the buffer is full.

With DECC$STDIO_CTX_EOL disabled, each fwrite generates a separate write, which for mailbox and record files generates a separate record.

DECC$STRTOL_ERANGE

With DECC$STRTOL_ERANGE enabled, the strtol behavior for an ERANGE error is corrected to consume all remaining digits in the string.

With DECC$STRTOL_ERANGE disabled, the legacy behavior of leaving the pointer at the failing digit is preserved.

DECC$THREAD_DATA_AST_SAFE

The C RTL has a mode that allocates storage for thread-specific data allocated by threads at non-AST level separate for data allocated for ASTs. In this mode, each access to thread-specific data requires a call to LIB$AST_IN_PROG, which can add significant overhead when accessing thread-specific data in the C RTL.

The alternate mode protects thread-specific data only if another function has it locked. This protects data that is in use within the C RTL, but does not protect the caller from an AST changing the data pointed to.

This latter mode is now the C RTL default for the strtok , ecvt , and fcvt functions.

You can select the legacy AST safe mode by enabling DECC$THREAD_DATA_AST_SAFE.

DECC$TZ_CACHE_SIZE

DECC$TZ_CACHE_SIZE specifies the number of time zones that can be held in memory.

Default: 2

Maximum: 2147483647

DECC$UMASK

DECC$UMASK specifies the default value for the permission mask umask . By default, a parent C program sets the umask from the RMS default permissions for the process. A child process inherits the parent's value for umask .

To enter the value as an octal value, add the leading zero; otherwise, it is translated as a decimal value. For example:

$ DEFINE DECC$UMASK 026

Maximum: 0777

DECC$UNIX_LEVEL

With the DECC$UNIX_LEVEL logical name, you can manage multiple C RTL feature logical names at once. By setting a value for DECC$UNIX_LEVEL from 1 to 100, you determine the default value for groups of feature logical names. The value you set has a cumulative effect: the higher the value, the more groups that are affected. Setting a value of 20, for example, enables all the feature logicals associated with a DECC$UNIX_LEVEL of 20, 10, and 1.

The principal logical names affecting UNIX like behavior are grouped as follows:

1 General corrections
10 Enhancements
20 UNIX style file names
30 UNIX style file attributes
90 Full UNIX behavior - No concessions to OpenVMS

Level 30 is appropriate for UNIX like programs such as BASH and GNV.

The DECC$UNIX_LEVEL values and associated groups of affected feature logical names are:

General Corrections          (DECC$UNIX_LEVEL 1)

   DECC$FIXED_LENGTH_SEEK_TO_EOF   1
   DECC$POSIX_SEEK_STREAM_FILE     1
   DECC$SELECT_IGNORES_INVALID_FD  1
   DECC$STRTOL_ERANGE              1
   DECC$VALIDATE_SIGNAL_IN_KILL    1

General Enhancements        (DECC$UNIX_LEVEL 10)

   DECC$ARGV_PARSE_STYLE           1
   DECC$EFS_CASE_PRESERVE          1
   DECC$STDIO_CTX_EOL              1
   DECC$PIPE_BUFFER_SIZE           4096
   DECC$USE_RAB64                  1

UNIX style file names       (DECC$UNIX_LEVEL 20)

   DECC$DISABLE_TO_VMS_LOGNAME_TRANSLATION 1
   DECC$EFS_CHARSET                1
   DECC$FILENAME_UNIX_NO_VERSION   1
   DECC$FILENAME_UNIX_REPORT       1
   DECC$READDIR_DROPDOTNOTYPE      1
   DECC$RENAME_NO_INHERIT          1
   DECC$GLOB_UNIX_STYLE

UNIX like file attributes     (DECC$UNIX_LEVEL 30)

   DECC$EFS_FILE_TIMESTAMPS        1
   DECC$EXEC_FILEATTR_INHERITANCE  1
   DECC$FILE_OWNER_UNIX            1
   DECC$FILE_PERMISSION_UNIX       1
   DECC$FILE_SHARING               1

UNIX compliant behavior       (DECC$UNIX_LEVEL 90)

   DECC$FILENAME_UNIX_ONLY         1
   DECC$POSIX_STYLE_UID            1
   DECC$USE_JPI$_CREATOR           1
   DECC$DETACHED_CHILD_PROCESS     1

Notes

Defining a logical name for an individual feature logical supersedes the default value established by DECC$UNIX_LEVEL for that feature.
Future revisions of the C RTL may add new feature logicals to a given DECC$UNIX_LEVEL. For applications that specify that UNIX level, the effect is to enable those new feature logicals by default.

DECC$UNIX_PATH_BEFORE_LOGNAME

With DECC$UNIX_PATH_BEFORE_LOGNAME enabled, when translating a UNIX file name not starting with a leading slash (/), an attempt is made to match this to a file or directory in the current directory. If this is not found and the name is valid as a logical name in an OpenVMS file name, an attempt is made to translate the logical name and, if found, is used as part of the resulting file name.

Enabling DECC$UNIX_PATH_BEFORE_LOGNAME overrides the setting for DECC$DISABLE_TO_VMS_LOGNAME_TRANSLATION.

DECC$USE_JPI$_CREATOR

When enabled, DECC$USE_JPI$_CREATOR determines the parent process ID in getppid by calling $GETJPI using item JPI$_CREATOR instead of JPI$_OWNER.

This feature is only available on systems supporting POSIX style session identifiers.

DECC$USE_RAB64

With DECC$USE_RAB64 enabled, open functions allocate a RAB64 structure instead of the traditional RAB structure.

This provides latent support for file buffers in 64-bit memory.

DECC$VALIDATE_SIGNAL_IN_KILL

With DECC$VALIDATE_SIGNAL_IN_KILL enabled, a signal value that is in the range 0 to _SIG_MAX but is not supported by the C RTL generates an error with errno set to EINVAL, which makes the behavior the same as for raise .

With this logical name disabled, validation of signals is restricted to checking that the signal value is in the range 0 to _SIG_MAX. If sys$sigprc fails, errno is set based on sys$sigprc exit status.

DECC$V62_RECORD_GENERATION

OpenVMS Versions 6.2 and higher can output record files using different rules.

With DECC$V62_RECORD_GENERATION enabled, the output mechanism follows the rules used for OpenVMS Version 6.2.

DECC$WRITE_SHORT_RECORDS

The DECC$WRITE_SHORT_RECORDS feature logical supports a previous change to the fwrite function (to accommodate writing records with size less than the maximum record size), while retaining the legacy way of writing records to a fixed-length file as the default behavior:

With DECC$WRITE_SHORT_RECORDS enabled, short-sized records (records with size less than the maximum record size) written at EOF are padded with zeros to align records on record boundaries. This is the behavior seen in OpenVMS Version 7.3-1 and some ACRTL ECOs of that time period.

With DECC$WRITE_SHORT_RECORDS disabled, the legacy behavior of writing records with no padding is implemented. This is the recommended and default behavior.

DECC$XPG4_STRPTIME

XPG5 support for strptime introduces pivoting year support so that years in the range 0 to 68 are in the 21st century, and years in the range 69-99 are in the 20th century.

With DECC$XPG4_STRPTIME enabled, XPG5 support for the pivoting year is disabled and all years in the range 0 to 99 are in the current century.

1.7 32-Bit UIDs/GIDs and POSIX Style Identifiers

Where supported in versions of the OpenVMS operating system, POSIX style identifiers refers to the User Identifier (UID), Group Identifier (GID), and Process Group. The scope includes real and effective identifiers.

The support for POSIX style identifiers in the HP C RTL requires 32-bit user and group ID support and also depends on features in the base version of OpenVMS. POSIX style IDs are supported by OpenVMS Version 7.3-2 and higher.

To use POSIX style identifiers on OpenVMS versions that support them requires applications to be compiled for 32-bit UID/GID. On OpenVMS versions where 32-bit UID/GID is the default, the user or application must still enable POSIX style IDs by defining the DECC$POSIX_STYLE_UID feature logical name:

$ DEFINE DECC$POSIX_STYLE_UID ENABLE

With POSIX style IDs enabled, at compile time you can selectively invoke the traditional (UIC-based) definition for an individual function by explicitly calling it by its decc$ -prefixed entry point (as opposed to the decc$__long_gid_ -prefixed entry point, which provides the POSIX style behavior).

To disable POSIX style IDs:

$ DEFINE DECC$POSIX_STYLE_UID DISABLE

OpenVMS Version 7.3-2 and higher supports POSIX style IDs as well as 32-bit UID/GIDs. When an application is compiled to use 32-bit UID/GIDs, the UID and GID are derived from the UIC as in previous versions of the operating system. In some cases, such as with the getgroups function, more information may be returned when the application supports 32-bit GIDs.

To compile an application for 32-bit UID/GID support, define the macro __USE_LONG_GID_T . To compile an application for 16-bit UID/GID support, define the macro _DECC_SHORT_GID_T .

1.8 Input and Output on OpenVMS Systems

After you learn how to link with the HP C RTL and call HP C functions and macros, you can use the HP 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 HP 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 HP C Standard I/O and UNIX I/O functions and macros use the RMS functions. Since the HP 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 HP C RTL adds functionality to this original specification. Since, as implemented in the HP C RTL, the Standard I/O functions recognize line terminators, the HP C RTL Standard I/O functions are particularly useful for text manipulation. The HP 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 HP C RTL adds functionality to the original specification. The UNIX I/O functions, as implemented in HP C, are particularly useful for manipulating binary data. The HP C RTL also implements some of the UNIX I/O functions as preprocessor-defined macros.

The HP 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.8.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 HP 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

1.8.1 RMS Record and File Formats

To understand the capabilities and the restrictions of the Standard I/O and UNIX I/O functions and macros, you need to understand OpenVMS Record Management Services (RMS).

RMS supports the following file organizations:

Sequential
Relative
Indexed

Sequential files have consecutive records with no empty records in between; relative files have fixed-length cells that may or may not contain a record; and indexed files have records that contain data, carriage-control information, and keys that permit various orders of access.

The HP C RTL functions can access only sequential files. If you wish to use the other file organizations, you must use the RMS functions. For more information about the RMS functions, see the HP C User's Guide for OpenVMS Systems.

RMS is not concerned with the contents of records, but it is concerned about the record format, which is the way a record physically appears on the recording surface of the storage medium.

RMS supports the following record formats:

Fixed-length
Variable-length
Variable with fixed-length control (VFC)
Stream

You can specify a fixed-length record format at the time of file creation. This means that all records occupy the same amount of space in the file. You cannot change the record format once you create the file.

The length of records in variable-length, VFC, and stream file formats can vary up to a maximum size that must be specified when you create the file. With variable-length record or VFC format files, the size of the record is held in a header section at the beginning of the data record. With stream files, RMS terminates the records when it encounters a specific character, such as a carriage-control or line-feed character. Stream files are useful for storing text.

RMS allows you to specify carriage-control attributes for records in a file. Such attributes include the implied carriage-return or the Fortran formatted records. RMS interprets these carriage controls when the file is output to a terminal, a line printer, or other device. The carriage-control information is not stored in the data records.

By default, files inherit the RMS record format, maximum record size and record attributes, from the previous version of the file, if one exists; to an OpenVMS system programmer, the inherited attributes are known as FAB$B_RFM, FAB$W_MRS and FAB$B_RAT. If no previous versions exist, the newly created file defaults to stream format with line-feed record separator and implied carriage-return attributes. (This manual refers to this type of file as a stream file.) You can manipulate stream files using the Standard I/O and the UNIX I/O functions of the HP C RTL. When using these files and fixed-record files with no carriage control, there is no restriction on the ability to seek to any random byte of the file using the fseek or the lseek functions. However, if the file has one of the other RMS record formats, such as variable-length record format, then these functions, due to RMS restrictions, can seek only to record boundaries. Use the default VAX stream format unless you need to create or access files to be used with other VAX languages or utilities.