| Previous | Contents | Index |
When accessing a fixed-length record file in record mode, the I/O functions generally behave as described in Section 1.7.2.2.1.
The write , fwrite , and decc$record_write functions will fail if given a record size that is not an integral multiple of the maximum record size, unless the file was opened with the "ctx=xplct" optional argument specified. All other output functions will generate records at every nth byte, where n is the maximum record size.
If a new record is forced by fflush , the data in the buffer is padded to the maximum record size with null characters.
This padding can cause problems for programs that seek to the end-of-file. For example, if a program were to append data to a file, then seek backwards in the file (causing an fflush to occur), and then seek to the end-of-file again, a zero-filled "hole" will have been created between the previous end-of-file and the new end-of-file if the previous end-of-file was not on a record boundary. |
Example 1-1 demonstrates the difference between stream mode and record mode access.
| Example 1-1 Differences Between Stream Mode and Record Mode Access |
|---|
/* CHAP_1_STREAM_RECORD.C */
/* This program demonstrates the difference between */
/* record mode and stream mode input/output. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void process_records(const char *fspec, FILE * fp);
main()
{
FILE *fp;
fp = fopen("example-fixed.dat", "w", "rfm=fix", "mrs=40", "rat=none");
if (fp == NULL) {
perror("example-fixed");
exit(EXIT_FAILURE);
}
printf("Record mode\n");
process_records("example-fixed.dat", fp);
fclose(fp);
printf("\nStream mode\n");
fp = fopen("example-streamlf.dat", "w");
if (fp == NULL) {
perror("example-streamlf");
exit(EXIT_FAILURE);
}
process_records("example-streamlf.dat", fp);
fclose(fp);
}
void process_records(const char *fspec, FILE * fp)
{
int i,
sts;
char buffer[40];
/* Write records of all 1's, all 2's and all 3's */
for (i = 0; i < 3; i++) {
memset(buffer, '1' + i, 40);
sts = fwrite(buffer, 40, 1, fp);
if (sts != 1) {
perror("fwrite");
exit(EXIT_FAILURE);
}
}
/* Rewind the file and write 10 characters of A's, then 10 B's, */
/* then 10 C's. */
/* */
/* For stream mode, each fwrite call outputs 10 characters */
/* and advances the file position 10 characters */
/* characters. */
/* */
/* For record mode, each fwrite merges the 10 characters into */
/* the existing 40-character record, updates the record and */
/* advances the file position 40 characters to the next record. */
rewind(fp);
for (i = 0; i < 3; i++) {
memset(buffer, 'A' + i, 10);
sts = fwrite(buffer, 10, 1, fp);
if (sts != 1) {
perror("fwrite2");
exit(EXIT_FAILURE);
}
}
/* Now reopen the file and output the records. */
fclose(fp);
fp = fopen(fspec, "r");
for (i = 0; i < 3; i++) {
sts = fread(buffer, 40, 1, fp);
if (sts != 1)
perror("fread");
printf("%.40s\n", buffer);
}
return;
}
|
Running this program produces the following output:
Record Mode AAAAAAAAAA111111111111111111111111111111 BBBBBBBBBB222222222222222222222222222222 CCCCCCCCCC333333333333333333333333333333 Stream mode AAAAAAAAAABBBBBBBBBBCCCCCCCCCC1111111111 2222222222222222222222222222222222222222 3333333333333333333333333333333333333333 |
One of the last tasks in preparing to use the HP C RTL, if you are going to port your source programs across systems, is to be aware of specific differences between the HP C RTL and the run-time libraries of other implementations of the C language. This section describes some of the problems that you might encounter when porting programs to and from an OpenVMS system. Although portability is closely tied to the implementation of the HP C RTL, this section also contains information on the portability of other HP C for OpenVMS constructs.
The HP C RTL provides ANSI C defined library functions as well as many commonly available APIs and a few OpenVMS extensions. See Section 1.4 for specific standards, portions of which are implemented by the HP C RTL. Attempts have been made to maintain complete portability in functionality whenever possible. Many of the Standard I/O and UNIX I/O functions and macros contained in the HP C RTL are functionally equivalent to those of other implementations.
The RTL function and macro descriptions elaborate on issues presented in this section and describe concerns not documented here.
The following list documents issues of concern if you wish to port C programs to the OpenVMS environment:
int foo 123; |
int a, b, c; |
a[i] = i++; |
x = func_y() + func_z(); |
f(p++, p++) |
The HP C RTL supports an improved and enhanced reentrancy. The following types of reentrancy are supported:
For nonthreaded processes, the default reentrancy type is TOLERANT. When the threads library is loaded, the reentracy level is implicitly set to C$C_MULTITHREAD, and the application cannot change it after that.
You can set the reentrancy type by compiling with the /REENTRANCY command-line qualifier or by calling the decc$set_reentrancy function. This function must be called exclusively from non-AST level.
When programming an application using multiple threads or ASTs, consider three classes of functions:
Most functions have no internal data at all. For these functions, synchronization is necessary only if the parameter is used by the application in multiple threads or in both AST and non-AST contexts. For example, although the strcat function is ordinarily safe, the following is an example of unsafe usage:
extern char buffer[100];
void routine1(char *data) {
strcat( buffer, data );
}
|
If routine1 executed concurrently in multiple threads, or if routine1 is interrupted by an AST routine that calls it, the results of the strcat call are unpredictable.
The second class of functions are those that have thread-local static data. Typically, these are routines in the library that return a string where the application is not permitted to free the storage for the string. These routines are thread-safe but not AST-reentrant. This means they can safely be called concurrently, and each thread will have its own copy of the data. They cannot be called from AST routines if it is possible that the same routine was executing in non-AST context. The routines in this class are:
asctime stat ctermid strerror ctime strtok cuserid VAXC$ESTABLISH gmtime the errno variable localtime wcstok perror |
All the socket functions are also included in this list if the TCP/IP product in use is thread-safe.
The third class of functions are those that affect processwide data. These functions are neither thread-safe nor AST-reentrant. For example, sigsetmask establishes the processwide signal mask. Consider a routine like the following:
void update_data
base()
{
int old_mask;
old_mask = sigsetmask( 1 << (SIGINT - 1));
/* Do work here that should not be aborted. */
sigsetmask( old_mask );
}
|
If update_database was called concurrently in multiple threads, thread 1 might unblock SIGINT while thread 2 was still performing work that should not be aborted.
The routines in this class are:
Generally, UTC-based time functions can affect in-memory time-zone information, which is processwide data. However, if the system time zone remains the same during the execution of the application (which is the common case) and the cache of time-zone files is enabled (which is the default), then the _r variant of the time functions asctime_r , ctime_r , gmtime_r and localtime_r is both thread-safe and AST-reentrant. If, however, the system time zone can change during the execution of the application or the cache of time-zone files is not enabled, then both variants of the UTC-based time functions belong to the third class of functions, which are neither thread-safe nor AST-reentrant. |
Some functions remain inherently nonthread-safe regardless of the reentrancy type. They are:
execl exit execle _exit execlp nice execv system execve vfork execvp |
Mixing the multithread programming model and the OpenVMS AST programming model in the same application is not recommended. The application has no mechanism to control which thread gets interrupted by an AST. This can result in a resource deadlock if the thread holds a resource that is also needed by the AST routine. The following functions use mutexes. To avoid a potential resource deadlock, do not call them from AST functions in a multithreaded application.
This section is for application developers who need to use 64-bit virtual memory addressing on OpenVMS Alpha Version 7.0 or higher.
OpenVMS Alpha 64-bit virtual addressing support makes the 64-bit virtual address space defined by the Alpha architecture available to both the OpenVMS operating system and its users. It also allows per-process virtual addressing for accessing dynamically mapped data beyond traditional 32-bit limits.
The HP C Run-Time Library on OpenVMS Alpha Version 7.0 systems and higher includes the following features in support of 64-bit pointers:
The HP C Run-Time library on OpenVMS Alpha Version 7.0 systems and higher can generate and accept 64-bit pointers. Functions that require a second interface to be used with 64-bit pointers reside in the same object libraries and shareable images as their 32-bit counterparts. No new object libraries or shareable images are introduced. Using 64-bit pointers does not require changes to your link command or link options files.
The HP C 64-bit environment allows an application to use both 32-bit and 64-bit addresses. For more information about how to manipulate pointer sizes, see the /POINTER_SIZE qualifier and #pragma pointer_size and #pragma required_pointer_size preprocessor directives in the HP C User's Guide for OpenVMS Systems.
The /POINTER_SIZE qualifier requires you to specify a value of 32 or 64. This value is used as the default pointer size within the compilation unit. You can compile one set of modules using 32-bit pointers and another set using 64-bit pointers. Care must be taken when these two separate groups of modules call each other.
Use of the /POINTER_SIZE qualifier also influences the processing of HP C RTL header files. For those functions that have a 32-bit and 64-bit implementation, specifying /POINTER_SIZE enables function prototypes to access both functions, regardless of the actual value supplied to the qualifier. In addition, the value specified to the qualifier determines the default implementation to call during that compilation unit.
The
#pragma pointer_size
and
#pragma required_pointer_size
preprocessor directives can be used to change the pointer size in
effect within a compilation unit. You can default pointers to 32-bit
pointers and then declare specific pointers within the module as 64-bit
pointers. You would also need to specifically call the
_malloc64
form of
malloc
to obtain memory from the 64-bit memory area.
1.9.2 Obtaining 64-Bit Pointers to Memory
The HP C RTL has many functions that return pointers to newly allocated memory. In each of these functions, the application owns the memory pointed to and is responsible for freeing that memory.
Functions that allocate memory are:
malloc
calloc
realloc
strdup
Each of these functions have a 32-bit and a 64-bit implementation. When the /POINTER_SIZE qualifier is used, the following functions can also be called:
_malloc32 , _malloc64
_calloc32 , _calloc64
_realloc32 , _realloc64
_strdup32 , _strdup64
When /POINTER_SIZE=32 is specified, all malloc calls default to _malloc32 .
When /POINTER_SIZE=64 is specified, all malloc calls default to _malloc64 .
Regardless of whether the application calls a 32-bit or 64-bit memory allocation routine, there is still a single free function. This function accepts either pointer size.
Be aware that the memory allocation functions are the only ones that return pointers to 64-bit memory. All HP C RTL structure pointers returned to the calling application (such as a FILE, WINDOW, or DIR) are always 32-bit pointers. This allows both 32-bit and 64-bit callers to pass these structure pointers within the application.
| Previous | Next | Contents | Index |