/******************************************************************************
*
* NSSDC/CDF CDF Internal Interface/FORTRAN.
*
* Version 1.8b, 21-Feb-97, Hughes STX.
*
* Modification history:
*
* V1.0 30-Jan-91, J Love Original version (for CDF V2.1).
* V1.1 6-Aug-91, J Love Use 'CDFlib'. If variable is a character data
* type, check for %DESCR (if VMS).
* V1.2 24-Oct-91, J Love Modified for IBM-PC and IBM-RS6000 ports.
* V1.3 20-May-92, J Love CDF V2.2.
* V1.4 16-Sep-92, J Love CDF V2.3 (shareable/NeXT/zVar).
* V1.5 19-Jan-94, J Love CDF V2.4.
* V1.5a 4-Feb-94, J Love DEC Alpha/OpenVMS port.
* V1.5b 22-Feb-94, J Love Spelling lesson.
* V1.5c 29-Mar-94, J Love Solaris using GNU C compiler.
* V1.6 21-Dec-94, J Love CDF V2.5.
* V1.7 19-Jan-95, J Love IRIX 6.0 (64-bit).
* V1.7a 30-Jan-95, J Love `int sC' -> `Int32 sC'.
* V1.7b 13-Jun-95, J Love Linux.
* V1.8 5-Aug-96, J Love CDF V2.6 (renamed - previously `cdf_i_if.c').
* V1.8a 2-Dec-96, J Love Fixed declaration of `i' (now `int').
* V1.8b 21-Feb-97, J Love Removed RICE.
*
******************************************************************************/
/******************************************************************************
*
* Notes:
*
* For the FORTRAN interfaces everything is indexed from one (1) while for
* the C interfaces everything is indexed from zero (0) [eg. variable and
* attribute numbers, record numbers, indices, entry numbers]. For this
* reason one (1) is subtracted from arguments passed in while one (1) is
* added to arguments passed out (where appropriate).
*
* The FORTRAN interfaces use INTEGER*4 as the data type for all numerical
* values passed in/out while the C interfaces use `long'. These are the same
* on all supported platforms except the DEC Alpha (where `long' is 8 bytes).
* For this reason temporary variables/arrays of size `long' are used in the
* calls to the CDF library (the direct C interface). This causes a small
* performance loss on the other platforms mainly when reading/writing single
* values repeatly (but then the hyper reads/writes should have been used
* instead).
*
******************************************************************************/
/******************************************************************************
*
* Notes for VMS:
*
* To make the user's life a little easier, all names and attribute
* values (for attributes of data types CDF_CHAR and CDF_UCHAR) may be passed
* in and out by either reference or descriptor. The default passing mode
* for an embedded character string (e.g., CALL subr (..., 'string', ...)) or
* a CHARACTER variable symbol (e.g., CALL subr (..., ATTR_NAME, ...) where
* ATTR_NAME is defined as CHARACTER*8) is by descriptor when passing from
* FORTRAN to C in VMS.
*
* An embedded character string could be enclosed in %REF() to force
* passing by reference since the FORTRAN compiler puts a NUL character at
* the end of these strings as expected by the CDF V2.0 library (written in
* C). Enclosing a CHARACTER variable symbol in %REF() will result in
* an error, however, because a NUL character is not placed at the ends of
* these type strings by the FORTRAN compiler. The user would have to
* supply the terminating NUL. By letting the passing mode default to by-
* descriptor, this interface will supply the terminating NUL.
*
* The main difference here from CDF Version 1 is that the %REF() is
* not needed when passing out names and attribute values. Also, %REF()
* is not necessary when passing the value of a variable that is a character
* data type.
*
******************************************************************************/
/******************************************************************************
*
* Notes for UNIX:
*
* All passing between FORTRAN and C on UNIX systems is done by reference.
* When character strings are passed between FORTRAN and C, extra arguments
* are added to the argument list containing the lengths of those character
* strings (EXCEPT on NeXT machines - FORTRAN applications must NUL-terminate
* passed character strings).
*
* Entry points have been made lowercase because the FORTRAN compiler
* converts all uppercase characters to lowercase in entry points. This way
* the linker will find everything. Unix FORTRAN compilers and linkers also
* seem to like trailing '_'s (except on the IBM-RS6000/AIX, HP9000/HP-UX,
* and NeXT/Mach).
*
******************************************************************************/
/******************************************************************************
*
* Notes for Macintosh (MPW C/Fortran):
*
* In order to get the Internal Interface to work with MPW Fortran a separate
* entry point has been created for each possible number of arguments. They
* are called CDF_lib_1, CDF_lib_2,... CDF_lib_n. This is because MPW Fortran
* will not allow varying numbers of arguments to the same subroutine/function.
* An application must use CDF_lib_x when there are `x' arguments in the call.
*
******************************************************************************/
#include "cdflib.h"
/******************************************************************************
* Local function prototypes.
******************************************************************************/
static size_t PickMaxLen PROTOARGs((long requiredArgument, ...));
VISIBLE_PREFIX
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib__,cdf_lib_,cdf_lib,CDF_LIB)
VARPROTOARGs((Int32 *requiredFnc, ...));
#define CDF_LIBx Fif_ENTRYPOINT(cdf_lib__,cdf_lib_,cdf_lib,CDF_LIB)
static CDFid currentCDFid = NULL;
/******************************************************************************
* CDF_lib. Note that CDFstatus is returned both as an argument (the last
* argument) and as the value of the function.
******************************************************************************/
VISIBLE_PREFIX
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib__,cdf_lib_,cdf_lib,CDF_LIB)
#if defined(STDARG)
(Int32 *requiredFnc, ...)
#else
(va_alist)
va_dcl
#endif
{
CDFstatus pStatus = CDF_OK; /* Pending status. */
CDFstatus tStatus; /* Temporary status. */
Int32 *status; /* Address of `status' variable. */
struct VAstruct Va;
struct STRINGstruct *ssh = NULL; /* Head of STRINGstruct linked list. */
#if !defined(STDARG)
Int32 *fncP; /* Pointer to required function. */
#endif
#if defined(Fif_GHOSTLEN)
int i;
Int32 sC = 0; /* String count. Number of (possible) strings
passed in. */
Int32 *sCp; /* Pointer to string count. */
Int32 *sLs; /* Lengths of (possible) character strings passed
in - some arguments may or may not be character
strings (eg. variable/entry data). */
#endif
#if defined(Fif_GHOSTLEN)
/******************************************************************************
* Scan argument list counting number of (possible) strings passed in.
******************************************************************************/
#if defined(STDARG)
va_start (Va.ap, requiredFnc);
if (*requiredFnc == 0) {
sCp = requiredFnc;
Va.fnc = (long) *(va_arg (Va.ap, Int32 *));
}
else {
sCp = &sC;
Va.fnc = (long) *requiredFnc;
}
#else
VA_START (Va.ap);
fncP = va_arg (Va.ap, Int32 *);
if (*fncP == 0) {
sCp = fncP;
Va.fnc = (long) *(va_arg (Va.ap, Int32 *));
}
else {
sCp = &sC;
Va.fnc = (long) *fncP;
}
#endif
while (Va.fnc != NULL_) {
switch (Va.fnc) {
/**************************************************************************
* CREATE_,<item>
**************************************************************************/
case CREATE_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* CREATE_,CDF_
*******************************************************************/
case CDF_: {
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(*sCp)++;
break;
}
/*******************************************************************
* CREATE_,rVAR_
*******************************************************************/
case rVAR_: {
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(*sCp)++;
break;
}
/*******************************************************************
* CREATE_,zVAR_
*******************************************************************/
case zVAR_: {
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(*sCp)++;
break;
}
/*******************************************************************
* CREATE_,ATTR_
*******************************************************************/
case ATTR_: {
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(*sCp)++;
break;
}
/*******************************************************************
* Unknown - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* OPEN_,<item>
**************************************************************************/
case OPEN_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* OPEN_,CDF_
*******************************************************************/
case CDF_: {
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, Int32 *);
(*sCp)++;
break;
}
/*******************************************************************
* Unknown - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* DELETE_,<item>
**************************************************************************/
case DELETE_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* DELETE_,<object>
*******************************************************************/
case CDF_:
case zVAR_:
case rVAR_:
case ATTR_:
case gENTRY_:
case zENTRY_:
case rENTRY_:
break;
/*******************************************************************
* DELETE_,r|zVAR_RECORDS_
*******************************************************************/
case rVAR_RECORDS_:
case zVAR_RECORDS_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* Unknown - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* CLOSE_,<item>
**************************************************************************/
case CLOSE_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* CLOSE_,CDF_
*******************************************************************/
case CDF_: {
break;
}
/*******************************************************************
* CLOSE_,r/zVAR_
*******************************************************************/
case rVAR_:
case zVAR_: {
break;
}
/*******************************************************************
* Unknown - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* SELECT_,<item>
**************************************************************************/
case SELECT_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* SELECT_,<Int32 * or Int32 []>
*******************************************************************/
case CDF_:
case CDF_STATUS_:
case CDF_READONLY_MODE_:
case CDF_zMODE_:
case CDF_NEGtoPOSfp0_MODE_:
case CDF_DECODING_:
case CDF_CACHESIZE_:
case STAGE_CACHESIZE_:
case COMPRESS_CACHESIZE_:
case rVARs_CACHESIZE_:
case zVARs_CACHESIZE_:
case rVAR_CACHESIZE_:
case zVAR_CACHESIZE_:
case rVAR_:
case zVAR_:
case rVARs_RECNUMBER_:
case zVARs_RECNUMBER_:
case zVAR_RECNUMBER_:
case rVARs_RECCOUNT_:
case zVAR_RECCOUNT_:
case rVARs_RECINTERVAL_:
case zVAR_RECINTERVAL_:
case rVARs_DIMINDICES_:
case zVAR_DIMINDICES_:
case rVARs_DIMCOUNTS_:
case zVAR_DIMCOUNTS_:
case rVARs_DIMINTERVALS_:
case zVAR_DIMINTERVALS_:
case rVAR_RESERVEPERCENT_:
case zVAR_RESERVEPERCENT_:
case ATTR_:
case gENTRY_:
case rENTRY_:
case zENTRY_: {
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* SELECT_,<Int32 *, Int32 *>
*******************************************************************/
case rVAR_SEQPOS_:
case zVAR_SEQPOS_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* SELECT_,<void * (string)>
*******************************************************************/
case CDF_SCRATCHDIR_:
case rVAR_NAME_:
case zVAR_NAME_:
case ATTR_NAME_:
case rENTRY_NAME_:
case zENTRY_NAME_: {
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* Unknown item - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* CONFIRM_,<item>
**************************************************************************/
case CONFIRM_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* CONFIRM_,<no arguments>
*******************************************************************/
case CURgENTRY_EXISTENCE_:
case CURrENTRY_EXISTENCE_:
case CURzENTRY_EXISTENCE_:
case CDF_CHECKSUM_:
break;
/*******************************************************************
* CONFIRM_,<Int32 * or Int32 []>
*******************************************************************/
case CDF_READONLY_MODE_:
case CDF_zMODE_:
case CDF_NEGtoPOSfp0_MODE_:
case CDF_DECODING_:
case CDF_CACHESIZE_:
case STAGE_CACHESIZE_:
case COMPRESS_CACHESIZE_:
case rVAR_CACHESIZE_:
case zVAR_CACHESIZE_:
case rVAR_:
case zVAR_:
case rVARs_RECNUMBER_:
case zVAR_RECNUMBER_:
case rVARs_RECCOUNT_:
case zVAR_RECCOUNT_:
case rVARs_RECINTERVAL_:
case zVAR_RECINTERVAL_:
case rVARs_DIMINDICES_:
case zVAR_DIMINDICES_:
case rVARs_DIMCOUNTS_:
case zVAR_DIMCOUNTS_:
case rVARs_DIMINTERVALS_:
case zVAR_DIMINTERVALS_:
case rVAR_RESERVEPERCENT_:
case zVAR_RESERVEPERCENT_:
case ATTR_:
case gENTRY_:
case rENTRY_:
case zENTRY_:
case gENTRY_EXISTENCE_:
case rENTRY_EXISTENCE_:
case zENTRY_EXISTENCE_: {
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* CONFIRM_,<Int32 *, Int32 *>
*******************************************************************/
case rVAR_SEQPOS_:
case zVAR_SEQPOS_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* CONFIRM_,<void * (string)>
*******************************************************************/
case CDF_NAME_:
case rVAR_EXISTENCE_:
case zVAR_EXISTENCE_:
case ATTR_EXISTENCE_: {
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* Unknown - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* GET_,<item>
**************************************************************************/
case GET_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* GET_,<Int32 *>
*******************************************************************/
case rVARs_NUMDIMS_:
case zVAR_NUMDIMS_:
case rVARs_DIMSIZES_:
case zVAR_DIMSIZES_:
case CDF_ENCODING_:
case CDF_MAJORITY_:
case CDF_FORMAT_:
case CDF_NUMrVARS_:
case CDF_NUMzVARS_:
case CDF_NUMATTRS_:
case CDF_NUMgATTRS_:
case CDF_NUMvATTRS_:
case rVARs_MAXREC_:
case zVARs_MAXREC_:
case CDF_VERSION_:
case CDF_RELEASE_:
case CDF_INCREMENT_:
case LIB_VERSION_:
case LIB_RELEASE_:
case LIB_INCREMENT_:
case rVAR_DATATYPE_:
case zVAR_DATATYPE_:
case rVAR_NUMELEMS_:
case zVAR_NUMELEMS_:
case rVAR_RECVARY_:
case zVAR_RECVARY_:
case rVAR_DIMVARYS_:
case zVAR_DIMVARYS_:
case rVAR_MAXREC_:
case zVAR_MAXREC_:
case rVAR_MAXallocREC_:
case zVAR_MAXallocREC_:
case rVAR_NUMRECS_:
case zVAR_NUMRECS_:
case rVAR_NUMallocRECS_:
case zVAR_NUMallocRECS_:
case rVAR_BLOCKINGFACTOR_:
case zVAR_BLOCKINGFACTOR_:
case rVAR_nINDEXRECORDS_:
case zVAR_nINDEXRECORDS_:
case rVAR_nINDEXENTRIES_:
case zVAR_nINDEXENTRIES_:
case rVAR_nINDEXLEVELS_:
case zVAR_nINDEXLEVELS_:
case rVAR_SPARSERECORDS_:
case zVAR_SPARSERECORDS_:
case ATTR_SCOPE_:
case ATTR_MAXgENTRY_:
case ATTR_MAXrENTRY_:
case ATTR_MAXzENTRY_:
case ATTR_NUMgENTRIES_:
case ATTR_NUMrENTRIES_:
case ATTR_NUMzENTRIES_:
case gENTRY_DATATYPE_:
case rENTRY_DATATYPE_:
case zENTRY_DATATYPE_:
case gENTRY_NUMELEMS_:
case rENTRY_NUMELEMS_:
case zENTRY_NUMELEMS_:
case CDF_CHECKSUM_: {
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* GET_,<Int32 *, Int32 *>
*******************************************************************/
case rVAR_ALLOCATEDFROM_:
case zVAR_ALLOCATEDFROM_:
case rVAR_ALLOCATEDTO_:
case zVAR_ALLOCATEDTO_:
case DATATYPE_SIZE_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* GET_,<Int32 *, Int32 *, Int32 *>
*******************************************************************/
case CDF_COMPRESSION_:
case rVAR_COMPRESSION_:
case zVAR_COMPRESSION_:
case rVAR_SPARSEARRAYS_:
case zVAR_SPARSEARRAYS_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* GET_,<void * (string)>
*******************************************************************/
case CDF_COPYRIGHT_:
case LIB_COPYRIGHT_:
case LIB_subINCREMENT_:
case rVAR_NAME_:
case zVAR_NAME_:
case ATTR_NAME_:
case STATUS_TEXT_: {
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* GET_,<void * (string), Int32 *>
*******************************************************************/
case rVAR_NUMBER_:
case zVAR_NUMBER_:
case ATTR_NUMBER_: {
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, Int32 *);
(*sCp)++;
break;
}
/*******************************************************************
* GET_,<void * (string), Int32 *, Int32 *, Int32 *, Int32 *>
*******************************************************************/
case CDF_INFO_: {
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, void *);
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* GET_,<void * (possible string)>
*******************************************************************/
case rVAR_PADVALUE_:
case zVAR_PADVALUE_:
case rVAR_DATA_:
case zVAR_DATA_:
case rVAR_HYPERDATA_:
case zVAR_HYPERDATA_:
case rVAR_SEQDATA_:
case zVAR_SEQDATA_:
case gENTRY_DATA_:
case rENTRY_DATA_:
case zENTRY_DATA_: {
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* GET_,<void * (cannot be string)>
*******************************************************************/
case rVARs_RECDATA_:
case zVARs_RECDATA_: {
Int32 *nVars = va_arg (Va.ap, Int32 *);
Int32 *varNs = va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, void *);
break;
}
/*******************************************************************
* Unknown - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* PUT_,<item>
**************************************************************************/
case PUT_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* PUT_,<Int32 *>
*******************************************************************/
case CDF_ENCODING_:
case CDF_MAJORITY_:
case CDF_FORMAT_:
case rVAR_RECVARY_:
case zVAR_RECVARY_:
case rVAR_DIMVARYS_:
case zVAR_DIMVARYS_:
case rVAR_ALLOCATERECS_:
case zVAR_ALLOCATERECS_:
case rVAR_INITIALRECS_:
case zVAR_INITIALRECS_:
case rVAR_BLOCKINGFACTOR_:
case zVAR_BLOCKINGFACTOR_:
case rVAR_SPARSERECORDS_:
case zVAR_SPARSERECORDS_:
case ATTR_SCOPE_:
case CDF_CHECKSUM_: {
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* PUT_,<Int32 *, Int32 *>
*******************************************************************/
case CDF_COMPRESSION_:
case rVAR_DATASPEC_:
case zVAR_DATASPEC_:
case rVAR_COMPRESSION_:
case zVAR_COMPRESSION_:
case rVAR_SPARSEARRAYS_:
case zVAR_SPARSEARRAYS_:
case rVAR_ALLOCATEBLOCK_:
case zVAR_ALLOCATEBLOCK_:
case gENTRY_DATASPEC_:
case rENTRY_DATASPEC_:
case zENTRY_DATASPEC_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
break;
}
/*******************************************************************
* PUT_,<void * (string)>
*******************************************************************/
case rVAR_NAME_:
case zVAR_NAME_:
case ATTR_NAME_: {
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* PUT_,<void * (possible string)>
*******************************************************************/
case rVAR_PADVALUE_:
case zVAR_PADVALUE_:
case rVAR_DATA_:
case zVAR_DATA_:
case rVAR_HYPERDATA_:
case zVAR_HYPERDATA_:
case rVAR_SEQDATA_:
case zVAR_SEQDATA_: {
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* PUT_,<void * (cannot be string)>
*******************************************************************/
case rVARs_RECDATA_:
case zVARs_RECDATA_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, void *);
break;
}
/*******************************************************************
* PUT_,<Int32 *, Int32 *, void * (possible string)>
*******************************************************************/
case gENTRY_DATA_:
case rENTRY_DATA_:
case zENTRY_DATA_: {
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, Int32 *);
(void) va_arg (Va.ap, void *);
(*sCp)++;
break;
}
/*******************************************************************
* Unknown - hopefully the next operation.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* Unknown - this is bad. We're lost.
**************************************************************************/
default:
va_end (Va.ap);
return ((Int32) BAD_FNC_OR_ITEM);
}
}
status = va_arg (Va.ap, Int32 *);
/******************************************************************************
* Return if only counting possible character strings.
******************************************************************************/
if (sCp != &sC) {
va_end (Va.ap);
return CDF_OK;
}
/******************************************************************************
* Store character string lengths.
******************************************************************************/
if (sC > 0) {
sLs = (Int32 *) cdf_AllocateMemory (sC * sizeof(Int32), NULL);
if (sLs == NULL) {
*status = (Int32) BAD_MALLOC;
return ((Int32) BAD_MALLOC);
}
for (i = 0; i < sC; i++) sLs[i] = Fif_GHOSTFETCH (Va.ap);
}
else
sLs = NULL;
va_end (Va.ap);
#endif
/******************************************************************************
* Scan argument list performing functions.
******************************************************************************/
#if defined(Fif_GHOSTLEN)
sC = 0; /* start at beginning of list of string lengths */
#endif
#if defined(STDARG)
va_start (Va.ap, requiredFnc);
Va.fnc = (long) *requiredFnc;
#else
VA_START (Va.ap);
Va.fnc = (long) *(va_arg (Va.ap, Int32 *));
#endif
while (Va.fnc != NULL_)
switch (Va.fnc) {
/**************************************************************************
* CREATE_
**************************************************************************/
case CREATE_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* CREATE_,CDF_
*******************************************************************/
case CDF_: {
void *CDFname = va_arg (Va.ap, void *);
Int32 numDims = *(va_arg (Va.ap, Int32 *));
Int32 *dimSizes = va_arg (Va.ap, Int32 *);
Int32 *id = va_arg (Va.ap, Int32 *);
int dimN; long dimSizesT[CDF_MAX_DIMS]; CDFid idT;
if (StatusBAD(pStatus)) break;
if (numDims < 0 || numDims > CDF_MAX_DIMS) {
if (!sX(BAD_NUM_DIMS,&pStatus)) break;
}
for (dimN = 0; dimN < numDims; dimN++) {
dimSizesT[dimN] = (long) dimSizes[dimN];
}
tStatus = CDFlib (CREATE_, CDF_,
#if defined(Fif_DESCR)
DESCRtoREFnul(CDFname,
CDF_PATHNAME_LEN,
&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(CDFname,sLs[sC],
&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(CDFname,
CDF_PATHNAME_LEN,
&ssh),
#endif
(long) numDims, dimSizesT, &idT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
*id = CDFidToInt32 (idT);
currentCDFid = idT;
break;
}
/*******************************************************************
* CREATE_,rVAR_
*******************************************************************/
case rVAR_: {
void *varName = va_arg (Va.ap, void *);
Int32 dataType = *(va_arg (Va.ap, Int32 *));
Int32 numElements = *(va_arg (Va.ap, Int32 *));
Int32 recVariance = *(va_arg (Va.ap, Int32 *));
Int32 *dimVariances = va_arg (Va.ap, Int32 *);
Int32 *var_num = va_arg (Va.ap, Int32 *);
int dimN;
long numDims, dimVarysT[CDF_MAX_DIMS], varNumT;
int LFS = FALSE;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, rVARs_NUMDIMS_, &numDims,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
dimVarysT[dimN] = (long) dimVariances[dimN];
}
tStatus = CDFlib (CREATE_, rVAR_,
#if defined(Fif_DESCR)
DESCRtoREFnul(varName,
(LFS ?
CDF_VAR_NAME_LEN256 :
CDF_VAR_NAME_LEN),
&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(varName,
sLs[sC],&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(varName,
(LFS ?
CDF_VAR_NAME_LEN256 :
CDF_VAR_NAME_LEN),
&ssh),
#endif
(long) dataType,
(long) numElements,
(long) recVariance,
dimVarysT, &varNumT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
*var_num = (Int32) (varNumT + 1);
break;
}
/*******************************************************************
* CREATE_,zVAR_
*******************************************************************/
case zVAR_: {
void *varName = va_arg (Va.ap, void *);
Int32 dataType = *(va_arg (Va.ap, Int32 *));
Int32 numElements = *(va_arg (Va.ap, Int32 *));
Int32 numDims = *(va_arg (Va.ap, Int32 *));
Int32 *dimSizes = va_arg (Va.ap, Int32 *);
Int32 recVariance = *(va_arg (Va.ap, Int32 *));
Int32 *dimVariances = va_arg (Va.ap, Int32 *);
Int32 *var_num = va_arg (Va.ap, Int32 *);
int dimN;
long varNumT, dimSizesT[CDF_MAX_DIMS], dimVarysT[CDF_MAX_DIMS];
int LFS = FALSE;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
if (StatusBAD(pStatus)) break;
if (numDims < 0 || numDims > CDF_MAX_DIMS)
if (!sX(BAD_NUM_DIMS,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
dimSizesT[dimN] = (long) dimSizes[dimN];
dimVarysT[dimN] = (long) dimVariances[dimN];
}
tStatus = CDFlib (CREATE_, zVAR_,
#if defined(Fif_DESCR)
DESCRtoREFnul(varName,
(LFS ?
CDF_VAR_NAME_LEN256 :
CDF_VAR_NAME_LEN),
&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(varName,sLs[sC],
&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(varName,
(LFS ?
CDF_VAR_NAME_LEN256 :
CDF_VAR_NAME_LEN),
&ssh),
#endif
(long) dataType,
(long) numElements,
(long) numDims, dimSizesT,
(long) recVariance, dimVarysT,
&varNumT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
*var_num = (Int32) (varNumT + 1);
break;
}
/*******************************************************************
* CREATE_,ATTR_
*******************************************************************/
case ATTR_: {
void *attrName = va_arg (Va.ap, void *);
Int32 scope = *(va_arg (Va.ap, Int32 *));
Int32 *attr_num = va_arg (Va.ap, Int32 *);
long attrNumT;
int LFS = FALSE;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CREATE_, ATTR_,
#if defined(Fif_DESCR)
DESCRtoREFnul(attrName,
(LFS ?
CDF_ATTR_NAME_LEN256 :
CDF_ATTR_NAME_LEN),
&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(attrName,sLs[sC],
&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(attrName,
(LFS ?
CDF_ATTR_NAME_LEN256 :
CDF_ATTR_NAME_LEN),
&ssh),
#endif
(long) scope, &attrNumT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
*attr_num = (Int32) (attrNumT + 1);
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* OPEN_
**************************************************************************/
case OPEN_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* OPEN_,CDF_
*******************************************************************/
case CDF_: {
void *CDFname = va_arg (Va.ap, void *);
Int32 *id = va_arg (Va.ap, Int32 *);
CDFid idT;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (OPEN_, CDF_,
#if defined(Fif_DESCR)
DESCRtoREFnul(CDFname,
CDF_PATHNAME_LEN,
&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(CDFname,sLs[sC],
&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(CDFname,
CDF_PATHNAME_LEN,&ssh),
#endif
&idT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
*id = CDFidToInt32 (idT);
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* DELETE_
**************************************************************************/
case DELETE_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* DELETE_,<object>
*******************************************************************/
case CDF_:
case zVAR_:
case rVAR_:
case ATTR_:
case gENTRY_:
case zENTRY_:
case rENTRY_:
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (DELETE_, Va.item,
NULL_);
if (!sX(tStatus,&pStatus)) break;
if (Va.item == CDF_) currentCDFid = NULL;
break;
/*******************************************************************
* DELETE_,r|zVAR_RECORDS_
*******************************************************************/
case rVAR_RECORDS_:
case zVAR_RECORDS_: {
Int32 *ptr1 = va_arg (Va.ap, Int32 *);
Int32 *ptr2 = va_arg (Va.ap, Int32 *);
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (DELETE_, Va.item, (long) (*ptr1 - 1),
(long) (*ptr2 - 1),
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* CLOSE_
**************************************************************************/
case CLOSE_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* CLOSE_,CDF_
*******************************************************************/
case CDF_: {
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CLOSE_, CDF_,
NULL_);
if (!sX(tStatus,&pStatus)) break;
currentCDFid = NULL;
break;
}
/*******************************************************************
* CLOSE_,rVAR_/zVAR_
*******************************************************************/
case rVAR_:
case zVAR_: {
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CLOSE_, Va.item,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* SELECT_
**************************************************************************/
case SELECT_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* SELECT_,<Int32 * (pass by value)>
*******************************************************************/
case CDF_READONLY_MODE_:
case CDF_zMODE_:
case CDF_NEGtoPOSfp0_MODE_:
case CDF_DECODING_:
case CDF_CACHESIZE_:
case STAGE_CACHESIZE_:
case COMPRESS_CACHESIZE_:
case rVARs_CACHESIZE_:
case zVARs_CACHESIZE_:
case rVAR_CACHESIZE_:
case zVAR_CACHESIZE_:
case rVARs_RECCOUNT_:
case zVAR_RECCOUNT_:
case rVARs_RECINTERVAL_:
case zVAR_RECINTERVAL_:
case rVAR_RESERVEPERCENT_:
case zVAR_RESERVEPERCENT_: {
Int32 value = *(va_arg (Va.ap, Int32 *));
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (SELECT_, Va.item, (long) value,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* SELECT_,<Int32 [] (pass by reference) - CDF_MAX_DIMS maximum>
*******************************************************************/
case rVARs_DIMCOUNTS_:
case zVAR_DIMCOUNTS_:
case rVARs_DIMINTERVALS_:
case zVAR_DIMINTERVALS_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_DIMCOUNTS_ ||
Va.item == zVAR_DIMINTERVALS_);
long numDims, valuesT[CDF_MAX_DIMS];
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
valuesT[dimN] = (long) ptr[dimN];
}
tStatus = CDFlib (SELECT_, Va.item, valuesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* SELECT_,<(Int32 *) - 1 [pass by value]>
*******************************************************************/
case rVAR_:
case zVAR_:
case rVARs_RECNUMBER_:
case zVARs_RECNUMBER_:
case zVAR_RECNUMBER_:
case ATTR_:
case gENTRY_:
case rENTRY_:
case zENTRY_: {
Int32 value = *(va_arg (Va.ap, Int32 *));
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (SELECT_, Va.item, (long) (value - 1),
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* SELECT_,<(Int32 [] - 1) [pass by reference] - CDF_MAX_DIMS
* maximum>
*******************************************************************/
case rVARs_DIMINDICES_:
case zVAR_DIMINDICES_: {
Int32 *indices = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_DIMINDICES_);
long numDims, indicesT[CDF_MAX_DIMS];
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
indicesT[dimN] = (long) (indices[dimN] - 1);
}
tStatus = CDFlib (SELECT_, Va.item, indicesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* SELECT_,<void * (character string)>
*******************************************************************/
case CDF_SCRATCHDIR_:
case rVAR_NAME_:
case zVAR_NAME_:
case ATTR_NAME_:
case rENTRY_NAME_:
case zENTRY_NAME_: {
void *ptr = va_arg (Va.ap, void *);
int LFS = FALSE;
size_t maxLen;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
#if !defined(Fif_GHOSTLEN)
maxLen = PickMaxLen (Va.item, 4,
CDF_SCRATCHDIR_, (size_t) DU_MAX_DIR_LEN,
rVAR_NAME_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
zVAR_NAME_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
ATTR_NAME_, (LFS ?
(size_t) CDF_ATTR_NAME_LEN256 :
(size_t) CDF_ATTR_NAME_LEN));
#endif
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (SELECT_, Va.item,
#if defined(Fif_DESCR)
DESCRtoREFnul(ptr,maxLen,&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(ptr,sLs[sC],&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(ptr,maxLen,&ssh),
#endif
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
break;
}
/*******************************************************************
* SELECT_,CDF_
*******************************************************************/
case CDF_: {
Int32 *id = va_arg (Va.ap, Int32 *);
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (SELECT_, CDF_, Int32ToCDFid(*id),
NULL_);
if (!sX(tStatus,&pStatus)) break;
currentCDFid = Int32ToCDFid(*id);
break;
}
/*******************************************************************
* SELECT_,CDF_STATUS_
*******************************************************************/
case CDF_STATUS_: {
Int32 newStatus = *(va_arg (Va.ap, Int32 *));
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (SELECT_, CDF_STATUS_, (CDFstatus) newStatus,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* SELECT_,rVAR_SEQPOS_/zVAR_SEQPOS_
*******************************************************************/
case rVAR_SEQPOS_:
case zVAR_SEQPOS_: {
Int32 rec_num = *(va_arg (Va.ap, Int32 *));
Int32 *indices = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_SEQPOS_);
long numDims, indicesT[CDF_MAX_DIMS];
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
indicesT[dimN] = (long) (indices[dimN] - 1);
}
tStatus = CDFlib (SELECT_, Va.item, (long) (rec_num-1), indicesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* CONFIRM_
**************************************************************************/
case CONFIRM_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* CONFIRM_,<no arguments>
*******************************************************************/
case CURgENTRY_EXISTENCE_:
case CURrENTRY_EXISTENCE_:
case CURzENTRY_EXISTENCE_:
case CDF_CHECKSUM_: {
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CONFIRM_, Va.item,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* CONFIRM_,<Int32 * [output]>
*******************************************************************/
case CDF_READONLY_MODE_:
case CDF_zMODE_:
case CDF_NEGtoPOSfp0_MODE_:
case CDF_DECODING_:
case CDF_CACHESIZE_:
case STAGE_CACHESIZE_:
case COMPRESS_CACHESIZE_:
case rVAR_CACHESIZE_:
case zVAR_CACHESIZE_:
case rVARs_RECCOUNT_:
case zVAR_RECCOUNT_:
case rVARs_RECINTERVAL_:
case zVAR_RECINTERVAL_:
case rVAR_RESERVEPERCENT_:
case zVAR_RESERVEPERCENT_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
long valueT;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CONFIRM_, Va.item, &valueT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*ptr = (Int32) valueT;
break;
}
/*******************************************************************
* CONFIRM_,<(Int32 *) + 1 [output]>
*******************************************************************/
case rVAR_:
case zVAR_:
case rVARs_RECNUMBER_:
case zVAR_RECNUMBER_:
case ATTR_:
case gENTRY_:
case rENTRY_:
case zENTRY_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
long valueT;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CONFIRM_, Va.item, &valueT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*ptr = (Int32) (valueT + 1);
break;
}
/*******************************************************************
* CONFIRM_,<(Int32 []) [output] - CDF_MAX_DIMS maximum>
*******************************************************************/
case rVARs_DIMCOUNTS_:
case zVAR_DIMCOUNTS_:
case rVARs_DIMINTERVALS_:
case zVAR_DIMINTERVALS_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_DIMCOUNTS_ ||
Va.item == zVAR_DIMINTERVALS_);
long numDims, valuesT[CDF_MAX_DIMS];
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
CONFIRM_, Va.item, valuesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
ptr[dimN] = (Int32) valuesT[dimN];
}
break;
}
/*******************************************************************
* CONFIRM_,<(Int32 [] + 1) [output] - CDF_MAX_DIMS maximum>
*******************************************************************/
case rVARs_DIMINDICES_:
case zVAR_DIMINDICES_: {
Int32 *values = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_DIMINDICES_);
long numDims, valuesT[CDF_MAX_DIMS];
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
CONFIRM_, Va.item, valuesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
values[dimN] = (Int32) (valuesT[dimN] + 1);
}
break;
}
/*******************************************************************
* CONFIRM_,<(Int32 *) - 1 [input]>
*******************************************************************/
case gENTRY_EXISTENCE_:
case rENTRY_EXISTENCE_:
case zENTRY_EXISTENCE_: {
Int32 entryN = *(va_arg (Va.ap, Int32 *));
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CONFIRM_, Va.item, (long) (entryN - 1),
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* CONFIRM_,<void * (character string) [input]>
*******************************************************************/
case rVAR_EXISTENCE_:
case zVAR_EXISTENCE_:
case ATTR_EXISTENCE_: {
void *varName = va_arg (Va.ap, void *);
int LFS = FALSE;
size_t maxLen;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
#if !defined(Fif_GHOSTLEN)
maxLen = PickMaxLen (Va.item, 3,
rVAR_EXISTENCE_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
zVAR_EXISTENCE_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
ATTR_EXISTENCE_, (LFS ?
(size_t) CDF_ATTR_NAME_LEN256:
(size_t) CDF_ATTR_NAME_LEN));
#endif
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CONFIRM_, Va.item,
#if defined(Fif_DESCR)
DESCRtoREFnul(varName,
maxLen,&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(varName,sLs[sC],
&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(varName,maxLen,
&ssh),
#endif
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
break;
}
/*******************************************************************
* CONFIRM_,CDF_NAME_
*******************************************************************/
case CDF_NAME_: {
void *name = va_arg (Va.ap, void *);
char nameT[CDF_PATHNAME_LEN+1];
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (CONFIRM_, CDF_NAME_, nameT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
CtoFORTstring (nameT, name, sLs[sC]);
sC++;
#else
CtoFORTstring (nameT, name, CDF_PATHNAME_LEN);
#endif
break;
}
/*******************************************************************
* CONFIRM_,rVAR_SEQPOS_/zVAR_SEQPOS_
*******************************************************************/
case rVAR_SEQPOS_:
case zVAR_SEQPOS_: {
Int32 *rec_num = va_arg (Va.ap, Int32 *);
Int32 *indices = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_SEQPOS_);
long numDims, indicesT[CDF_MAX_DIMS], recNumT;
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
CONFIRM_, Va.item, &recNumT, indicesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*rec_num = (Int32) (recNumT + 1);
for (dimN = 0; dimN < numDims; dimN++) {
indices[dimN] = (Int32) (indicesT[dimN] + 1);
}
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* GET_
**************************************************************************/
case GET_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* GET_,<Int32 * (passed by reference)>.
*******************************************************************/
case rVARs_NUMDIMS_:
case zVAR_NUMDIMS_:
case CDF_ENCODING_:
case CDF_MAJORITY_:
case CDF_FORMAT_:
case CDF_NUMrVARS_:
case CDF_NUMzVARS_:
case CDF_NUMATTRS_:
case CDF_NUMgATTRS_:
case CDF_NUMvATTRS_:
case CDF_VERSION_:
case CDF_RELEASE_:
case CDF_INCREMENT_:
case rVAR_DATATYPE_:
case zVAR_DATATYPE_:
case rVAR_NUMELEMS_:
case zVAR_NUMELEMS_:
case rVAR_RECVARY_:
case zVAR_RECVARY_:
case rVAR_BLOCKINGFACTOR_:
case zVAR_BLOCKINGFACTOR_:
case rVAR_nINDEXRECORDS_:
case zVAR_nINDEXRECORDS_:
case rVAR_nINDEXENTRIES_:
case zVAR_nINDEXENTRIES_:
case rVAR_nINDEXLEVELS_:
case zVAR_nINDEXLEVELS_:
case rVAR_NUMRECS_:
case zVAR_NUMRECS_:
case rVAR_NUMallocRECS_:
case zVAR_NUMallocRECS_:
case rVAR_SPARSERECORDS_:
case zVAR_SPARSERECORDS_:
case ATTR_SCOPE_:
case ATTR_NUMgENTRIES_:
case ATTR_NUMrENTRIES_:
case ATTR_NUMzENTRIES_:
case gENTRY_DATATYPE_:
case rENTRY_DATATYPE_:
case zENTRY_DATATYPE_:
case gENTRY_NUMELEMS_:
case rENTRY_NUMELEMS_:
case zENTRY_NUMELEMS_:
case LIB_VERSION_:
case LIB_RELEASE_:
case LIB_INCREMENT_:
case CDF_CHECKSUM_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
long valueT;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, Va.item, &valueT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*ptr = (Int32) valueT;
break;
}
/*******************************************************************
* GET_,<Int32 * In, Int32 * Out>.
*******************************************************************/
case DATATYPE_SIZE_: {
Int32 *ptr1 = va_arg (Va.ap, Int32 *);
Int32 *ptr2 = va_arg (Va.ap, Int32 *);
long valueT;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, Va.item, (long) *ptr1, &valueT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*ptr2 = (Int32) valueT;
break;
}
/*******************************************************************
* GET_,<(Int32 * In) - 1, (Int32 * Out) + 1>.
*******************************************************************/
case rVAR_ALLOCATEDTO_:
case zVAR_ALLOCATEDTO_:
case rVAR_ALLOCATEDFROM_:
case zVAR_ALLOCATEDFROM_: {
Int32 *ptr1 = va_arg (Va.ap, Int32 *);
Int32 *ptr2 = va_arg (Va.ap, Int32 *);
long valueT;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, Va.item, (long) (*ptr1 - 1), &valueT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*ptr2 = (Int32) (valueT + 1);
break;
}
/*******************************************************************
* GET_,<(Int32 *) + 1 (passed by reference)>.
*******************************************************************/
case rVARs_MAXREC_:
case zVARs_MAXREC_:
case rVAR_MAXREC_:
case zVAR_MAXREC_:
case rVAR_MAXallocREC_:
case zVAR_MAXallocREC_:
case ATTR_MAXgENTRY_:
case ATTR_MAXrENTRY_:
case ATTR_MAXzENTRY_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
long valueT;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, Va.item, &valueT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*ptr = (Int32) (valueT + 1);
break;
}
/*******************************************************************
* GET_,<Int32 [] (passed by reference) - CDF_MAX_DIMS maximum>
*******************************************************************/
case rVARs_DIMSIZES_:
case zVAR_DIMSIZES_:
case rVAR_DIMVARYS_:
case zVAR_DIMVARYS_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_DIMSIZES_ ||
Va.item == zVAR_DIMVARYS_);
long valuesT[CDF_MAX_DIMS], numDims;
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
Va.item, valuesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
ptr[dimN] = (Int32) valuesT[dimN];
}
break;
}
/*******************************************************************
* GET_,<void * (character string)>.
*******************************************************************/
case LIB_subINCREMENT_:
case LIB_COPYRIGHT_:
case CDF_COPYRIGHT_:
case rVAR_NAME_:
case zVAR_NAME_:
case ATTR_NAME_: {
void *ptr = va_arg (Va.ap, void *);
char *ptrT;
int LFS = FALSE;
size_t maxLen;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
if (StatusBAD(pStatus)) break;
maxLen = PickMaxLen (Va.item, 6,
LIB_subINCREMENT_, (size_t) 1,
LIB_COPYRIGHT_, (size_t) CDF_DOCUMENT_LEN,
CDF_COPYRIGHT_, (size_t) CDF_DOCUMENT_LEN,
rVAR_NAME_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
zVAR_NAME_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
ATTR_NAME_, (LFS ?
(size_t) CDF_ATTR_NAME_LEN256 :
(size_t) CDF_ATTR_NAME_LEN));
ptrT = (char *) cdf_AllocateMemory (maxLen + 1, NULL);
if (ptrT == NULL) {
if (!sX(BAD_MALLOC,&pStatus)) break;
}
tStatus = CDFlib (GET_, Va.item, ptrT,
NULL_);
if (!sX(tStatus,&pStatus)) {
cdf_FreeMemory (ptrT, NULL);
break;
}
#if defined(Fif_GHOSTLEN)
CtoFORTstring (ptrT, ptr, sLs[sC]);
sC++;
#else
CtoFORTstring (ptrT, ptr, (int) maxLen);
#endif
cdf_FreeMemory (ptrT, NULL);
break;
}
/*******************************************************************
* GET_,<in: void * (character string), out: (Int32 *) + 1>
*******************************************************************/
case rVAR_NUMBER_:
case zVAR_NUMBER_:
case ATTR_NUMBER_: {
void *ptr1 = va_arg (Va.ap, void *);
Int32 *ptr2 = va_arg (Va.ap, Int32 *);
long valueT;
int LFS = FALSE;
size_t maxLen;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
#if !defined(Fif_GHOSTLEN)
maxLen = PickMaxLen (Va.item, 3,
rVAR_NUMBER_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
zVAR_NUMBER_, (LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
ATTR_NUMBER_, (LFS ?
(size_t) CDF_ATTR_NAME_LEN256 :
(size_t) CDF_ATTR_NAME_LEN));
#endif
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, Va.item,
#if defined(Fif_DESCR)
DESCRtoREFnul(ptr1,maxLen,&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(ptr1,sLs[sC],&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(ptr1,maxLen,&ssh),
#endif
&valueT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
*ptr2 = (Int32) (valueT + 1);
break;
}
/*******************************************************************
* GET_,CDF_INFO_:
*******************************************************************/
case CDF_INFO_: {
void *ptr1 = va_arg (Va.ap, void *);
Int32 *ptr2 = va_arg (Va.ap, Int32 *);
Int32 *ptr3 = va_arg (Va.ap, Int32 *);
void *ptr4 = va_arg (Va.ap, void *);
void *ptr5 = va_arg (Va.ap, void *);
long cType, cParms[CDF_MAX_PARMS]; /* cSize, uSize;*/ int p;
void *cSize, *uSize;
int LFS = FALSE;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
if (LFS) {
cSize = (OFF_T *) malloc(sizeof(OFF_T));
uSize = (OFF_T *) malloc(sizeof(OFF_T));
} else {
cSize = (long *) malloc(sizeof(long));
uSize = (long *) malloc(sizeof(long));
}
tStatus = CDFlib (GET_, Va.item,
#if defined(Fif_DESCR)
DESCRtoREFnul(ptr1,
CDF_PATHNAME_LEN,
&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(ptr1,sLs[sC],&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(ptr1,
CDF_PATHNAME_LEN,
&ssh),
#endif
&cType, cParms, cSize, uSize,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
*ptr2 = (Int32) cType;
for (p = 0; p < CompressionParmsCount((Int32)cType); p++) {
ptr3[p] = (Int32) cParms[p];
}
memcpy(ptr4, cSize, sizeof(cSize));
memcpy(ptr5, uSize, sizeof(uSize));
free (cSize);
free (uSize);
break;
}
/*******************************************************************
* GET_,CDF_COMPRESSION_
* GET_,rVAR_COMPRESSION_
* GET_,zVAR_COMPRESSION_
* GET_,rVAR_SPARSEARRAYS_
* GET_,zVAR_SPARSEARRAYS_
*******************************************************************/
case CDF_COMPRESSION_:
case rVAR_COMPRESSION_:
case zVAR_COMPRESSION_:
case rVAR_SPARSEARRAYS_:
case zVAR_SPARSEARRAYS_: {
Logical sparse = (Va.item == rVAR_SPARSEARRAYS_ ||
Va.item == zVAR_SPARSEARRAYS_);
Int32 *ptr1 = va_arg (Va.ap, Int32 *);
Int32 *ptr2 = va_arg (Va.ap, Int32 *);
Int32 *ptr3 = va_arg (Va.ap, Int32 *);
long type, parms[CDF_MAX_PARMS], pct; int pCount, p;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, Va.item, &type, parms, &pct,
NULL_);
if (!sX(tStatus,&pStatus)) break;
*ptr1 = (Int32) type;
pCount = BOO(sparse,SparsenessParmsCount((Int32)type),
CompressionParmsCount((Int32)type));
for (p = 0; p < pCount; p++) ptr2[p] = (Int32) parms[p];
*ptr3 = (Int32) pct;
break;
}
/*******************************************************************
* GET_,<void * (depends on data type) - variable value(s)>
*******************************************************************/
case rVAR_PADVALUE_:
case zVAR_PADVALUE_:
case rVAR_DATA_:
case zVAR_DATA_:
case rVAR_HYPERDATA_:
case zVAR_HYPERDATA_:
case rVAR_SEQDATA_:
case zVAR_SEQDATA_: {
void *ptr = va_arg (Va.ap, void *);
Logical Z = (Va.item == zVAR_PADVALUE_ ||
Va.item == zVAR_DATA_ ||
Va.item == zVAR_HYPERDATA_ ||
Va.item == zVAR_SEQDATA_);
long dataType;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_DATATYPE_,
rVAR_DATATYPE_), &dataType,
NULL_);
if (!sX(tStatus,&pStatus)) break;
tStatus = CDFlib (GET_, Va.item,
#if defined(Fif_DESCR)
STRINGdataType(dataType) ?
DESCRtoREF(ptr) : ptr,
#else
ptr,
#endif
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
if (STRINGdataType(dataType)) sC++;
#endif
break;
}
/*******************************************************************
* GET_,r/zVARs_RECDATA_
*******************************************************************/
case rVARs_RECDATA_:
case zVARs_RECDATA_: {
Int32 *nVars = va_arg (Va.ap, Int32 *);
Int32 *varNs = va_arg (Va.ap, Int32 *);
void *ptr = va_arg (Va.ap, void *);
long *tVarNs; int varX;
if (StatusBAD(pStatus)) break;
if (*nVars < 1) {
if (!sX(BAD_NUM_VARS,&pStatus)) break;
}
tVarNs = (long *) cdf_AllocateMemory ((size_t)(*nVars*sizeof(long)),
NULL);
if (tVarNs == NULL) {
if (!sX(BAD_MALLOC,&pStatus)) break;
}
for (varX = 0; varX < *nVars; varX++) {
tVarNs[varX] = (long) (varNs[varX] - 1);
}
tStatus = CDFlib (GET_, Va.item, (long) *nVars, tVarNs, ptr,
NULL_);
cdf_FreeMemory (tVarNs, NULL); /*Before checking status.*/
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* GET_,gENTRY_DATA_/rENTRY_DATA_/zENTRY_DATA_
*******************************************************************/
case gENTRY_DATA_:
case rENTRY_DATA_:
case zENTRY_DATA_: {
void *value = va_arg (Va.ap, void *);
int Et = E3p(Va.item,gENTRY_DATA_,rENTRY_DATA_,zENTRY_DATA_);
long dataType;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, E3(Et,gENTRY_DATATYPE_,
rENTRY_DATATYPE_,
zENTRY_DATATYPE_), &dataType,
NULL_);
if (!sX(tStatus,&pStatus)) break;
tStatus = CDFlib (GET_, Va.item,
#if defined(Fif_DESCR)
STRINGdataType(dataType) ?
DESCRtoREF(value) : value,
#else
value,
#endif
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
if (STRINGdataType(dataType)) sC++;
#endif
break;
}
/*******************************************************************
* GET_,STATUS_TEXT_
*******************************************************************/
case STATUS_TEXT_: {
void *textPtr = va_arg (Va.ap, void *);
char textT[CDF_STATUSTEXT_LEN+1];
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, STATUS_TEXT_, textT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
CtoFORTstring (textT, textPtr, sLs[sC]);
sC++;
#else
CtoFORTstring (textT, textPtr, CDF_STATUSTEXT_LEN);
#endif
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* PUT_
**************************************************************************/
case PUT_:
for (;;) {
Va.item = (long) *(va_arg (Va.ap, Int32 *));
switch (Va.item) {
/*******************************************************************
* PUT_,<Int32 *>
*******************************************************************/
case CDF_ENCODING_:
case CDF_MAJORITY_:
case CDF_FORMAT_:
case rVAR_RECVARY_:
case zVAR_RECVARY_:
case rVAR_ALLOCATERECS_:
case zVAR_ALLOCATERECS_:
case rVAR_INITIALRECS_:
case zVAR_INITIALRECS_:
case rVAR_BLOCKINGFACTOR_:
case zVAR_BLOCKINGFACTOR_:
case rVAR_SPARSERECORDS_:
case zVAR_SPARSERECORDS_:
case ATTR_SCOPE_:
case CDF_CHECKSUM_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (PUT_, Va.item, (long) *ptr,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* PUT_,<Int32 []>
*******************************************************************/
case rVAR_DIMVARYS_:
case zVAR_DIMVARYS_: {
Int32 *ptr = va_arg (Va.ap, Int32 *);
Logical Z = (Va.item == zVAR_DIMVARYS_);
long valuesT[CDF_MAX_DIMS], numDims;
int dimN;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
rVARs_NUMDIMS_), &numDims,
NULL_);
if (!sX(tStatus,&pStatus)) break;
for (dimN = 0; dimN < numDims; dimN++) {
valuesT[dimN] = (long) ptr[dimN];
}
tStatus = CDFlib (PUT_, Va.item, valuesT,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* PUT_,CDF_COMPRESSION_
* PUT_,rVAR_COMPRESSION_
* PUT_,zVAR_COMPRESSION_
* PUT_,rVAR_SPARSEARRAYS_
* PUT_,zVAR_SPARSEARRAYS_
*******************************************************************/
case CDF_COMPRESSION_:
case rVAR_COMPRESSION_:
case zVAR_COMPRESSION_:
case rVAR_SPARSEARRAYS_:
case zVAR_SPARSEARRAYS_: {
Logical sparse = (Va.item == rVAR_SPARSEARRAYS_ ||
Va.item == zVAR_SPARSEARRAYS_);
Int32 *ptr1 = va_arg (Va.ap, Int32 *);
Int32 *ptr2 = va_arg (Va.ap, Int32 *);
int p, pCount = BOO(sparse,SparsenessParmsCount(*ptr1),
CompressionParmsCount(*ptr1));
long parms[CDF_MAX_PARMS];
if (StatusBAD(pStatus)) break;
for (p = 0; p < pCount; p++) parms[p] = (long) ptr2[p];
tStatus = CDFlib (PUT_, Va.item, (long) *ptr1, parms,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* PUT_,<Int32 *, Int32 *>
*******************************************************************/
case rVAR_DATASPEC_:
case zVAR_DATASPEC_:
case gENTRY_DATASPEC_:
case rENTRY_DATASPEC_:
case zENTRY_DATASPEC_: {
Int32 value1 = *(va_arg (Va.ap, Int32 *));
Int32 value2 = *(va_arg (Va.ap, Int32 *));
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (PUT_, Va.item, (long) value1, (long) value2,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* PUT_,<(Int32 *) - 1, (Int32 *) - 1>
*******************************************************************/
case rVAR_ALLOCATEBLOCK_:
case zVAR_ALLOCATEBLOCK_: {
Int32 value1 = *(va_arg (Va.ap, Int32 *)) - 1;
Int32 value2 = *(va_arg (Va.ap, Int32 *)) - 1;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (PUT_, Va.item, (long) value1, (long) value2,
NULL_);
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* PUT_,<void * (character string)>
*******************************************************************/
case rVAR_NAME_:
case zVAR_NAME_:
case ATTR_NAME_: {
void *ptr = va_arg (Va.ap, void *);
int LFS = FALSE;
size_t maxLen;
if (currentCDFid != NULL) {
struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
if (isLFS(CDF)) LFS = TRUE;
}
#if !defined(Fif_GHOSTLEN)
maxLen = PickMaxLen (Va.item, 3,
rVAR_NAME_,(LFS ?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
zVAR_NAME_,(LFS?
(size_t) CDF_VAR_NAME_LEN256 :
(size_t) CDF_VAR_NAME_LEN),
ATTR_NAME_,(LFS?
(size_t) CDF_ATTR_NAME_LEN256 :
(size_t) CDF_ATTR_NAME_LEN));
#endif
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (PUT_, Va.item,
#if defined(Fif_DESCR)
DESCRtoREFnul(ptr,maxLen,&ssh),
#endif
#if defined(Fif_GHOSTLEN)
NULterminate(ptr,sLs[sC],&ssh),
#endif
#if defined(Fif_NOLEN)
FindEndNUL(ptr,maxLen,&ssh),
#endif
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
sC++;
#endif
break;
}
/*******************************************************************
* PUT_,<void * (depends on data type) - variable value(s)>
*******************************************************************/
case rVAR_PADVALUE_:
case zVAR_PADVALUE_:
case rVAR_DATA_:
case zVAR_DATA_:
case rVAR_HYPERDATA_:
case zVAR_HYPERDATA_:
case rVAR_SEQDATA_:
case zVAR_SEQDATA_: {
void *ptr = va_arg (Va.ap, void *);
Logical Z = (Va.item == zVAR_PADVALUE_ ||
Va.item == zVAR_DATA_ ||
Va.item == zVAR_HYPERDATA_ ||
Va.item == zVAR_SEQDATA_);
long dataType;
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (GET_, BOO(Z,zVAR_DATATYPE_,
rVAR_DATATYPE_), &dataType,
NULL_);
if (!sX(tStatus,&pStatus)) break;
tStatus = CDFlib (PUT_, Va.item,
#if defined(Fif_DESCR)
STRINGdataType(dataType) ?
DESCRtoREF(ptr) : ptr,
#else
ptr,
#endif
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
if (STRINGdataType(dataType)) sC++;
#endif
break;
}
/*******************************************************************
* PUT_,r/zVARs_RECDATA_
*******************************************************************/
case rVARs_RECDATA_:
case zVARs_RECDATA_: {
Int32 *nVars = va_arg (Va.ap, Int32 *);
Int32 *varNs = va_arg (Va.ap, Int32 *);
void *ptr = va_arg (Va.ap, void *);
long *tVarNs; int varX;
if (StatusBAD(pStatus)) break;
if (*nVars < 1) {
if (!sX(BAD_NUM_VARS,&pStatus)) break;
}
tVarNs = (long *) cdf_AllocateMemory ((size_t)(*nVars*sizeof(long)),
NULL);
if (tVarNs == NULL) {
if (!sX(BAD_MALLOC,&pStatus)) break;
}
for (varX = 0; varX < *nVars; varX++) {
tVarNs[varX] = (long) (varNs[varX] - 1);
}
tStatus = CDFlib (PUT_, Va.item, (long) *nVars, tVarNs, ptr,
NULL_);
cdf_FreeMemory (tVarNs, NULL); /*Before checking status.*/
if (!sX(tStatus,&pStatus)) break;
break;
}
/*******************************************************************
* PUT_,gENTRY_DATA_/rENTRY_DATA_/zENTRY_DATA_
*******************************************************************/
case gENTRY_DATA_:
case rENTRY_DATA_:
case zENTRY_DATA_: {
Int32 dataType = *(va_arg (Va.ap, Int32 *));
Int32 numElements = *(va_arg (Va.ap, Int32 *));
void *value = va_arg (Va.ap, void *);
if (StatusBAD(pStatus)) break;
tStatus = CDFlib (PUT_, Va.item, (long) dataType,
(long) numElements,
#if defined(Fif_DESCR)
STRINGdataType(dataType) ?
DESCRtoREF(value) : value,
#else
value,
#endif
NULL_);
if (!sX(tStatus,&pStatus)) break;
#if defined(Fif_GHOSTLEN)
if (STRINGdataType(dataType)) sC++;
#endif
break;
}
/*******************************************************************
* Unknown item - hopefully the next function.
*******************************************************************/
default: {
Va.fnc = Va.item;
break;
}
}
if (Va.fnc == Va.item) break;
}
break;
/**************************************************************************
* Unknown function/item. This is bad - we're lost.
**************************************************************************/
default: {
#if defined(Fif_GHOSTLEN)
if (sLs != NULL) cdf_FreeMemory (sLs, NULL);
#endif
FreeStrings (ssh);
va_end (Va.ap);
return ((Int32) BAD_FNC_OR_ITEM);
}
}
#if defined(Fif_GHOSTLEN)
if (sLs != NULL) cdf_FreeMemory (sLs, NULL);
#endif
status = va_arg (Va.ap, Int32 *);
*status = (Int32) pStatus;
va_end (Va.ap);
FreeStrings (ssh);
return ((Int32) pStatus);
}
/******************************************************************************
* PickMaxLen.
* Syntax: len = PickMaxLen (targetItem, nListed,
* listItem1, listLen1,
* listItem2, listLen2,
* .
* .
* .
* listItemN, listLenN);
******************************************************************************/
static size_t PickMaxLen
#if defined(STDARG)
(long requiredArgument, ...)
#else
(va_alist)
va_dcl
#endif
{
va_list ap;
long targetItem; /* The item being sought. */
int nListed; /* The number of listed items (the list
being searched for the target item). */
int listN; /* Index into list of item/length pairs. */
#if defined(STDARG)
va_start (ap, requiredArgument);
targetItem = requiredArgument;
#else
VA_START (ap);
targetItem = va_arg (ap, long);
#endif
nListed = va_arg (ap, int);
for (listN = 0; listN < nListed; listN++) {
long listItem = va_arg (ap, long);
size_t listLen = va_arg (ap, size_t);
if (listItem == targetItem) {
va_end (ap);
return listLen;
}
}
va_end (ap);
return (size_t) 0;
}
/******************************************************************************
* CDF_lib_4.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_4__,cdf_lib_4_,cdf_lib_4,CDF_LIB_4)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[4]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a3);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, l[0], l[1], l[2], l[3]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[4]; int i; void *a[4];
va_list ap; CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 4; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], l[0], l[1], l[2], l[3]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3);
#else
void *a[4]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 4; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_5.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_5__,cdf_lib_5_,cdf_lib_5,CDF_LIB_5)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[5]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a4);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4,
l[0], l[1], l[2], l[3], l[4]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[5]; int i; void *a[5];
va_list ap; CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 5; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4],
l[0], l[1], l[2], l[3], l[4]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4);
#else
void *a[5]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 5; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_6.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_6__,cdf_lib_6_,cdf_lib_6,CDF_LIB_6)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[6]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a5);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5,
l[0], l[1], l[2], l[3], l[4], l[5]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[6]; int i; void *a[6];
va_list ap; CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 6; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5],
l[0], l[1], l[2], l[3], l[4], l[5]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5);
#else
void *a[6]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 6; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_7.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_7__,cdf_lib_7_,cdf_lib_7,CDF_LIB_7)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[7]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a6);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6,
l[0], l[1], l[2], l[3], l[4], l[5], l[6]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[7]; int i; void *a[7];
va_list ap; CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 7; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6],
l[0], l[1], l[2], l[3], l[4], l[5], l[6]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6);
#else
void *a[7]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 7; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_8.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_8__,cdf_lib_8_,cdf_lib_8,CDF_LIB_8)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[8]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a7);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[8]; int i; void *a[8];
va_list ap; CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 8; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7);
#else
void *a[8]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 8; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_9.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_9__,cdf_lib_9_,cdf_lib_9,CDF_LIB_9)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[9]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a8);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[9]; int i; void *a[9];
va_list ap; CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 9; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8);
#else
void *a[9]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 9; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_10.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_10__,cdf_lib_10_,cdf_lib_10,CDF_LIB_10)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[10]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a9);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[10]; int i; void *a[10]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 10; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
#else
void *a[10]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 10; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_11.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_11__,cdf_lib_11_,cdf_lib_11,CDF_LIB_11)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[11]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a10);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[11]; int i; void *a[11]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 11; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
#else
void *a[11]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 11; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_12.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_12__,cdf_lib_12_,cdf_lib_12,CDF_LIB_12)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[12]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a11);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[12]; int i; void *a[12]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 12; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
#else
void *a[12]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 12; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_13.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_13__,cdf_lib_13_,cdf_lib_13,CDF_LIB_13)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[13]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a12);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[13]; int i; void *a[13]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 13; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
#else
void *a[13]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 13; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_14.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_14__,cdf_lib_14_,cdf_lib_14,CDF_LIB_14)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[14]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a13);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[14]; int i; void *a[14]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 14; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
#else
void *a[14]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 14; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_15.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_15__,cdf_lib_15_,cdf_lib_15,CDF_LIB_15)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[15]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a14);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[15]; int i; void *a[15]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 15; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14);
#else
void *a[15]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 15; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_16.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_16__,cdf_lib_16_,cdf_lib_16,CDF_LIB_16)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[16]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a15);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[16]; int i; void *a[16]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 16; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15);
#else
void *a[16]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 16; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_17.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_17__,cdf_lib_17_,cdf_lib_17,CDF_LIB_17)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[17]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a16);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[17]; int i; void *a[17]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 17; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16);
#else
void *a[17]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 17; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_18.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_18__,cdf_lib_18_,cdf_lib_18,CDF_LIB_18)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[18]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a17);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, l[0], l[1], l[2], l[3], l[4], l[5],
l[6], l[7], l[8], l[9], l[10], l[11], l[12], l[13], l[14],
l[15], l[16], l[17]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[18]; int i; void *a[18]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 18; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17);
#else
void *a[18]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 18; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_19.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_19__,cdf_lib_19_,cdf_lib_19,CDF_LIB_19)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, void *a18, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[19]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a18);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[19]; int i; void *a[19]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 19; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17], a[18]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18);
#else
void *a[19]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 19; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_20.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_20__,cdf_lib_20_,cdf_lib_20,CDF_LIB_20)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[20]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a19);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[20]; int i; void *a[20]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 20; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17], a[18], a[19]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19);
#else
void *a[20]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 20; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_21.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_21__,cdf_lib_21_,cdf_lib_21,CDF_LIB_21)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[21]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a20);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[21]; int i; void *a[21]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 21; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17], a[18], a[19], a[20]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20);
#else
void *a[21]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 21; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_22.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_22__,cdf_lib_22_,cdf_lib_22,CDF_LIB_22)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
void *a21, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[22]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20, a21);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a21);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[22]; int i; void *a[22]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 22; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17], a[18], a[19], a[20], a[21]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21);
#else
void *a[22]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 22; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_23.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_23__,cdf_lib_23_,cdf_lib_23,CDF_LIB_23)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
void *a21, void *a22, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[23]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a22);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21, a22,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21], l[22]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[23]; int i; void *a[23]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 23; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17], a[18], a[19], a[20], a[21], a[22]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21], a[22],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21], l[22]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21, a22);
#else
void *a[23]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 23; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21], a[22]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_24.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_24__,cdf_lib_24_,cdf_lib_24,CDF_LIB_24)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
void *a21, void *a22, void *a23, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[24]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22,
a23);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a23);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21, a22, a23,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21], l[22], l[23]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[24]; int i; void *a[24]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 24; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17], a[18], a[19], a[20], a[21], a[22], a[23]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21], a[22], a[23],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21], l[22], l[23]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21, a22, a23);
#else
void *a[24]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 24; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21], a[22], a[23]);
#endif
#endif
}
/******************************************************************************
* CDF_lib_25.
******************************************************************************/
VISIBLE_PREFIX
Fif_PREFIXa
Int32
Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_25__,cdf_lib_25_,cdf_lib_25,CDF_LIB_25)
#if defined(STDARG)
(void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
void *a21, void *a22, void *a23, void *a24, ...)
#else
(va_alist)
va_dcl
#endif
{
#if defined(Fif_GHOSTLEN)
#if defined(STDARG)
Int32 sC = 0; Fif_GHOSTTYPE l[25]; int i; va_list ap; CDFstatus tStatus;
tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22,
a23, a24);
if (StatusBAD(tStatus)) return tStatus;
va_start (ap, a24);
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24,
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21], l[22], l[23], l[24]);
#else
Int32 sC = 0; Fif_GHOSTTYPE l[25]; int i; void *a[25]; va_list ap;
CDFstatus tStatus;
VA_START (ap);
for (i = 0; i < 25; i++) a[i] = va_arg (ap, void *);
tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
a[16], a[17], a[18], a[19], a[20], a[21], a[22], a[23],
a[24]);
if (StatusBAD(tStatus)) return tStatus;
for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21], a[22], a[23], a[24],
l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
l[18], l[19], l[20], l[21], l[22], l[23], l[24]);
#endif
#else
#if defined(STDARG)
return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24);
#else
void *a[25]; int i; va_list ap;
VA_START (ap);
for (i = 0; i < 25; i++) a[i] = va_arg (ap, void *);
va_end (ap);
return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
a[18], a[19], a[20], a[21], a[22], a[23], a[24]);
#endif
#endif
}
syntax highlighted by Code2HTML, v. 0.9.1