Compaq C
Compaq C
User's Guide for OpenVMS Systems
6.2.1.8 Allocate Bytes from Stack ( __ALLOCA)
The __ALLOCA function allocates n bytes from the stack.
This function has the following format:
void *__ALLOCA (unsigned int n);
|
n
The number of bytes to be allocated.
A pointer to the allocated memory is returned.
6.2.1.9 AND Atomic Longword ( __AND_ATOMIC_LONG)
The __AND_ATOMIC_LONG function performs a bit-wise or arithmetic AND of
the specified expression with the aligned longword pointed to by the
address parameter within a load-locked/store-conditional code sequence.
This function has the following format:
int __AND_ATOMIC_LONG (void *address, int expression, ...);
|
address
The longword-aligned address of the data segment.
expression
An integer expression.
...
An optional retry count of type
int
. If specified, the retry count indicates the number of times the
operation is attempted (which will be at least once, even if the count
argument is 0). If the operation cannot be performed successfully in
the specified number of retries, a value of 0 is returned. If the
operation is successful, a value of 1 is returned.
Note
If the optional retry count is omitted, this function loops back for a
retry unconditionally on failure. In this case, the function can never
return a failure value. It either returns a value of 1 upon successful
completion, or hangs in an endless failure loop.
|
6.2.1.10 AND Atomic Quadword ( __AND_ATOMIC_QUAD)
The __AND_ATOMIC_QUAD function performs a bit-wise or arithmetic AND of
the specified expression with the aligned quadword pointed to by the
address parameter within a load-locked/store-conditional code sequence.
This function has the following format:
int __AND_ATOMIC_QUAD (void *address, int expression, ...);
|
address
The address of the aligned quadword.
expression
An integer expression.
...
An optional retry count of type
int
. If specified, the retry count indicates the number of times the
operation is attempted (which will be at least once, even if the count
argument is 0). If the operation cannot be performed successfully in
the specified number of retries, a value of 0 is returned. If the
operation is successful, a value of 1 is returned.
Note
If the optional retry count is omitted, this function loops back for a
retry unconditionally on failure. In this case, the function can never
return a failure value. It either returns a value of 1 upon successful
completion, or hangs in an endless failure loop.
|
6.2.1.11 Atomic Add Longword (__ATOMIC_ADD_LONG)
The __ATOMIC_ADD_LONG function adds the specified expression to the
aligned longword pointed to by the address parameter within a
load-locked/store-conditional code sequence and returns the value of
the longword before the addition was performed.
This function has one of the following formats:
int __ATOMIC_ADD_LONG (volatile void *address, int expression);
int __ATOMIC_ADD_LONG_RETRY (volatile void *address, int expression,
int retry, int *status);
|
address
The longword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the longword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.12 Atomic Add Quadword (__ATOMIC_ADD_QUAD)
The __ATOMIC_ADD_QUAD function adds the specified expression to the
aligned quadword pointed to by the address parameter within a
load-locked/store-conditional code sequence and returns the value of
the quadword before the addition was performed.
This function has one of the following formats:
__int64 __ATOMIC_ADD_QUAD (volatile void *address, __int64 expression);
__int64 __ATOMIC_ADD_QUAD_RETRY (volatile void *address, __int64 expression,
int retry, int *status);
|
address
The quadword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the quadword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.13 Atomic AND Longword (__ATOMIC_AND_LONG)
The __ATOMIC_AND_LONG function performs a bit-wise or arithmetic AND of
the specified expression with the aligned longword pointed to by the
address parameter within a load-locked/store-conditional code
sequence and returns the value of the longword before the operation was
performed.
This function has one of the following formats:
int __ATOMIC_AND_LONG (volatile void *address, int expression);
int __ATOMIC_AND_LONG_RETRY (volatile void *address, int expression,
int retry, int *status);
|
address
The longword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the longword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.14 Atomic AND Quadword (__ATOMIC_AND_QUAD)
The __ATOMIC_AND_QUAD function performs a bit-wise or arithmetic AND of
the specified expression with the aligned quadword pointed to by the
address parameter within a load-locked/store-conditional code
sequence and returns the value of the quadword before the operation was
performed.
This function has one of the following formats:
__int64 __ATOMIC_AND_QUAD (volatile void *address, __int64 expression);
__int64 __ATOMIC_AND_QUAD_RETRY (volatile void *address, __int64 expression,
int retry, int *status);
|
address
The quadword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the quadword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.15 Atomic OR Longword (__ATOMIC_OR_LONG)
The __ATOMIC_OR_LONG function performs a bit-wise or arithmetic OR of
the specified expression with the aligned longword pointed to by the
address parameter within a load-locked/store-conditional code
sequence and returns the value of the longword before the operation was
performed.
This function has one of the following formats:
int __ATOMIC_OR_LONG (volatile void *address, int expression);
int __ATOMIC_OR_LONG_RETRY (volatile void *address, int expression,
int retry, int *status);
|
address
The longword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the longword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.16 Atomic OR Quadword (__ATOMIC_OR_QUAD)
The __ATOMIC_OR_QUAD function performs a bit-wise or arithmetic OR of
the specified expression with the aligned quadword pointed to by the
address parameter within a load-locked/store-conditional code
sequence and returns the value of the quadword before the operation was
performed.
This function has one of the following formats:
__int64 __ATOMIC_OR_QUAD (volatile void *address, __int64 expression);
__int64 __ATOMIC_OR_QUAD_RETRY (volatile void *address, __int64 expression,
int retry, int *status);
|
address
The quadword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the quadword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.17 Atomic Increment Longword (__ATOMIC_INCREMENT_LONG)
The __ATOMIC_INCREMENT_LONG function increments by 1 the aligned
longword pointed to by the address parameter within a
load-locked/store-conditional code sequence and returns the value of
the longword before the operation was performed.
This function has the following format:
int __ATOMIC_INCREMENT_LONG (volatile void *address);
|
address
The longword-aligned address of the data segment.
6.2.1.18 Atomic Increment Quadword (__ATOMIC_INCREMENT_QUAD)
The __ATOMIC_INCREMENT_QUAD function increments by 1 the aligned
quadword pointed to by the address parameter within a
load-locked/store-conditional code sequence and returns the value of
the quadword before the operation was performed.
This function has the following format:
__int64 __ATOMIC_INCREMENT_QUAD (volatile void *address);
|
address
The quadword-aligned address of the data segment.
6.2.1.19 Atomic Decrement Longword (__ATOMIC_DECREMENT_LONG)
The __ATOMIC_DECREMENT_LONG function decrements by 1 the aligned
longword pointed to by the address parameter within a
load-locked/store-conditional code sequence and returns the value of
the longword before the operation was performed.
This function has the following format:
int __ATOMIC_DECREMENT_LONG (volatile void *address);
|
address
The longword-aligned address of the data segment.
6.2.1.20 Atomic Decrement Quadword (__ATOMIC_DECREMENT_QUAD)
The __ATOMIC_DECREMENT_QUAD function decrements by 1 the aligned
quadword pointed to by the address parameter within a
load-locked/store-conditional code sequence and returns the value of
the quadword before the operation was performed.
This function has the following format:
__int64 __ATOMIC_DECREMENT_QUAD (volatile void *address);
|
address
The quadword-aligned address of the data segment.
6.2.1.21 Atomic Exchange Longword (__ATOMIC_EXCH_LONG)
The __ATOMIC_EXCH_LONG function stores the value of the specified
expression into the aligned longword pointed to by the address
parameter within a load-locked/store-conditional code sequence and
returns the value of the longword before the operation was performed.
This function has one of the following formats:
int __ATOMIC_EXCH_LONG (volatile void *address, int expression);
int __ATOMIC_EXCH_LONG_RETRY (volatile void *address, int expression,
int retry, int *status);
|
address
The longword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the longword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.22 Atomic Exchange Quadword (__ATOMIC_EXCH_QUAD)
The __ATOMIC_EXCH_QUAD function stores the value of the specified
expression into the aligned quadword pointed to by the address
parameter within a load-locked/store-conditional code sequence and
returns the value of the quadword before the operation was performed.
This function has one of the following formats:
__int64 __ATOMIC_EXCH_QUAD (volatile void *address, __int64 expression);
__int64 __ATOMIC_EXCH_QUAD_RETRY (volatile void *address, __int64 expression,
int retry, int *status);
|
address
The quadword-aligned address of the data segment.
expression
An integer expression.
retry
A retry count of type
int
that indicates the number of times the operation is attempted (which is
at least once, even if the retry argument is 0). If the
operation cannot be performed successfully in the specified number of
retries, the function returns without updating the quadword.
status
A pointer to an integer that is set to 0 if the operation did not
succeed within the specified number of retries, and set to 1 if the
operation succeeded.
Note
The non-RETRY form of this function loops back for a retry
unconditionally on failure. This means this function can hang in an
endless failure loop.
|
6.2.1.23 Compare Store Longword ( __CMP_STORE_LONG)
The __CMP_STORE_LONG function has the following format:
int __CMP_STORE_LONG (volatile void *source, int old_value,
int new_value, volatile void *dest);
|
This function performs a conditional atomic compare and update
operation involving one or two longwords in the same lock region. The
value pointed to by source is compared with the longword
old_value. If they are equal, the longword new_value
is conditionally stored into the value pointed to by dest.
The store will not complete if the compare yields unequal values or if
there is an intervening store to the lock region involved. To be in the
same lock region, source and dest must point to
aligned longwords in the same naturally aligned 16-byte region.
The function returns 0 if the store does not complete, and returns 1 if
the store does complete.
6.2.1.24 Compare Store Quadword ( __CMP_STORE_QUAD)
The __CMP_STORE_QUAD function has the following format:
int __CMP_STORE_QUAD (volatile void *source, int64 old_value,
int64 new_value, volatile void *dest);
|
This function performs a conditional atomic compare and update
operation involving one or two quadwords in the same lock region. The
value pointed to by source is compared with the quadword
old_value. If they are equal, the quadword new_value
is conditionally stored into the value pointed to by dest.
The store will not complete if the compare yields unequal values or if
there is an intervening store to the lock region involved. To be in the
same lock region, source and dest must point to
aligned quadwords in the same naturally aligned 16-byte region.
The function returns 0 if the store does not complete, and returns 1 if
the store does complete.
6.2.1.25 Convert G_Floating to F_Floating Chopped ( __CVTGF_C)
The __CVTGF_C function converts a double-precision, VAX
G_floating-point number to a single-precision, VAX
F_floating-point number. This conversion chops to single-precision;
then the 8-bit exponent range is checked for overflow or underflow.
This function has the following format:
float __CVTGF_C (double operand);
|
operand
A double-precision, VAX floating-point number.
|
