/****************************************************************************** * * 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_, **************************************************************************/ 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_, **************************************************************************/ 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_, **************************************************************************/ case DELETE_: for (;;) { Va.item = (long) *(va_arg (Va.ap, Int32 *)); switch (Va.item) { /******************************************************************* * DELETE_, *******************************************************************/ 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_, **************************************************************************/ 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_, **************************************************************************/ case SELECT_: for (;;) { Va.item = (long) *(va_arg (Va.ap, Int32 *)); switch (Va.item) { /******************************************************************* * SELECT_, *******************************************************************/ 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_, *******************************************************************/ case rVAR_SEQPOS_: case zVAR_SEQPOS_: { (void) va_arg (Va.ap, Int32 *); (void) va_arg (Va.ap, Int32 *); break; } /******************************************************************* * SELECT_, *******************************************************************/ 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_, **************************************************************************/ case CONFIRM_: for (;;) { Va.item = (long) *(va_arg (Va.ap, Int32 *)); switch (Va.item) { /******************************************************************* * CONFIRM_, *******************************************************************/ case CURgENTRY_EXISTENCE_: case CURrENTRY_EXISTENCE_: case CURzENTRY_EXISTENCE_: case CDF_CHECKSUM_: break; /******************************************************************* * CONFIRM_, *******************************************************************/ 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_, *******************************************************************/ case rVAR_SEQPOS_: case zVAR_SEQPOS_: { (void) va_arg (Va.ap, Int32 *); (void) va_arg (Va.ap, Int32 *); break; } /******************************************************************* * CONFIRM_, *******************************************************************/ 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_, **************************************************************************/ case GET_: for (;;) { Va.item = (long) *(va_arg (Va.ap, Int32 *)); switch (Va.item) { /******************************************************************* * GET_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ case rVAR_NUMBER_: case zVAR_NUMBER_: case ATTR_NUMBER_: { (void) va_arg (Va.ap, void *); (void) va_arg (Va.ap, Int32 *); (*sCp)++; break; } /******************************************************************* * GET_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, **************************************************************************/ case PUT_: for (;;) { Va.item = (long) *(va_arg (Va.ap, Int32 *)); switch (Va.item) { /******************************************************************* * PUT_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ case rVAR_NAME_: case zVAR_NAME_: case ATTR_NAME_: { (void) va_arg (Va.ap, void *); (*sCp)++; break; } /******************************************************************* * PUT_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_,. *******************************************************************/ 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_,. *******************************************************************/ 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_, *******************************************************************/ 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_,. *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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_, *******************************************************************/ 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 }