HP OpenVMS Systems Documentation

The C RTL supports an X/Open standard-compliant definition of the stat structure and associated definitions. To use these new definitions, applications must compile with the _USE_STD_STAT feature-test macro defined. Use of _USE_STD_STAT specifies long (32-bit) GIDs.

When compiled with _USE_STD_STAT, the stat structure includes these changes:

• Type ino_t is defined as an unsigned quadword int . Without _USE_STD_STAT, it is an unsigned short .
• Type dev_t is defined as a 64-bit integer. Without _USE_STD_STAT, it is a 32-bit character pointer.
• Type off_t is defined as a 64-bit integer, as if the _LARGEFILE macro has been defined. Without _USE_STD_STAT, off_t is a 32-bit integer.
• Fields st_dev and st_rdev will have unique values per device. Without _USE_STD_STAT, uniqueness is not assured.
• Fields st_blksize and st_blocks are added. Without _USE_STD_STAT, these fields do not exist.

As of OpenVMS Version 8.3, to comply with the C99 ANSI standard and X/Open Specification, the _tolower and _toupper macros by default do not evaluate their parameter more than once. They simply call their respective tolower or toupper function. This avoids side effects (such as i++ or function calls) where the user can tell how many times an expression is evaluated.

To retain the older, optimized behavior of the _tolower and _toupper macros, compile with /DEFINE=_FAST_TOUPPER. Then, as in previous releases, these macros optimize the call to avoid the overhead of a runtime call. However, the macro's parameter is evaluated more than once to determine how to calculate the result, possibly creating unwanted side effects.

1.4.11 Using Faster, Inlined Put and Get Functions (INTEGRITY SERVERS, ALPHA)

Compiling with the __UNIX_PUTC macro defined enables an optimization that sets the following I/O functions to use faster, inlined functions:

fgetc 
fputc 
putc 
putchar 
fgetc_unlocked 
fputc_unlocked 
putc_unlocked 
putchar_unlocked 

The HP C and C++ Version 7.1 and higher compilers have a /MAIN=POSIX_EXIT qualifier that defines the _POSIX_EXIT macro and causes the main program to call __posix_exit instead of exit when returning from the main program.

This qualifier should be used with programs ported from UNIX that do not explicitly call exit and do not use OpenVMS specific exit codes.

For older compilers, the following sample code can be used to force the existing main module to have a different name so that a simple main program will call it but force the exit status to be through the __posix_exit call.

The replacement main function can be in a different module, so that /DEFINE="main=real_main" is all that is needed for modifying the build of the existing main function.

#define _POSIX_EXIT 1 
 
#include <stdlib.h> 
 
int real_main(int argc, char **argv); 
 
/* Make sure POSIXized exit is used */ 
int main(int argc, char **argv) 
{ 
int ret_status; 
 
   ret_status = real_main(argc, argv); 
 
exit (ret_status); 
} 
#define main real_main 

Unless your C program is intentionally using OpenVMS status codes for exit values, it is strongly recommended that both the _POSIX_EXIT macro be defined and, if needed, the /MAIN=POSIX_EXIT or the alternative main replacement be used so that DCL, BASH, and the accounting file get usable exit values.

1.5 Enabling C RTL Features Using Feature Logical Names

The C RTL provides an extensive list of feature switches that can be set using DECC$ logical names. These switches affect the behavior of a C application at run time.

The feature switches introduce new behaviors and also preserve old behaviors that have been deprecated.

You enable most features by setting a logical name to ENABLE and disable a feature by setting the logical name to DISABLE:

$ DEFINE DECC$feature ENABLE 
 
$ DEFINE DECC$feature DISABLE 

Some feature logical names can be set to a numeric value. For example:

$ DEFINE DECC$PIPE_BUFFER_SIZE 32768 

The C RTL also provides several functions to manage feature logicals within your applications:

decc$feature_get 
decc$feature_get_value 
decc$feature_get_index 
decc$feature_get_name 
decc$feature_set 
decc$feature_set_value 
decc$feature_show 
decc$feature_show_all 

See the reference section for more information on these functions.

Table 1-4 lists the C RTL feature logical names, grouped by the type of features they control.

An alphabetic listing and description of the C RTL feature logical names follows. Unless otherwise stated, the feature logicals are enabled with ENABLE and disabled with DISABLE.

DECC$ACL_ACCESS_CHECK

The DECC$ACL_ACCESS_CHECK feature logical controls the behavior of the access function.

With DECC$ACL_ACCESS_CHECK enabled, the access function checks both UIC protection and OpenVMS Access Control Lists (ACLs).

With DECC$ACL_ACCESS_CHECK disabled, the access function checks only UIC protection.

DECC$ALLOW_REMOVE_OPEN_FILES

The DECC$ALLOW_REMOVE_OPEN_FILES feature logical controls the behavior of the remove function on open files. Ordinarily, the operation fails. However, POSIX conformance dictates that the operation succeed.

With DECC$ALLOW_REMOVE_OPEN_FILES enabled, this POSIX conformant behavior is achieved.

DECC$ALLOW_UNPRIVILEGED_NICE

With DECC$ALLOW_UNPRIVILEGED_NICE enabled, the nice function exhibits its legacy behavior of not checking the privilege of the calling process (that is, any user may lower the nice value to increase process priorities). Also, when the caller sets a priority above MAX_PRIORITY, the nice value is set to the base priority.

With DECC$ALLOW_UNPRIVILEGED_NICE disabled, the nice function conforms to the X/Open standard of checking the privilege of the calling process (only users with ALTPRI privilege can lower the nice value to increase process priorities), and when the caller sets a priority above MAX_PRIORITY, the nice value is set to MAX_PRIORITY.

DECC$ARGV_PARSE_STYLE

With DECC$ARGV_PARSE_STYLE enabled, case is preserved in command-line arguments when the process has been set up for extended DCL parsing using SET PROCESS/PARSE_STYLE=EXTENDED.

DECC$ARGV_PARSE_STYLE must be defined externally as a logical name or set in a function called using the LIB$INITIALIZE mechanism because it is evaluated before function main is called.

DECC$DEFAULT_LRL

DECC$DEFAULT_LRL specifies the default value for the RMS attribute for the longest record length. The default value 32767 is the largest record size supported by RMS.

Default: 32767

Maximum: 32767

DECC$DEFAULT_UDF_RECORD

With DECC$DEFAULT_UDF_RECORD enabled, file access mode defaults to RECORD instead of STREAM mode for all files except STREAMLF.

DECC$DETACHED_CHILD_PROCESS

With DECC$DETACHED_CHILD_PROCESS enabled, child processes created using vfork and exec are created as detached processes instead of subprocesses.

This feature has only limited support. In some cases the console cannot be shared between the parent process and the detached process, which can cause exec to fail.

DECC$DISABLE_POSIX_ROOT

With DECC$DISABLE_POSIX_ROOT enabled, support for the POSIX root directory defined by SYS$POSIX_ROOT is disabled.

With DECC$DISABLE_POSIX_ROOT disabled, the SYS$POSIX_ROOT logical name is interpreted as the equivalent of the file path "/". If a UNIX path starting with a slash (/) is given and the value after the leading slash cannot be translated as a logical name, SYS$POSIX_ROOT is used as the parent directory for the specified UNIX file path.

The C RTL supports a UNIX style root that behaves like a real directory. This allows such actions as:

% cd / % mkdir /dirname % tar -xvf tarfile.tar /dirname % ls /

Previously, the C RTL did not recognize "/" as a directory name. The normal processing for a file path starting with "/" was to interpret the first element as a logical name or device name. If this failed, there was special processing for the name /dev/null and names starting with /bin and /tmp :

/dev/null NLA0: /bin SYS$SYSTEM: /tmp SYS$SCRATCH:

These behaviors are retained for compatibility purposes. In addition, support has been added to the C RTL for the logical name SYS$POSIX_ROOT as an equivalent to "/".

To enable this feature for use by the C RTL, define SYS$POSIX_ROOT as a concealed logical name. For example:

$ DEFINE/TRANSLATION=(CONCEALED,TERMINAL) SYS$POSIX_ROOT "$1$DKA0:[SYS0.abc.]"

To disable this feature:

$ DEFINE DECC$DISABLE_POSIX_ROOT DISABLE

Enabling SYS$POSIX_ROOT results in the following behavior:

• If the existing translation of a UNIX path starting with "/" fails and SYS$POSIX_ROOT is defined, the name is interpreted as if it starts with /sys$posix_root .
• When converting from an OpenVMS to a UNIX style filename, and the OpenVMS name starts with "SYS$POSIX_ROOT:", then the "SYS$POSIX_ROOT:" is removed. For example, SYS$POSIX_ROOT:[dirname] becomes /dirname . If the resulting name could be interpreted as a logical name or one of the special cases previously listed, the result is /./dirname instead of /dirname .

DECC$DISABLE_TO_VMS_LOGNAME_TRANSLATION

With DECC$DISABLE_TO_VMS_LOGNAME_TRANSLATION enabled, the conversion routine decc$to_vms will only treat the first element of a UNIX style name as a logical name if there is a leading slash (/).

DECC$EFS_CASE_PRESERVE

With DECC$EFS_CASE_PRESERVE enabled, case is preserved for filenames on ODS-5 disks.

With DECC$EFS_CASE_PRESERVE disabled, UNIX style filenames are always reported in lowercase.

However, note that enabling DECC$EFS_CASE_SPECIAL overrides the setting for DECC$EFS_CASE_PRESERVE.

DECC$EFS_CASE_SPECIAL

With DECC$EFS_CASE_SPECIAL enabled, case is preserved only for filenames containing lowercase. If an element of a filename contains all uppercase letters, it is reported in all lowercase in UNIX style.

When enabled, DECC$EFS_CASE_SPECIAL overrides the value of DECC$EFS_CASE_PRESERVE.

DECC$EFS_CHARSET

With DECC$EFS_CHARSET enabled, UNIX names can contain ODS-5 extended characters. Support includes multiple dots and all ASCII characters in the range 0 to 255, except the following:

<NUL> / * " ?

Unless DECC$FILENAME_UNIX_ONLY is enabled, some characters can be interpreted as OpenVMS characters depending on context. They are:

: ^ [ ; <

DECC$EFS_CHARSET might be necessary for existing applications that make assumptions about filenames based on the presence of certain characters, because the following nonstandard and undocumented C RTL extensions do not work when EFS extended character-set support is enabled:

• $HOME is interpreted as the user's login directory
  With DECC$EFS_CHARSET enabled, $HOME is treated literally and may be in an OpenVMS or UNIX style filename.
• ~name is interpreted as the login directory for user name
  With DECC$EFS_CHARSET enabled, ~name is treated literally and can be in an OpenVMS or UNIX style filename.
• Wild card regular expressions in the form [a-z]
  With DECC$EFS_CHARSET enabled, square brackets are acceptable in OpenVMS and UNIX style filenames. For instance, in a function such as open , abc[a-z]ef.txt is interpreted as a UNIX style name equivalent to the OpenVMS style name abc^[a-z^]ef.txt , and [a-z]bc is interpreted as an OpenVMS style name equivalent to the UNIX style name /sys$disk/a-z/bc .

With DECC$EFS_CHARSET enabled, the following encoding for EFS extended characters is supported when converting from an OpenVMS style filename to a UNIX style filename:

• All ODS-2 compatible names
• All encoding for 8-bit characters, either as single byte or using two-digit hexadecimal form ^ab . In a UNIX path these are always represented as a single byte.
• Encoding for DEL (^7F)
• The following characters when preceded by a caret:

  space ! , _ & ' ( ) + @ { } ; # [ ] % ^ = $ - ~ .

• The following characters when not preceded by a caret:

  $ - ~ .

• The implementation supports the conversion from OpenVMS to UNIX needed for functions readdir , ftw , getname , fgetname , getcwd , and others.

Note There are some special cases in C RTL filename processing. For example: Pathnames ending in ^.dir are treated as directories, and when translated, these characters are truncated from the string. Pathnames begining with ^/ treat the next token as a logical name or a directory from the root. The following sample program shows these nuances: #include <stdio.h> #include <dirent.h> #include <unixlib.h> #include <string.h> main() { char adir[80]; DIR *dir; struct dirent *dp; int decc_feature_efs_charset_index = 0; int decc_feature_efs_charset_default_val = 0; if ( ( (decc_feature_efs_charset_index = decc$feature_get_index("DECC$EFS_CHARSET")) == -1 ) || ( (decc_feature_efs_charset_default_val = decc$feature_get_value(decc_feature_efs_charset_index, 0)) == -1 ) || ( (decc$feature_set_value(decc_feature_efs_charset_index, 1, TRUE) == -1)) ) { printf("Error setting up DECC$EFS_CHARSET macro\n"); } strcpy(adir, "SYS$SYSDEVICE:[SSHTEST.TEST.a^,test^.dir^;22]"); printf("\n\nFor %s\n", adir); mrb: dir = opendir(adir); if(dir) { do { dp = readdir(dir); if(dp->d_name) printf("%s\n", dp->d_name); } while (dp); } closedir(dir); strcpy(adir, "SYS$SYSDEVICE:[SSHTEST.TEST.a^,test^.dir]"); printf("\n\nFor %s\n", adir); dir = opendir(adir); if(dir) { do { dp = readdir(dir); if(dp->d_name) printf("%s\n", dp->d_name); } while (dp); } closedir(dir); strcpy(adir, "SYS$SYSDEVICE:[SSHTEST.TEST.a^\\test]"); printf("\n\nFor %s\n", adir); dir = opendir(adir); if(dir) { do { dp = readdir(dir); if(dp->d_name) printf("%s\n", dp->d_name); } while (dp); } strcpy(adir, "SYS$SYSDEVICE:[SSHTEST.TEST.copies]"); printf("\n\nFor %s\n", adir); dir = opendir(adir); if(dir) { do { dp = readdir(dir); if(dp->d_name) printf("%s\n", dp->d_name); } while (dp); } closedir(dir); strcpy(adir, "/SYS$SYSDEVICE/SSHTEST/TEST/copies"); printf("\n\nFor %s\n", adir); dir = opendir(adir); if(dir) { do { dp = readdir(dir); if(dp->d_name) printf("%s\n", dp->d_name); } while (dp); } closedir(dir); }

DECC$EFS_FILE_TIMESTAMPS

With DECC$EFS_FILE_TIMESTAMPS enabled, stat and fstat report new ODS-5 access time ( st_atime ), attribute revision time ( st_ctime ) and modification time ( st_mtime ) for files on ODS-5 volumes that have the extended file times enabled using SET VOLUME/VOLUME=ACCESS_DATES.

If DECC$EFS_FILE_TIMESTAMPS is disabled, or the volume is not ODS-5, or the volume does not have support for these additional times enabled, st_ctime continues to be the file creation time and st_atime the same as the st_mtime .

The utime and utimes functions support these ODS-5 times in the same way as stat .

DECC$EFS_NO_DOTS_IN_DIRNAME

With support for extended characters in filenames for ODS-5, a name such as NAME.EXT can be interpreted as NAME.EXT.DIR. Determining if directory [.name^.ext] exists adds overhead to UNIX name translation when support for extended character support in UNIX filenames is enabled.

---

Previous

Next

Contents

Index