HP OpenVMS Systems Documentation
With DECC$STDIO_CTX_EOL disabled, each fwrite generates a separate write, which for mailbox and record files generates a separate record.
With DECC$STREAM_PIPE disabled, pipe uses the OpenVMS legacy record I/O. This is the default.
With DECC$STRTOL_ERANGE disabled, the legacy behavior of leaving the pointer at the failing digit is preserved.
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.
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
The principal logical names affecting UNIX like behavior are grouped as follows:
1 General corrections
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
Enabling DECC$UNIX_PATH_BEFORE_LOGNAME overrides the setting for DECC$DISABLE_TO_VMS_LOGNAME_TRANSLATION.
This feature is only available on systems supporting POSIX style session identifiers.
This provides latent support for file buffers in 64-bit memory.
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.
With DECC$V62_RECORD_GENERATION enabled, the output mechanism follows the rules used for OpenVMS Version 6.2.
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.
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 16-bit UID/GID support on systems that by
default use 32-bit UIDs/GIDs, define the _DECC_SHORT_GID_T macro to 1.
1.8 Input and Output on OpenVMS Systems
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 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
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.
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
seek to any random byte of the file using the
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.
1.8.2 Access to RMS Files
RMS sequential files can be opened in record mode or stream mode. By default, STREAM_LF files are opened in stream mode; all other file types are opened in record mode. When opening a file, you can override these defaults by specifying the optional argument "ctx=rec" to force record mode, or "ctx=stm" to force stream mode. RMS relative and indexed files are always opened in record mode. The access mode determines the behavior of various I/O functions in the HP C RTL.
One of the file types defined by RMS is an RMS-11 stream format file, corresponding to a value of FAB$C_STM for the record format. The definition of this format is such that the RMS record operation SYS$GET removes leading null bytes from each record. Because this file type is processed in record mode by the HP C RTL, it is unsuitable as a file format for binary data unless it is explicitly opened with "ctx=stm", in which case the raw bytes of data from the file are returned.
In OpenVMS Version 7.0 the default LRL value on stream files was changed from 0 to 32767. This change caused significant performance degradation on certain file operations such as sort.
This is no longer a problem. The HP C RTL now lets you define the logical DECC$DEFAULT_LRL to change the default record-length value on stream files.
The HP C RTL first looks for this logical. If it is found and it translates to a numeric value between 0 and 32767, that value is used for the default LRL.
To restore the behavior prior to OpenVMS Version 7.0, enter the following command:
Stream access to RMS files is done with the block I/O facilities of RMS. Stream input is performed from RMS files by passing each byte of the on-disk representation of the file to your program. Stream output to RMS files is done by passing each byte from your program to the file. The HP C RTL performs no special processing on the data.
When opening a file in stream mode, the HP C RTL allocates a large
internal buffer area. Data is read from the file using a single read
into the buffer area and then passing the data to your program as
needed. Data is written to the file when the internal buffer is full or
function is called.
188.8.131.52 Accessing RMS Record Files in Record Mode
Record access to record files is done with the record I/O facilities of RMS. The HP C RTL emulates a byte stream by translating carriage-control characters during the process of reading and writing records. Random access is allowed to all record files, but positioning (with fseek and lseek ) must be on a record boundary for VFC files, variable record files, or files with non-null carriage control. Positioning a record file causes all buffered input to be discarded and buffered output to be written to the file.
Record input from RMS record files is emulated by the HP C RTL in two steps:
In RMS terms, the HP C RTL translates the record's carriage-control information using one of the following methods:
As you read from the file, the HP C RTL delivers a stream of bytes resulting from the translations. Information that is not read from an expanded record by one function call is delivered on the next input function call.
The first part of the record output emulation is the formation of a logical record. As you write bytes to a record file, the emulator examines the information being written for record boundaries. The handling of information in the byte stream depends on the attributes of the destination file or device, as follows:
The second part of record output emulation is to write the logical record formed during the first step. The HP C RTL forms the output record as follows: