1 /******************************************************************************
2 *
3 * NSSDC/CDF CDF Internal Interface/FORTRAN.
4 *
5 * Version 1.8b, 21-Feb-97, Hughes STX.
6 *
7 * Modification history:
8 *
9 * V1.0 30-Jan-91, J Love Original version (for CDF V2.1).
10 * V1.1 6-Aug-91, J Love Use 'CDFlib'. If variable is a character data
11 * type, check for %DESCR (if VMS).
12 * V1.2 24-Oct-91, J Love Modified for IBM-PC and IBM-RS6000 ports.
13 * V1.3 20-May-92, J Love CDF V2.2.
14 * V1.4 16-Sep-92, J Love CDF V2.3 (shareable/NeXT/zVar).
15 * V1.5 19-Jan-94, J Love CDF V2.4.
16 * V1.5a 4-Feb-94, J Love DEC Alpha/OpenVMS port.
17 * V1.5b 22-Feb-94, J Love Spelling lesson.
18 * V1.5c 29-Mar-94, J Love Solaris using GNU C compiler.
19 * V1.6 21-Dec-94, J Love CDF V2.5.
20 * V1.7 19-Jan-95, J Love IRIX 6.0 (64-bit).
21 * V1.7a 30-Jan-95, J Love `int sC' -> `Int32 sC'.
22 * V1.7b 13-Jun-95, J Love Linux.
23 * V1.8 5-Aug-96, J Love CDF V2.6 (renamed - previously `cdf_i_if.c').
24 * V1.8a 2-Dec-96, J Love Fixed declaration of `i' (now `int').
25 * V1.8b 21-Feb-97, J Love Removed RICE.
26 *
27 ******************************************************************************/
28
29 /******************************************************************************
30 *
31 * Notes:
32 *
33 * For the FORTRAN interfaces everything is indexed from one (1) while for
34 * the C interfaces everything is indexed from zero (0) [eg. variable and
35 * attribute numbers, record numbers, indices, entry numbers]. For this
36 * reason one (1) is subtracted from arguments passed in while one (1) is
37 * added to arguments passed out (where appropriate).
38 *
39 * The FORTRAN interfaces use INTEGER*4 as the data type for all numerical
40 * values passed in/out while the C interfaces use `long'. These are the same
41 * on all supported platforms except the DEC Alpha (where `long' is 8 bytes).
42 * For this reason temporary variables/arrays of size `long' are used in the
43 * calls to the CDF library (the direct C interface). This causes a small
44 * performance loss on the other platforms mainly when reading/writing single
45 * values repeatly (but then the hyper reads/writes should have been used
46 * instead).
47 *
48 ******************************************************************************/
49
50 /******************************************************************************
51 *
52 * Notes for VMS:
53 *
54 * To make the user's life a little easier, all names and attribute
55 * values (for attributes of data types CDF_CHAR and CDF_UCHAR) may be passed
56 * in and out by either reference or descriptor. The default passing mode
57 * for an embedded character string (e.g., CALL subr (..., 'string', ...)) or
58 * a CHARACTER variable symbol (e.g., CALL subr (..., ATTR_NAME, ...) where
59 * ATTR_NAME is defined as CHARACTER*8) is by descriptor when passing from
60 * FORTRAN to C in VMS.
61 *
62 * An embedded character string could be enclosed in %REF() to force
63 * passing by reference since the FORTRAN compiler puts a NUL character at
64 * the end of these strings as expected by the CDF V2.0 library (written in
65 * C). Enclosing a CHARACTER variable symbol in %REF() will result in
66 * an error, however, because a NUL character is not placed at the ends of
67 * these type strings by the FORTRAN compiler. The user would have to
68 * supply the terminating NUL. By letting the passing mode default to by-
69 * descriptor, this interface will supply the terminating NUL.
70 *
71 * The main difference here from CDF Version 1 is that the %REF() is
72 * not needed when passing out names and attribute values. Also, %REF()
73 * is not necessary when passing the value of a variable that is a character
74 * data type.
75 *
76 ******************************************************************************/
77
78 /******************************************************************************
79 *
80 * Notes for UNIX:
81 *
82 * All passing between FORTRAN and C on UNIX systems is done by reference.
83 * When character strings are passed between FORTRAN and C, extra arguments
84 * are added to the argument list containing the lengths of those character
85 * strings (EXCEPT on NeXT machines - FORTRAN applications must NUL-terminate
86 * passed character strings).
87 *
88 * Entry points have been made lowercase because the FORTRAN compiler
89 * converts all uppercase characters to lowercase in entry points. This way
90 * the linker will find everything. Unix FORTRAN compilers and linkers also
91 * seem to like trailing '_'s (except on the IBM-RS6000/AIX, HP9000/HP-UX,
92 * and NeXT/Mach).
93 *
94 ******************************************************************************/
95
96 /******************************************************************************
97 *
98 * Notes for Macintosh (MPW C/Fortran):
99 *
100 * In order to get the Internal Interface to work with MPW Fortran a separate
101 * entry point has been created for each possible number of arguments. They
102 * are called CDF_lib_1, CDF_lib_2,... CDF_lib_n. This is because MPW Fortran
103 * will not allow varying numbers of arguments to the same subroutine/function.
104 * An application must use CDF_lib_x when there are `x' arguments in the call.
105 *
106 ******************************************************************************/
107
108 #include "cdflib.h"
109
110 /******************************************************************************
111 * Local function prototypes.
112 ******************************************************************************/
113
114 static size_t PickMaxLen PROTOARGs((long requiredArgument, ...));
115
116 VISIBLE_PREFIX
117 Int32
118 Fif_PREFIXb
119 Fif_ENTRYPOINT(cdf_lib__,cdf_lib_,cdf_lib,CDF_LIB)
120 VARPROTOARGs((Int32 *requiredFnc, ...));
121
122 #define CDF_LIBx Fif_ENTRYPOINT(cdf_lib__,cdf_lib_,cdf_lib,CDF_LIB)
123 static CDFid currentCDFid = NULL;
124 /******************************************************************************
125 * CDF_lib. Note that CDFstatus is returned both as an argument (the last
126 * argument) and as the value of the function.
127 ******************************************************************************/
128
129 VISIBLE_PREFIX
130 Int32
131 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib__,cdf_lib_,cdf_lib,CDF_LIB)132 Fif_ENTRYPOINT(cdf_lib__,cdf_lib_,cdf_lib,CDF_LIB)
133 #if defined(STDARG)
134 (Int32 *requiredFnc, ...)
135 #else
136 (va_alist)
137 va_dcl
138 #endif
139 {
140 CDFstatus pStatus = CDF_OK; /* Pending status. */
141 CDFstatus tStatus; /* Temporary status. */
142 Int32 *status; /* Address of `status' variable. */
143 struct VAstruct Va;
144 struct STRINGstruct *ssh = NULL; /* Head of STRINGstruct linked list. */
145
146 #if !defined(STDARG)
147 Int32 *fncP; /* Pointer to required function. */
148 #endif
149
150 #if defined(Fif_GHOSTLEN)
151 int i;
152 Int32 sC = 0; /* String count. Number of (possible) strings
153 passed in. */
154 Int32 *sCp; /* Pointer to string count. */
155 Int32 *sLs; /* Lengths of (possible) character strings passed
156 in - some arguments may or may not be character
157 strings (eg. variable/entry data). */
158 #endif
159
160 #if defined(Fif_GHOSTLEN)
161 /******************************************************************************
162 * Scan argument list counting number of (possible) strings passed in.
163 ******************************************************************************/
164
165 #if defined(STDARG)
166 va_start (Va.ap, requiredFnc);
167 if (*requiredFnc == 0) {
168 sCp = requiredFnc;
169 Va.fnc = (long) *(va_arg (Va.ap, Int32 *));
170 }
171 else {
172 sCp = &sC;
173 Va.fnc = (long) *requiredFnc;
174 }
175 #else
176 VA_START (Va.ap);
177 fncP = va_arg (Va.ap, Int32 *);
178 if (*fncP == 0) {
179 sCp = fncP;
180 Va.fnc = (long) *(va_arg (Va.ap, Int32 *));
181 }
182 else {
183 sCp = &sC;
184 Va.fnc = (long) *fncP;
185 }
186 #endif
187
188 while (Va.fnc != NULL_) {
189 switch (Va.fnc) {
190 /**************************************************************************
191 * CREATE_,<item>
192 **************************************************************************/
193 case CREATE_:
194 for (;;) {
195 Va.item = (long) *(va_arg (Va.ap, Int32 *));
196 switch (Va.item) {
197 /*******************************************************************
198 * CREATE_,CDF_
199 *******************************************************************/
200 case CDF_: {
201 (void) va_arg (Va.ap, void *);
202 (void) va_arg (Va.ap, Int32 *);
203 (void) va_arg (Va.ap, Int32 *);
204 (void) va_arg (Va.ap, Int32 *);
205 (*sCp)++;
206 break;
207 }
208 /*******************************************************************
209 * CREATE_,rVAR_
210 *******************************************************************/
211 case rVAR_: {
212 (void) va_arg (Va.ap, void *);
213 (void) va_arg (Va.ap, Int32 *);
214 (void) va_arg (Va.ap, Int32 *);
215 (void) va_arg (Va.ap, Int32 *);
216 (void) va_arg (Va.ap, Int32 *);
217 (void) va_arg (Va.ap, Int32 *);
218 (*sCp)++;
219 break;
220 }
221 /*******************************************************************
222 * CREATE_,zVAR_
223 *******************************************************************/
224 case zVAR_: {
225 (void) va_arg (Va.ap, void *);
226 (void) va_arg (Va.ap, Int32 *);
227 (void) va_arg (Va.ap, Int32 *);
228 (void) va_arg (Va.ap, Int32 *);
229 (void) va_arg (Va.ap, Int32 *);
230 (void) va_arg (Va.ap, Int32 *);
231 (void) va_arg (Va.ap, Int32 *);
232 (void) va_arg (Va.ap, Int32 *);
233 (*sCp)++;
234 break;
235 }
236 /*******************************************************************
237 * CREATE_,ATTR_
238 *******************************************************************/
239 case ATTR_: {
240 (void) va_arg (Va.ap, void *);
241 (void) va_arg (Va.ap, Int32 *);
242 (void) va_arg (Va.ap, Int32 *);
243 (*sCp)++;
244 break;
245 }
246 /*******************************************************************
247 * Unknown - hopefully the next operation.
248 *******************************************************************/
249 default: {
250 Va.fnc = Va.item;
251 break;
252 }
253 }
254 if (Va.fnc == Va.item) break;
255 }
256 break;
257 /**************************************************************************
258 * OPEN_,<item>
259 **************************************************************************/
260 case OPEN_:
261 for (;;) {
262 Va.item = (long) *(va_arg (Va.ap, Int32 *));
263 switch (Va.item) {
264 /*******************************************************************
265 * OPEN_,CDF_
266 *******************************************************************/
267 case CDF_: {
268 (void) va_arg (Va.ap, void *);
269 (void) va_arg (Va.ap, Int32 *);
270 (*sCp)++;
271 break;
272 }
273 /*******************************************************************
274 * Unknown - hopefully the next operation.
275 *******************************************************************/
276 default: {
277 Va.fnc = Va.item;
278 break;
279 }
280 }
281 if (Va.fnc == Va.item) break;
282 }
283 break;
284 /**************************************************************************
285 * DELETE_,<item>
286 **************************************************************************/
287 case DELETE_:
288 for (;;) {
289 Va.item = (long) *(va_arg (Va.ap, Int32 *));
290 switch (Va.item) {
291 /*******************************************************************
292 * DELETE_,<object>
293 *******************************************************************/
294 case CDF_:
295 case zVAR_:
296 case rVAR_:
297 case ATTR_:
298 case gENTRY_:
299 case zENTRY_:
300 case rENTRY_:
301 break;
302 /*******************************************************************
303 * DELETE_,r|zVAR_RECORDS_
304 *******************************************************************/
305 case rVAR_RECORDS_:
306 case zVAR_RECORDS_: {
307 (void) va_arg (Va.ap, Int32 *);
308 (void) va_arg (Va.ap, Int32 *);
309 break;
310 }
311 /*******************************************************************
312 * Unknown - hopefully the next operation.
313 *******************************************************************/
314 default: {
315 Va.fnc = Va.item;
316 break;
317 }
318 }
319 if (Va.fnc == Va.item) break;
320 }
321 break;
322 /**************************************************************************
323 * CLOSE_,<item>
324 **************************************************************************/
325 case CLOSE_:
326 for (;;) {
327 Va.item = (long) *(va_arg (Va.ap, Int32 *));
328 switch (Va.item) {
329 /*******************************************************************
330 * CLOSE_,CDF_
331 *******************************************************************/
332 case CDF_: {
333 break;
334 }
335 /*******************************************************************
336 * CLOSE_,r/zVAR_
337 *******************************************************************/
338 case rVAR_:
339 case zVAR_: {
340 break;
341 }
342 /*******************************************************************
343 * Unknown - hopefully the next operation.
344 *******************************************************************/
345 default: {
346 Va.fnc = Va.item;
347 break;
348 }
349 }
350 if (Va.fnc == Va.item) break;
351 }
352 break;
353 /**************************************************************************
354 * SELECT_,<item>
355 **************************************************************************/
356 case SELECT_:
357 for (;;) {
358 Va.item = (long) *(va_arg (Va.ap, Int32 *));
359 switch (Va.item) {
360 /*******************************************************************
361 * SELECT_,<Int32 * or Int32 []>
362 *******************************************************************/
363 case CDF_:
364 case CDF_STATUS_:
365 case CDF_READONLY_MODE_:
366 case CDF_zMODE_:
367 case CDF_NEGtoPOSfp0_MODE_:
368 case CDF_DECODING_:
369 case CDF_CACHESIZE_:
370 case STAGE_CACHESIZE_:
371 case COMPRESS_CACHESIZE_:
372 case rVARs_CACHESIZE_:
373 case zVARs_CACHESIZE_:
374 case rVAR_CACHESIZE_:
375 case zVAR_CACHESIZE_:
376 case rVAR_:
377 case zVAR_:
378 case rVARs_RECNUMBER_:
379 case zVARs_RECNUMBER_:
380 case zVAR_RECNUMBER_:
381 case rVARs_RECCOUNT_:
382 case zVAR_RECCOUNT_:
383 case rVARs_RECINTERVAL_:
384 case zVAR_RECINTERVAL_:
385 case rVARs_DIMINDICES_:
386 case zVAR_DIMINDICES_:
387 case rVARs_DIMCOUNTS_:
388 case zVAR_DIMCOUNTS_:
389 case rVARs_DIMINTERVALS_:
390 case zVAR_DIMINTERVALS_:
391 case rVAR_RESERVEPERCENT_:
392 case zVAR_RESERVEPERCENT_:
393 case ATTR_:
394 case gENTRY_:
395 case rENTRY_:
396 case zENTRY_: {
397 (void) va_arg (Va.ap, Int32 *);
398 break;
399 }
400 /*******************************************************************
401 * SELECT_,<Int32 *, Int32 *>
402 *******************************************************************/
403 case rVAR_SEQPOS_:
404 case zVAR_SEQPOS_: {
405 (void) va_arg (Va.ap, Int32 *);
406 (void) va_arg (Va.ap, Int32 *);
407 break;
408 }
409 /*******************************************************************
410 * SELECT_,<void * (string)>
411 *******************************************************************/
412 case CDF_SCRATCHDIR_:
413 case rVAR_NAME_:
414 case zVAR_NAME_:
415 case ATTR_NAME_:
416 case rENTRY_NAME_:
417 case zENTRY_NAME_: {
418 (void) va_arg (Va.ap, void *);
419 (*sCp)++;
420 break;
421 }
422 /*******************************************************************
423 * Unknown item - hopefully the next operation.
424 *******************************************************************/
425 default: {
426 Va.fnc = Va.item;
427 break;
428 }
429 }
430 if (Va.fnc == Va.item) break;
431 }
432 break;
433 /**************************************************************************
434 * CONFIRM_,<item>
435 **************************************************************************/
436 case CONFIRM_:
437 for (;;) {
438 Va.item = (long) *(va_arg (Va.ap, Int32 *));
439 switch (Va.item) {
440 /*******************************************************************
441 * CONFIRM_,<no arguments>
442 *******************************************************************/
443 case CURgENTRY_EXISTENCE_:
444 case CURrENTRY_EXISTENCE_:
445 case CURzENTRY_EXISTENCE_:
446 case CDF_CHECKSUM_:
447 break;
448 /*******************************************************************
449 * CONFIRM_,<Int32 * or Int32 []>
450 *******************************************************************/
451 case CDF_READONLY_MODE_:
452 case CDF_zMODE_:
453 case CDF_NEGtoPOSfp0_MODE_:
454 case CDF_DECODING_:
455 case CDF_CACHESIZE_:
456 case STAGE_CACHESIZE_:
457 case COMPRESS_CACHESIZE_:
458 case rVAR_CACHESIZE_:
459 case zVAR_CACHESIZE_:
460 case rVAR_:
461 case zVAR_:
462 case rVARs_RECNUMBER_:
463 case zVAR_RECNUMBER_:
464 case rVARs_RECCOUNT_:
465 case zVAR_RECCOUNT_:
466 case rVARs_RECINTERVAL_:
467 case zVAR_RECINTERVAL_:
468 case rVARs_DIMINDICES_:
469 case zVAR_DIMINDICES_:
470 case rVARs_DIMCOUNTS_:
471 case zVAR_DIMCOUNTS_:
472 case rVARs_DIMINTERVALS_:
473 case zVAR_DIMINTERVALS_:
474 case rVAR_RESERVEPERCENT_:
475 case zVAR_RESERVEPERCENT_:
476 case ATTR_:
477 case gENTRY_:
478 case rENTRY_:
479 case zENTRY_:
480 case gENTRY_EXISTENCE_:
481 case rENTRY_EXISTENCE_:
482 case zENTRY_EXISTENCE_: {
483 (void) va_arg (Va.ap, Int32 *);
484 break;
485 }
486 /*******************************************************************
487 * CONFIRM_,<Int32 *, Int32 *>
488 *******************************************************************/
489 case rVAR_SEQPOS_:
490 case zVAR_SEQPOS_: {
491 (void) va_arg (Va.ap, Int32 *);
492 (void) va_arg (Va.ap, Int32 *);
493 break;
494 }
495 /*******************************************************************
496 * CONFIRM_,<void * (string)>
497 *******************************************************************/
498 case CDF_NAME_:
499 case rVAR_EXISTENCE_:
500 case zVAR_EXISTENCE_:
501 case ATTR_EXISTENCE_: {
502 (void) va_arg (Va.ap, void *);
503 (*sCp)++;
504 break;
505 }
506 /*******************************************************************
507 * Unknown - hopefully the next operation.
508 *******************************************************************/
509 default: {
510 Va.fnc = Va.item;
511 break;
512 }
513 }
514 if (Va.fnc == Va.item) break;
515 }
516 break;
517 /**************************************************************************
518 * GET_,<item>
519 **************************************************************************/
520 case GET_:
521 for (;;) {
522 Va.item = (long) *(va_arg (Va.ap, Int32 *));
523 switch (Va.item) {
524 /*******************************************************************
525 * GET_,<Int32 *>
526 *******************************************************************/
527 case rVARs_NUMDIMS_:
528 case zVAR_NUMDIMS_:
529 case rVARs_DIMSIZES_:
530 case zVAR_DIMSIZES_:
531 case CDF_ENCODING_:
532 case CDF_MAJORITY_:
533 case CDF_FORMAT_:
534 case CDF_NUMrVARS_:
535 case CDF_NUMzVARS_:
536 case CDF_NUMATTRS_:
537 case CDF_NUMgATTRS_:
538 case CDF_NUMvATTRS_:
539 case rVARs_MAXREC_:
540 case zVARs_MAXREC_:
541 case CDF_VERSION_:
542 case CDF_RELEASE_:
543 case CDF_INCREMENT_:
544 case LIB_VERSION_:
545 case LIB_RELEASE_:
546 case LIB_INCREMENT_:
547 case rVAR_DATATYPE_:
548 case zVAR_DATATYPE_:
549 case rVAR_NUMELEMS_:
550 case zVAR_NUMELEMS_:
551 case rVAR_RECVARY_:
552 case zVAR_RECVARY_:
553 case rVAR_DIMVARYS_:
554 case zVAR_DIMVARYS_:
555 case rVAR_MAXREC_:
556 case zVAR_MAXREC_:
557 case rVAR_MAXallocREC_:
558 case zVAR_MAXallocREC_:
559 case rVAR_NUMRECS_:
560 case zVAR_NUMRECS_:
561 case rVAR_NUMallocRECS_:
562 case zVAR_NUMallocRECS_:
563 case rVAR_BLOCKINGFACTOR_:
564 case zVAR_BLOCKINGFACTOR_:
565 case rVAR_nINDEXRECORDS_:
566 case zVAR_nINDEXRECORDS_:
567 case rVAR_nINDEXENTRIES_:
568 case zVAR_nINDEXENTRIES_:
569 case rVAR_nINDEXLEVELS_:
570 case zVAR_nINDEXLEVELS_:
571 case rVAR_SPARSERECORDS_:
572 case zVAR_SPARSERECORDS_:
573 case ATTR_SCOPE_:
574 case ATTR_MAXgENTRY_:
575 case ATTR_MAXrENTRY_:
576 case ATTR_MAXzENTRY_:
577 case ATTR_NUMgENTRIES_:
578 case ATTR_NUMrENTRIES_:
579 case ATTR_NUMzENTRIES_:
580 case gENTRY_DATATYPE_:
581 case rENTRY_DATATYPE_:
582 case zENTRY_DATATYPE_:
583 case gENTRY_NUMELEMS_:
584 case rENTRY_NUMELEMS_:
585 case zENTRY_NUMELEMS_:
586 case CDF_CHECKSUM_: {
587 (void) va_arg (Va.ap, Int32 *);
588 break;
589 }
590 /*******************************************************************
591 * GET_,<Int32 *, Int32 *>
592 *******************************************************************/
593 case rVAR_ALLOCATEDFROM_:
594 case zVAR_ALLOCATEDFROM_:
595 case rVAR_ALLOCATEDTO_:
596 case zVAR_ALLOCATEDTO_:
597 case DATATYPE_SIZE_: {
598 (void) va_arg (Va.ap, Int32 *);
599 (void) va_arg (Va.ap, Int32 *);
600 break;
601 }
602 /*******************************************************************
603 * GET_,<Int32 *, Int32 *, Int32 *>
604 *******************************************************************/
605 case CDF_COMPRESSION_:
606 case rVAR_COMPRESSION_:
607 case zVAR_COMPRESSION_:
608 case rVAR_SPARSEARRAYS_:
609 case zVAR_SPARSEARRAYS_: {
610 (void) va_arg (Va.ap, Int32 *);
611 (void) va_arg (Va.ap, Int32 *);
612 (void) va_arg (Va.ap, Int32 *);
613 break;
614 }
615 /*******************************************************************
616 * GET_,<void * (string)>
617 *******************************************************************/
618 case CDF_COPYRIGHT_:
619 case LIB_COPYRIGHT_:
620 case LIB_subINCREMENT_:
621 case rVAR_NAME_:
622 case zVAR_NAME_:
623 case ATTR_NAME_:
624 case STATUS_TEXT_: {
625 (void) va_arg (Va.ap, void *);
626 (*sCp)++;
627 break;
628 }
629 /*******************************************************************
630 * GET_,<void * (string), Int32 *>
631 *******************************************************************/
632 case rVAR_NUMBER_:
633 case zVAR_NUMBER_:
634 case ATTR_NUMBER_: {
635 (void) va_arg (Va.ap, void *);
636 (void) va_arg (Va.ap, Int32 *);
637 (*sCp)++;
638 break;
639 }
640 /*******************************************************************
641 * GET_,<void * (string), Int32 *, Int32 *, Int32 *, Int32 *>
642 *******************************************************************/
643 case CDF_INFO_: {
644 (void) va_arg (Va.ap, void *);
645 (void) va_arg (Va.ap, Int32 *);
646 (void) va_arg (Va.ap, Int32 *);
647 (void) va_arg (Va.ap, void *);
648 (void) va_arg (Va.ap, void *);
649 (*sCp)++;
650 break;
651 }
652 /*******************************************************************
653 * GET_,<void * (possible string)>
654 *******************************************************************/
655 case rVAR_PADVALUE_:
656 case zVAR_PADVALUE_:
657 case rVAR_DATA_:
658 case zVAR_DATA_:
659 case rVAR_HYPERDATA_:
660 case zVAR_HYPERDATA_:
661 case rVAR_SEQDATA_:
662 case zVAR_SEQDATA_:
663 case gENTRY_DATA_:
664 case rENTRY_DATA_:
665 case zENTRY_DATA_: {
666 (void) va_arg (Va.ap, void *);
667 (*sCp)++;
668 break;
669 }
670 /*******************************************************************
671 * GET_,<void * (cannot be string)>
672 *******************************************************************/
673 case rVARs_RECDATA_:
674 case zVARs_RECDATA_: {
675 Int32 *nVars = va_arg (Va.ap, Int32 *);
676 Int32 *varNs = va_arg (Va.ap, Int32 *);
677 (void) va_arg (Va.ap, void *);
678 break;
679 }
680 /*******************************************************************
681 * Unknown - hopefully the next operation.
682 *******************************************************************/
683 default: {
684 Va.fnc = Va.item;
685 break;
686 }
687 }
688 if (Va.fnc == Va.item) break;
689 }
690 break;
691 /**************************************************************************
692 * PUT_,<item>
693 **************************************************************************/
694 case PUT_:
695 for (;;) {
696 Va.item = (long) *(va_arg (Va.ap, Int32 *));
697 switch (Va.item) {
698 /*******************************************************************
699 * PUT_,<Int32 *>
700 *******************************************************************/
701 case CDF_ENCODING_:
702 case CDF_MAJORITY_:
703 case CDF_FORMAT_:
704 case rVAR_RECVARY_:
705 case zVAR_RECVARY_:
706 case rVAR_DIMVARYS_:
707 case zVAR_DIMVARYS_:
708 case rVAR_ALLOCATERECS_:
709 case zVAR_ALLOCATERECS_:
710 case rVAR_INITIALRECS_:
711 case zVAR_INITIALRECS_:
712 case rVAR_BLOCKINGFACTOR_:
713 case zVAR_BLOCKINGFACTOR_:
714 case rVAR_SPARSERECORDS_:
715 case zVAR_SPARSERECORDS_:
716 case ATTR_SCOPE_:
717 case CDF_CHECKSUM_: {
718 (void) va_arg (Va.ap, Int32 *);
719 break;
720 }
721 /*******************************************************************
722 * PUT_,<Int32 *, Int32 *>
723 *******************************************************************/
724 case CDF_COMPRESSION_:
725 case rVAR_DATASPEC_:
726 case zVAR_DATASPEC_:
727 case rVAR_COMPRESSION_:
728 case zVAR_COMPRESSION_:
729 case rVAR_SPARSEARRAYS_:
730 case zVAR_SPARSEARRAYS_:
731 case rVAR_ALLOCATEBLOCK_:
732 case zVAR_ALLOCATEBLOCK_:
733 case gENTRY_DATASPEC_:
734 case rENTRY_DATASPEC_:
735 case zENTRY_DATASPEC_: {
736 (void) va_arg (Va.ap, Int32 *);
737 (void) va_arg (Va.ap, Int32 *);
738 break;
739 }
740 /*******************************************************************
741 * PUT_,<void * (string)>
742 *******************************************************************/
743 case rVAR_NAME_:
744 case zVAR_NAME_:
745 case ATTR_NAME_: {
746 (void) va_arg (Va.ap, void *);
747 (*sCp)++;
748 break;
749 }
750 /*******************************************************************
751 * PUT_,<void * (possible string)>
752 *******************************************************************/
753 case rVAR_PADVALUE_:
754 case zVAR_PADVALUE_:
755 case rVAR_DATA_:
756 case zVAR_DATA_:
757 case rVAR_HYPERDATA_:
758 case zVAR_HYPERDATA_:
759 case rVAR_SEQDATA_:
760 case zVAR_SEQDATA_: {
761 (void) va_arg (Va.ap, void *);
762 (*sCp)++;
763 break;
764 }
765 /*******************************************************************
766 * PUT_,<void * (cannot be string)>
767 *******************************************************************/
768 case rVARs_RECDATA_:
769 case zVARs_RECDATA_: {
770 (void) va_arg (Va.ap, Int32 *);
771 (void) va_arg (Va.ap, Int32 *);
772 (void) va_arg (Va.ap, void *);
773 break;
774 }
775 /*******************************************************************
776 * PUT_,<Int32 *, Int32 *, void * (possible string)>
777 *******************************************************************/
778 case gENTRY_DATA_:
779 case rENTRY_DATA_:
780 case zENTRY_DATA_: {
781 (void) va_arg (Va.ap, Int32 *);
782 (void) va_arg (Va.ap, Int32 *);
783 (void) va_arg (Va.ap, void *);
784 (*sCp)++;
785 break;
786 }
787 /*******************************************************************
788 * Unknown - hopefully the next operation.
789 *******************************************************************/
790 default: {
791 Va.fnc = Va.item;
792 break;
793 }
794 }
795 if (Va.fnc == Va.item) break;
796 }
797 break;
798 /**************************************************************************
799 * Unknown - this is bad. We're lost.
800 **************************************************************************/
801 default:
802 va_end (Va.ap);
803 return ((Int32) BAD_FNC_OR_ITEM);
804 }
805 }
806
807 status = va_arg (Va.ap, Int32 *);
808
809 /******************************************************************************
810 * Return if only counting possible character strings.
811 ******************************************************************************/
812
813 if (sCp != &sC) {
814 va_end (Va.ap);
815 return CDF_OK;
816 }
817
818 /******************************************************************************
819 * Store character string lengths.
820 ******************************************************************************/
821
822 if (sC > 0) {
823 sLs = (Int32 *) cdf_AllocateMemory (sC * sizeof(Int32), NULL);
824 if (sLs == NULL) {
825 *status = (Int32) BAD_MALLOC;
826 return ((Int32) BAD_MALLOC);
827 }
828 for (i = 0; i < sC; i++) sLs[i] = Fif_GHOSTFETCH (Va.ap);
829 }
830 else
831 sLs = NULL;
832 va_end (Va.ap);
833 #endif
834
835 /******************************************************************************
836 * Scan argument list performing functions.
837 ******************************************************************************/
838
839 #if defined(Fif_GHOSTLEN)
840 sC = 0; /* start at beginning of list of string lengths */
841 #endif
842
843 #if defined(STDARG)
844 va_start (Va.ap, requiredFnc);
845 Va.fnc = (long) *requiredFnc;
846 #else
847 VA_START (Va.ap);
848 Va.fnc = (long) *(va_arg (Va.ap, Int32 *));
849 #endif
850
851 while (Va.fnc != NULL_)
852 switch (Va.fnc) {
853 /**************************************************************************
854 * CREATE_
855 **************************************************************************/
856 case CREATE_:
857 for (;;) {
858 Va.item = (long) *(va_arg (Va.ap, Int32 *));
859 switch (Va.item) {
860 /*******************************************************************
861 * CREATE_,CDF_
862 *******************************************************************/
863 case CDF_: {
864 void *CDFname = va_arg (Va.ap, void *);
865 Int32 numDims = *(va_arg (Va.ap, Int32 *));
866 Int32 *dimSizes = va_arg (Va.ap, Int32 *);
867 Int32 *id = va_arg (Va.ap, Int32 *);
868 int dimN; long dimSizesT[CDF_MAX_DIMS]; CDFid idT;
869 if (StatusBAD(pStatus)) break;
870 if (numDims < 0 || numDims > CDF_MAX_DIMS) {
871 if (!sX(BAD_NUM_DIMS,&pStatus)) break;
872 }
873 for (dimN = 0; dimN < numDims; dimN++) {
874 dimSizesT[dimN] = (long) dimSizes[dimN];
875 }
876 tStatus = CDFlib (CREATE_, CDF_,
877 #if defined(Fif_DESCR)
878 DESCRtoREFnul(CDFname,
879 CDF_PATHNAME_LEN,
880 &ssh),
881 #endif
882 #if defined(Fif_GHOSTLEN)
883 NULterminate(CDFname,sLs[sC],
884 &ssh),
885 #endif
886 #if defined(Fif_NOLEN)
887 FindEndNUL(CDFname,
888 CDF_PATHNAME_LEN,
889 &ssh),
890 #endif
891 (long) numDims, dimSizesT, &idT,
892 NULL_);
893 if (!sX(tStatus,&pStatus)) break;
894
895 #if defined(Fif_GHOSTLEN)
896 sC++;
897 #endif
898 *id = CDFidToInt32 (idT);
899 currentCDFid = idT;
900 break;
901 }
902 /*******************************************************************
903 * CREATE_,rVAR_
904 *******************************************************************/
905 case rVAR_: {
906 void *varName = va_arg (Va.ap, void *);
907 Int32 dataType = *(va_arg (Va.ap, Int32 *));
908 Int32 numElements = *(va_arg (Va.ap, Int32 *));
909 Int32 recVariance = *(va_arg (Va.ap, Int32 *));
910 Int32 *dimVariances = va_arg (Va.ap, Int32 *);
911 Int32 *var_num = va_arg (Va.ap, Int32 *);
912 int dimN;
913 long numDims, dimVarysT[CDF_MAX_DIMS], varNumT;
914 int LFS = FALSE;
915 if (currentCDFid != NULL) {
916 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
917 if (isLFS(CDF)) LFS = TRUE;
918 }
919
920 if (StatusBAD(pStatus)) break;
921
922 tStatus = CDFlib (GET_, rVARs_NUMDIMS_, &numDims,
923 NULL_);
924 if (!sX(tStatus,&pStatus)) break;
925
926 for (dimN = 0; dimN < numDims; dimN++) {
927 dimVarysT[dimN] = (long) dimVariances[dimN];
928 }
929
930 tStatus = CDFlib (CREATE_, rVAR_,
931 #if defined(Fif_DESCR)
932 DESCRtoREFnul(varName,
933 (LFS ?
934 CDF_VAR_NAME_LEN256 :
935 CDF_VAR_NAME_LEN),
936 &ssh),
937 #endif
938 #if defined(Fif_GHOSTLEN)
939 NULterminate(varName,
940 sLs[sC],&ssh),
941 #endif
942 #if defined(Fif_NOLEN)
943 FindEndNUL(varName,
944 (LFS ?
945 CDF_VAR_NAME_LEN256 :
946 CDF_VAR_NAME_LEN),
947 &ssh),
948 #endif
949 (long) dataType,
950 (long) numElements,
951 (long) recVariance,
952 dimVarysT, &varNumT,
953 NULL_);
954 if (!sX(tStatus,&pStatus)) break;
955
956 #if defined(Fif_GHOSTLEN)
957 sC++;
958 #endif
959 *var_num = (Int32) (varNumT + 1);
960 break;
961 }
962 /*******************************************************************
963 * CREATE_,zVAR_
964 *******************************************************************/
965 case zVAR_: {
966 void *varName = va_arg (Va.ap, void *);
967 Int32 dataType = *(va_arg (Va.ap, Int32 *));
968 Int32 numElements = *(va_arg (Va.ap, Int32 *));
969 Int32 numDims = *(va_arg (Va.ap, Int32 *));
970 Int32 *dimSizes = va_arg (Va.ap, Int32 *);
971 Int32 recVariance = *(va_arg (Va.ap, Int32 *));
972 Int32 *dimVariances = va_arg (Va.ap, Int32 *);
973 Int32 *var_num = va_arg (Va.ap, Int32 *);
974 int dimN;
975 long varNumT, dimSizesT[CDF_MAX_DIMS], dimVarysT[CDF_MAX_DIMS];
976 int LFS = FALSE;
977 if (currentCDFid != NULL) {
978 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
979 if (isLFS(CDF)) LFS = TRUE;
980 }
981
982 if (StatusBAD(pStatus)) break;
983
984 if (numDims < 0 || numDims > CDF_MAX_DIMS)
985 if (!sX(BAD_NUM_DIMS,&pStatus)) break;
986
987 for (dimN = 0; dimN < numDims; dimN++) {
988 dimSizesT[dimN] = (long) dimSizes[dimN];
989 dimVarysT[dimN] = (long) dimVariances[dimN];
990 }
991
992 tStatus = CDFlib (CREATE_, zVAR_,
993 #if defined(Fif_DESCR)
994 DESCRtoREFnul(varName,
995 (LFS ?
996 CDF_VAR_NAME_LEN256 :
997 CDF_VAR_NAME_LEN),
998 &ssh),
999 #endif
1000 #if defined(Fif_GHOSTLEN)
1001 NULterminate(varName,sLs[sC],
1002 &ssh),
1003 #endif
1004 #if defined(Fif_NOLEN)
1005 FindEndNUL(varName,
1006 (LFS ?
1007 CDF_VAR_NAME_LEN256 :
1008 CDF_VAR_NAME_LEN),
1009 &ssh),
1010 #endif
1011 (long) dataType,
1012 (long) numElements,
1013 (long) numDims, dimSizesT,
1014 (long) recVariance, dimVarysT,
1015 &varNumT,
1016 NULL_);
1017 if (!sX(tStatus,&pStatus)) break;
1018
1019 #if defined(Fif_GHOSTLEN)
1020 sC++;
1021 #endif
1022 *var_num = (Int32) (varNumT + 1);
1023 break;
1024 }
1025 /*******************************************************************
1026 * CREATE_,ATTR_
1027 *******************************************************************/
1028 case ATTR_: {
1029 void *attrName = va_arg (Va.ap, void *);
1030 Int32 scope = *(va_arg (Va.ap, Int32 *));
1031 Int32 *attr_num = va_arg (Va.ap, Int32 *);
1032 long attrNumT;
1033 int LFS = FALSE;
1034 if (currentCDFid != NULL) {
1035 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
1036 if (isLFS(CDF)) LFS = TRUE;
1037 }
1038
1039 if (StatusBAD(pStatus)) break;
1040
1041 tStatus = CDFlib (CREATE_, ATTR_,
1042 #if defined(Fif_DESCR)
1043 DESCRtoREFnul(attrName,
1044 (LFS ?
1045 CDF_ATTR_NAME_LEN256 :
1046 CDF_ATTR_NAME_LEN),
1047 &ssh),
1048 #endif
1049 #if defined(Fif_GHOSTLEN)
1050 NULterminate(attrName,sLs[sC],
1051 &ssh),
1052 #endif
1053 #if defined(Fif_NOLEN)
1054 FindEndNUL(attrName,
1055 (LFS ?
1056 CDF_ATTR_NAME_LEN256 :
1057 CDF_ATTR_NAME_LEN),
1058 &ssh),
1059 #endif
1060 (long) scope, &attrNumT,
1061 NULL_);
1062 if (!sX(tStatus,&pStatus)) break;
1063
1064 #if defined(Fif_GHOSTLEN)
1065 sC++;
1066 #endif
1067 *attr_num = (Int32) (attrNumT + 1);
1068 break;
1069 }
1070 /*******************************************************************
1071 * Unknown item - hopefully the next function.
1072 *******************************************************************/
1073 default: {
1074 Va.fnc = Va.item;
1075 break;
1076 }
1077 }
1078 if (Va.fnc == Va.item) break;
1079 }
1080 break;
1081
1082 /**************************************************************************
1083 * OPEN_
1084 **************************************************************************/
1085 case OPEN_:
1086 for (;;) {
1087 Va.item = (long) *(va_arg (Va.ap, Int32 *));
1088 switch (Va.item) {
1089 /*******************************************************************
1090 * OPEN_,CDF_
1091 *******************************************************************/
1092 case CDF_: {
1093 void *CDFname = va_arg (Va.ap, void *);
1094 Int32 *id = va_arg (Va.ap, Int32 *);
1095 CDFid idT;
1096
1097 if (StatusBAD(pStatus)) break;
1098
1099 tStatus = CDFlib (OPEN_, CDF_,
1100 #if defined(Fif_DESCR)
1101 DESCRtoREFnul(CDFname,
1102 CDF_PATHNAME_LEN,
1103 &ssh),
1104 #endif
1105 #if defined(Fif_GHOSTLEN)
1106 NULterminate(CDFname,sLs[sC],
1107 &ssh),
1108 #endif
1109 #if defined(Fif_NOLEN)
1110 FindEndNUL(CDFname,
1111 CDF_PATHNAME_LEN,&ssh),
1112 #endif
1113 &idT,
1114 NULL_);
1115 if (!sX(tStatus,&pStatus)) break;
1116
1117 #if defined(Fif_GHOSTLEN)
1118 sC++;
1119 #endif
1120 *id = CDFidToInt32 (idT);
1121 break;
1122 }
1123 /*******************************************************************
1124 * Unknown item - hopefully the next function.
1125 *******************************************************************/
1126 default: {
1127 Va.fnc = Va.item;
1128 break;
1129 }
1130 }
1131 if (Va.fnc == Va.item) break;
1132 }
1133 break;
1134
1135 /**************************************************************************
1136 * DELETE_
1137 **************************************************************************/
1138 case DELETE_:
1139 for (;;) {
1140 Va.item = (long) *(va_arg (Va.ap, Int32 *));
1141 switch (Va.item) {
1142 /*******************************************************************
1143 * DELETE_,<object>
1144 *******************************************************************/
1145 case CDF_:
1146 case zVAR_:
1147 case rVAR_:
1148 case ATTR_:
1149 case gENTRY_:
1150 case zENTRY_:
1151 case rENTRY_:
1152 if (StatusBAD(pStatus)) break;
1153 tStatus = CDFlib (DELETE_, Va.item,
1154 NULL_);
1155 if (!sX(tStatus,&pStatus)) break;
1156 if (Va.item == CDF_) currentCDFid = NULL;
1157 break;
1158 /*******************************************************************
1159 * DELETE_,r|zVAR_RECORDS_
1160 *******************************************************************/
1161 case rVAR_RECORDS_:
1162 case zVAR_RECORDS_: {
1163 Int32 *ptr1 = va_arg (Va.ap, Int32 *);
1164 Int32 *ptr2 = va_arg (Va.ap, Int32 *);
1165 if (StatusBAD(pStatus)) break;
1166 tStatus = CDFlib (DELETE_, Va.item, (long) (*ptr1 - 1),
1167 (long) (*ptr2 - 1),
1168 NULL_);
1169 if (!sX(tStatus,&pStatus)) break;
1170 break;
1171 }
1172 /*******************************************************************
1173 * Unknown item - hopefully the next function.
1174 *******************************************************************/
1175 default: {
1176 Va.fnc = Va.item;
1177 break;
1178 }
1179 }
1180 if (Va.fnc == Va.item) break;
1181 }
1182 break;
1183
1184 /**************************************************************************
1185 * CLOSE_
1186 **************************************************************************/
1187 case CLOSE_:
1188 for (;;) {
1189 Va.item = (long) *(va_arg (Va.ap, Int32 *));
1190 switch (Va.item) {
1191 /*******************************************************************
1192 * CLOSE_,CDF_
1193 *******************************************************************/
1194 case CDF_: {
1195 if (StatusBAD(pStatus)) break;
1196 tStatus = CDFlib (CLOSE_, CDF_,
1197 NULL_);
1198 if (!sX(tStatus,&pStatus)) break;
1199 currentCDFid = NULL;
1200 break;
1201 }
1202 /*******************************************************************
1203 * CLOSE_,rVAR_/zVAR_
1204 *******************************************************************/
1205 case rVAR_:
1206 case zVAR_: {
1207 if (StatusBAD(pStatus)) break;
1208 tStatus = CDFlib (CLOSE_, Va.item,
1209 NULL_);
1210 if (!sX(tStatus,&pStatus)) break;
1211 break;
1212 }
1213 /*******************************************************************
1214 * Unknown item - hopefully the next function.
1215 *******************************************************************/
1216 default: {
1217 Va.fnc = Va.item;
1218 break;
1219 }
1220 }
1221 if (Va.fnc == Va.item) break;
1222 }
1223 break;
1224
1225 /**************************************************************************
1226 * SELECT_
1227 **************************************************************************/
1228 case SELECT_:
1229 for (;;) {
1230 Va.item = (long) *(va_arg (Va.ap, Int32 *));
1231 switch (Va.item) {
1232 /*******************************************************************
1233 * SELECT_,<Int32 * (pass by value)>
1234 *******************************************************************/
1235 case CDF_READONLY_MODE_:
1236 case CDF_zMODE_:
1237 case CDF_NEGtoPOSfp0_MODE_:
1238 case CDF_DECODING_:
1239 case CDF_CACHESIZE_:
1240 case STAGE_CACHESIZE_:
1241 case COMPRESS_CACHESIZE_:
1242 case rVARs_CACHESIZE_:
1243 case zVARs_CACHESIZE_:
1244 case rVAR_CACHESIZE_:
1245 case zVAR_CACHESIZE_:
1246 case rVARs_RECCOUNT_:
1247 case zVAR_RECCOUNT_:
1248 case rVARs_RECINTERVAL_:
1249 case zVAR_RECINTERVAL_:
1250 case rVAR_RESERVEPERCENT_:
1251 case zVAR_RESERVEPERCENT_: {
1252 Int32 value = *(va_arg (Va.ap, Int32 *));
1253 if (StatusBAD(pStatus)) break;
1254 tStatus = CDFlib (SELECT_, Va.item, (long) value,
1255 NULL_);
1256 if (!sX(tStatus,&pStatus)) break;
1257 break;
1258 }
1259 /*******************************************************************
1260 * SELECT_,<Int32 [] (pass by reference) - CDF_MAX_DIMS maximum>
1261 *******************************************************************/
1262 case rVARs_DIMCOUNTS_:
1263 case zVAR_DIMCOUNTS_:
1264 case rVARs_DIMINTERVALS_:
1265 case zVAR_DIMINTERVALS_: {
1266 Int32 *ptr = va_arg (Va.ap, Int32 *);
1267 Logical Z = (Va.item == zVAR_DIMCOUNTS_ ||
1268 Va.item == zVAR_DIMINTERVALS_);
1269 long numDims, valuesT[CDF_MAX_DIMS];
1270 int dimN;
1271
1272 if (StatusBAD(pStatus)) break;
1273
1274 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
1275 rVARs_NUMDIMS_), &numDims,
1276 NULL_);
1277 if (!sX(tStatus,&pStatus)) break;
1278
1279 for (dimN = 0; dimN < numDims; dimN++) {
1280 valuesT[dimN] = (long) ptr[dimN];
1281 }
1282
1283 tStatus = CDFlib (SELECT_, Va.item, valuesT,
1284 NULL_);
1285 if (!sX(tStatus,&pStatus)) break;
1286 break;
1287 }
1288 /*******************************************************************
1289 * SELECT_,<(Int32 *) - 1 [pass by value]>
1290 *******************************************************************/
1291 case rVAR_:
1292 case zVAR_:
1293 case rVARs_RECNUMBER_:
1294 case zVARs_RECNUMBER_:
1295 case zVAR_RECNUMBER_:
1296 case ATTR_:
1297 case gENTRY_:
1298 case rENTRY_:
1299 case zENTRY_: {
1300 Int32 value = *(va_arg (Va.ap, Int32 *));
1301 if (StatusBAD(pStatus)) break;
1302 tStatus = CDFlib (SELECT_, Va.item, (long) (value - 1),
1303 NULL_);
1304 if (!sX(tStatus,&pStatus)) break;
1305 break;
1306 }
1307 /*******************************************************************
1308 * SELECT_,<(Int32 [] - 1) [pass by reference] - CDF_MAX_DIMS
1309 * maximum>
1310 *******************************************************************/
1311 case rVARs_DIMINDICES_:
1312 case zVAR_DIMINDICES_: {
1313 Int32 *indices = va_arg (Va.ap, Int32 *);
1314 Logical Z = (Va.item == zVAR_DIMINDICES_);
1315 long numDims, indicesT[CDF_MAX_DIMS];
1316 int dimN;
1317
1318 if (StatusBAD(pStatus)) break;
1319
1320 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
1321 rVARs_NUMDIMS_), &numDims,
1322 NULL_);
1323 if (!sX(tStatus,&pStatus)) break;
1324
1325 for (dimN = 0; dimN < numDims; dimN++) {
1326 indicesT[dimN] = (long) (indices[dimN] - 1);
1327 }
1328
1329 tStatus = CDFlib (SELECT_, Va.item, indicesT,
1330 NULL_);
1331 if (!sX(tStatus,&pStatus)) break;
1332 break;
1333 }
1334 /*******************************************************************
1335 * SELECT_,<void * (character string)>
1336 *******************************************************************/
1337 case CDF_SCRATCHDIR_:
1338 case rVAR_NAME_:
1339 case zVAR_NAME_:
1340 case ATTR_NAME_:
1341 case rENTRY_NAME_:
1342 case zENTRY_NAME_: {
1343 void *ptr = va_arg (Va.ap, void *);
1344 int LFS = FALSE;
1345 size_t maxLen;
1346
1347 if (currentCDFid != NULL) {
1348 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
1349 if (isLFS(CDF)) LFS = TRUE;
1350 }
1351
1352 #if !defined(Fif_GHOSTLEN)
1353 maxLen = PickMaxLen (Va.item, 4,
1354 CDF_SCRATCHDIR_, (size_t) DU_MAX_DIR_LEN,
1355 rVAR_NAME_, (LFS ?
1356 (size_t) CDF_VAR_NAME_LEN256 :
1357 (size_t) CDF_VAR_NAME_LEN),
1358 zVAR_NAME_, (LFS ?
1359 (size_t) CDF_VAR_NAME_LEN256 :
1360 (size_t) CDF_VAR_NAME_LEN),
1361 ATTR_NAME_, (LFS ?
1362 (size_t) CDF_ATTR_NAME_LEN256 :
1363 (size_t) CDF_ATTR_NAME_LEN));
1364 #endif
1365
1366 if (StatusBAD(pStatus)) break;
1367
1368 tStatus = CDFlib (SELECT_, Va.item,
1369 #if defined(Fif_DESCR)
1370 DESCRtoREFnul(ptr,maxLen,&ssh),
1371 #endif
1372 #if defined(Fif_GHOSTLEN)
1373 NULterminate(ptr,sLs[sC],&ssh),
1374 #endif
1375 #if defined(Fif_NOLEN)
1376 FindEndNUL(ptr,maxLen,&ssh),
1377 #endif
1378 NULL_);
1379 if (!sX(tStatus,&pStatus)) break;
1380
1381 #if defined(Fif_GHOSTLEN)
1382 sC++;
1383 #endif
1384 break;
1385 }
1386 /*******************************************************************
1387 * SELECT_,CDF_
1388 *******************************************************************/
1389 case CDF_: {
1390 Int32 *id = va_arg (Va.ap, Int32 *);
1391 if (StatusBAD(pStatus)) break;
1392
1393 tStatus = CDFlib (SELECT_, CDF_, Int32ToCDFid(*id),
1394 NULL_);
1395 if (!sX(tStatus,&pStatus)) break;
1396 currentCDFid = Int32ToCDFid(*id);
1397 break;
1398 }
1399 /*******************************************************************
1400 * SELECT_,CDF_STATUS_
1401 *******************************************************************/
1402 case CDF_STATUS_: {
1403 Int32 newStatus = *(va_arg (Va.ap, Int32 *));
1404 if (StatusBAD(pStatus)) break;
1405 tStatus = CDFlib (SELECT_, CDF_STATUS_, (CDFstatus) newStatus,
1406 NULL_);
1407 if (!sX(tStatus,&pStatus)) break;
1408 break;
1409 }
1410 /*******************************************************************
1411 * SELECT_,rVAR_SEQPOS_/zVAR_SEQPOS_
1412 *******************************************************************/
1413 case rVAR_SEQPOS_:
1414 case zVAR_SEQPOS_: {
1415 Int32 rec_num = *(va_arg (Va.ap, Int32 *));
1416 Int32 *indices = va_arg (Va.ap, Int32 *);
1417 Logical Z = (Va.item == zVAR_SEQPOS_);
1418 long numDims, indicesT[CDF_MAX_DIMS];
1419 int dimN;
1420
1421 if (StatusBAD(pStatus)) break;
1422
1423 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
1424 rVARs_NUMDIMS_), &numDims,
1425 NULL_);
1426 if (!sX(tStatus,&pStatus)) break;
1427
1428 for (dimN = 0; dimN < numDims; dimN++) {
1429 indicesT[dimN] = (long) (indices[dimN] - 1);
1430 }
1431
1432 tStatus = CDFlib (SELECT_, Va.item, (long) (rec_num-1), indicesT,
1433 NULL_);
1434 if (!sX(tStatus,&pStatus)) break;
1435 break;
1436 }
1437 /*******************************************************************
1438 * Unknown item - hopefully the next function.
1439 *******************************************************************/
1440 default: {
1441 Va.fnc = Va.item;
1442 break;
1443 }
1444 }
1445 if (Va.fnc == Va.item) break;
1446 }
1447 break;
1448
1449 /**************************************************************************
1450 * CONFIRM_
1451 **************************************************************************/
1452 case CONFIRM_:
1453 for (;;) {
1454 Va.item = (long) *(va_arg (Va.ap, Int32 *));
1455 switch (Va.item) {
1456 /*******************************************************************
1457 * CONFIRM_,<no arguments>
1458 *******************************************************************/
1459 case CURgENTRY_EXISTENCE_:
1460 case CURrENTRY_EXISTENCE_:
1461 case CURzENTRY_EXISTENCE_:
1462 case CDF_CHECKSUM_: {
1463 if (StatusBAD(pStatus)) break;
1464 tStatus = CDFlib (CONFIRM_, Va.item,
1465 NULL_);
1466 if (!sX(tStatus,&pStatus)) break;
1467 break;
1468 }
1469 /*******************************************************************
1470 * CONFIRM_,<Int32 * [output]>
1471 *******************************************************************/
1472 case CDF_READONLY_MODE_:
1473 case CDF_zMODE_:
1474 case CDF_NEGtoPOSfp0_MODE_:
1475 case CDF_DECODING_:
1476 case CDF_CACHESIZE_:
1477 case STAGE_CACHESIZE_:
1478 case COMPRESS_CACHESIZE_:
1479 case rVAR_CACHESIZE_:
1480 case zVAR_CACHESIZE_:
1481 case rVARs_RECCOUNT_:
1482 case zVAR_RECCOUNT_:
1483 case rVARs_RECINTERVAL_:
1484 case zVAR_RECINTERVAL_:
1485 case rVAR_RESERVEPERCENT_:
1486 case zVAR_RESERVEPERCENT_: {
1487 Int32 *ptr = va_arg (Va.ap, Int32 *);
1488 long valueT;
1489 if (StatusBAD(pStatus)) break;
1490 tStatus = CDFlib (CONFIRM_, Va.item, &valueT,
1491 NULL_);
1492 if (!sX(tStatus,&pStatus)) break;
1493 *ptr = (Int32) valueT;
1494 break;
1495 }
1496 /*******************************************************************
1497 * CONFIRM_,<(Int32 *) + 1 [output]>
1498 *******************************************************************/
1499 case rVAR_:
1500 case zVAR_:
1501 case rVARs_RECNUMBER_:
1502 case zVAR_RECNUMBER_:
1503 case ATTR_:
1504 case gENTRY_:
1505 case rENTRY_:
1506 case zENTRY_: {
1507 Int32 *ptr = va_arg (Va.ap, Int32 *);
1508 long valueT;
1509 if (StatusBAD(pStatus)) break;
1510 tStatus = CDFlib (CONFIRM_, Va.item, &valueT,
1511 NULL_);
1512 if (!sX(tStatus,&pStatus)) break;
1513 *ptr = (Int32) (valueT + 1);
1514 break;
1515 }
1516 /*******************************************************************
1517 * CONFIRM_,<(Int32 []) [output] - CDF_MAX_DIMS maximum>
1518 *******************************************************************/
1519 case rVARs_DIMCOUNTS_:
1520 case zVAR_DIMCOUNTS_:
1521 case rVARs_DIMINTERVALS_:
1522 case zVAR_DIMINTERVALS_: {
1523 Int32 *ptr = va_arg (Va.ap, Int32 *);
1524 Logical Z = (Va.item == zVAR_DIMCOUNTS_ ||
1525 Va.item == zVAR_DIMINTERVALS_);
1526 long numDims, valuesT[CDF_MAX_DIMS];
1527 int dimN;
1528
1529 if (StatusBAD(pStatus)) break;
1530
1531 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
1532 rVARs_NUMDIMS_), &numDims,
1533 CONFIRM_, Va.item, valuesT,
1534 NULL_);
1535 if (!sX(tStatus,&pStatus)) break;
1536
1537 for (dimN = 0; dimN < numDims; dimN++) {
1538 ptr[dimN] = (Int32) valuesT[dimN];
1539 }
1540 break;
1541 }
1542 /*******************************************************************
1543 * CONFIRM_,<(Int32 [] + 1) [output] - CDF_MAX_DIMS maximum>
1544 *******************************************************************/
1545 case rVARs_DIMINDICES_:
1546 case zVAR_DIMINDICES_: {
1547 Int32 *values = va_arg (Va.ap, Int32 *);
1548 Logical Z = (Va.item == zVAR_DIMINDICES_);
1549 long numDims, valuesT[CDF_MAX_DIMS];
1550 int dimN;
1551
1552 if (StatusBAD(pStatus)) break;
1553
1554 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
1555 rVARs_NUMDIMS_), &numDims,
1556 CONFIRM_, Va.item, valuesT,
1557 NULL_);
1558 if (!sX(tStatus,&pStatus)) break;
1559
1560 for (dimN = 0; dimN < numDims; dimN++) {
1561 values[dimN] = (Int32) (valuesT[dimN] + 1);
1562 }
1563 break;
1564 }
1565 /*******************************************************************
1566 * CONFIRM_,<(Int32 *) - 1 [input]>
1567 *******************************************************************/
1568 case gENTRY_EXISTENCE_:
1569 case rENTRY_EXISTENCE_:
1570 case zENTRY_EXISTENCE_: {
1571 Int32 entryN = *(va_arg (Va.ap, Int32 *));
1572 if (StatusBAD(pStatus)) break;
1573 tStatus = CDFlib (CONFIRM_, Va.item, (long) (entryN - 1),
1574 NULL_);
1575 if (!sX(tStatus,&pStatus)) break;
1576 break;
1577 }
1578 /*******************************************************************
1579 * CONFIRM_,<void * (character string) [input]>
1580 *******************************************************************/
1581 case rVAR_EXISTENCE_:
1582 case zVAR_EXISTENCE_:
1583 case ATTR_EXISTENCE_: {
1584 void *varName = va_arg (Va.ap, void *);
1585 int LFS = FALSE;
1586 size_t maxLen;
1587
1588 if (currentCDFid != NULL) {
1589 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
1590 if (isLFS(CDF)) LFS = TRUE;
1591 }
1592
1593 #if !defined(Fif_GHOSTLEN)
1594 maxLen = PickMaxLen (Va.item, 3,
1595 rVAR_EXISTENCE_, (LFS ?
1596 (size_t) CDF_VAR_NAME_LEN256 :
1597 (size_t) CDF_VAR_NAME_LEN),
1598 zVAR_EXISTENCE_, (LFS ?
1599 (size_t) CDF_VAR_NAME_LEN256 :
1600 (size_t) CDF_VAR_NAME_LEN),
1601 ATTR_EXISTENCE_, (LFS ?
1602 (size_t) CDF_ATTR_NAME_LEN256:
1603 (size_t) CDF_ATTR_NAME_LEN));
1604 #endif
1605
1606 if (StatusBAD(pStatus)) break;
1607
1608 tStatus = CDFlib (CONFIRM_, Va.item,
1609 #if defined(Fif_DESCR)
1610 DESCRtoREFnul(varName,
1611 maxLen,&ssh),
1612 #endif
1613 #if defined(Fif_GHOSTLEN)
1614 NULterminate(varName,sLs[sC],
1615 &ssh),
1616 #endif
1617 #if defined(Fif_NOLEN)
1618 FindEndNUL(varName,maxLen,
1619 &ssh),
1620 #endif
1621 NULL_);
1622 if (!sX(tStatus,&pStatus)) break;
1623 #if defined(Fif_GHOSTLEN)
1624 sC++;
1625 #endif
1626 break;
1627 }
1628 /*******************************************************************
1629 * CONFIRM_,CDF_NAME_
1630 *******************************************************************/
1631 case CDF_NAME_: {
1632 void *name = va_arg (Va.ap, void *);
1633 char nameT[CDF_PATHNAME_LEN+1];
1634 if (StatusBAD(pStatus)) break;
1635 tStatus = CDFlib (CONFIRM_, CDF_NAME_, nameT,
1636 NULL_);
1637 if (!sX(tStatus,&pStatus)) break;
1638 #if defined(Fif_GHOSTLEN)
1639 CtoFORTstring (nameT, name, sLs[sC]);
1640 sC++;
1641 #else
1642 CtoFORTstring (nameT, name, CDF_PATHNAME_LEN);
1643 #endif
1644 break;
1645 }
1646 /*******************************************************************
1647 * CONFIRM_,rVAR_SEQPOS_/zVAR_SEQPOS_
1648 *******************************************************************/
1649 case rVAR_SEQPOS_:
1650 case zVAR_SEQPOS_: {
1651 Int32 *rec_num = va_arg (Va.ap, Int32 *);
1652 Int32 *indices = va_arg (Va.ap, Int32 *);
1653 Logical Z = (Va.item == zVAR_SEQPOS_);
1654 long numDims, indicesT[CDF_MAX_DIMS], recNumT;
1655 int dimN;
1656
1657 if (StatusBAD(pStatus)) break;
1658
1659 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
1660 rVARs_NUMDIMS_), &numDims,
1661 CONFIRM_, Va.item, &recNumT, indicesT,
1662 NULL_);
1663 if (!sX(tStatus,&pStatus)) break;
1664
1665 *rec_num = (Int32) (recNumT + 1);
1666 for (dimN = 0; dimN < numDims; dimN++) {
1667 indices[dimN] = (Int32) (indicesT[dimN] + 1);
1668 }
1669 break;
1670 }
1671 /*******************************************************************
1672 * Unknown item - hopefully the next function.
1673 *******************************************************************/
1674 default: {
1675 Va.fnc = Va.item;
1676 break;
1677 }
1678 }
1679 if (Va.fnc == Va.item) break;
1680 }
1681 break;
1682
1683 /**************************************************************************
1684 * GET_
1685 **************************************************************************/
1686 case GET_:
1687 for (;;) {
1688 Va.item = (long) *(va_arg (Va.ap, Int32 *));
1689 switch (Va.item) {
1690 /*******************************************************************
1691 * GET_,<Int32 * (passed by reference)>.
1692 *******************************************************************/
1693 case rVARs_NUMDIMS_:
1694 case zVAR_NUMDIMS_:
1695 case CDF_ENCODING_:
1696 case CDF_MAJORITY_:
1697 case CDF_FORMAT_:
1698 case CDF_NUMrVARS_:
1699 case CDF_NUMzVARS_:
1700 case CDF_NUMATTRS_:
1701 case CDF_NUMgATTRS_:
1702 case CDF_NUMvATTRS_:
1703 case CDF_VERSION_:
1704 case CDF_RELEASE_:
1705 case CDF_INCREMENT_:
1706 case rVAR_DATATYPE_:
1707 case zVAR_DATATYPE_:
1708 case rVAR_NUMELEMS_:
1709 case zVAR_NUMELEMS_:
1710 case rVAR_RECVARY_:
1711 case zVAR_RECVARY_:
1712 case rVAR_BLOCKINGFACTOR_:
1713 case zVAR_BLOCKINGFACTOR_:
1714 case rVAR_nINDEXRECORDS_:
1715 case zVAR_nINDEXRECORDS_:
1716 case rVAR_nINDEXENTRIES_:
1717 case zVAR_nINDEXENTRIES_:
1718 case rVAR_nINDEXLEVELS_:
1719 case zVAR_nINDEXLEVELS_:
1720 case rVAR_NUMRECS_:
1721 case zVAR_NUMRECS_:
1722 case rVAR_NUMallocRECS_:
1723 case zVAR_NUMallocRECS_:
1724 case rVAR_SPARSERECORDS_:
1725 case zVAR_SPARSERECORDS_:
1726 case ATTR_SCOPE_:
1727 case ATTR_NUMgENTRIES_:
1728 case ATTR_NUMrENTRIES_:
1729 case ATTR_NUMzENTRIES_:
1730 case gENTRY_DATATYPE_:
1731 case rENTRY_DATATYPE_:
1732 case zENTRY_DATATYPE_:
1733 case gENTRY_NUMELEMS_:
1734 case rENTRY_NUMELEMS_:
1735 case zENTRY_NUMELEMS_:
1736 case LIB_VERSION_:
1737 case LIB_RELEASE_:
1738 case LIB_INCREMENT_:
1739 case CDF_CHECKSUM_: {
1740 Int32 *ptr = va_arg (Va.ap, Int32 *);
1741 long valueT;
1742 if (StatusBAD(pStatus)) break;
1743 tStatus = CDFlib (GET_, Va.item, &valueT,
1744 NULL_);
1745 if (!sX(tStatus,&pStatus)) break;
1746 *ptr = (Int32) valueT;
1747 break;
1748 }
1749 /*******************************************************************
1750 * GET_,<Int32 * In, Int32 * Out>.
1751 *******************************************************************/
1752 case DATATYPE_SIZE_: {
1753 Int32 *ptr1 = va_arg (Va.ap, Int32 *);
1754 Int32 *ptr2 = va_arg (Va.ap, Int32 *);
1755 long valueT;
1756 if (StatusBAD(pStatus)) break;
1757 tStatus = CDFlib (GET_, Va.item, (long) *ptr1, &valueT,
1758 NULL_);
1759 if (!sX(tStatus,&pStatus)) break;
1760 *ptr2 = (Int32) valueT;
1761 break;
1762 }
1763 /*******************************************************************
1764 * GET_,<(Int32 * In) - 1, (Int32 * Out) + 1>.
1765 *******************************************************************/
1766 case rVAR_ALLOCATEDTO_:
1767 case zVAR_ALLOCATEDTO_:
1768 case rVAR_ALLOCATEDFROM_:
1769 case zVAR_ALLOCATEDFROM_: {
1770 Int32 *ptr1 = va_arg (Va.ap, Int32 *);
1771 Int32 *ptr2 = va_arg (Va.ap, Int32 *);
1772 long valueT;
1773 if (StatusBAD(pStatus)) break;
1774 tStatus = CDFlib (GET_, Va.item, (long) (*ptr1 - 1), &valueT,
1775 NULL_);
1776 if (!sX(tStatus,&pStatus)) break;
1777 *ptr2 = (Int32) (valueT + 1);
1778 break;
1779 }
1780 /*******************************************************************
1781 * GET_,<(Int32 *) + 1 (passed by reference)>.
1782 *******************************************************************/
1783 case rVARs_MAXREC_:
1784 case zVARs_MAXREC_:
1785 case rVAR_MAXREC_:
1786 case zVAR_MAXREC_:
1787 case rVAR_MAXallocREC_:
1788 case zVAR_MAXallocREC_:
1789 case ATTR_MAXgENTRY_:
1790 case ATTR_MAXrENTRY_:
1791 case ATTR_MAXzENTRY_: {
1792 Int32 *ptr = va_arg (Va.ap, Int32 *);
1793 long valueT;
1794 if (StatusBAD(pStatus)) break;
1795 tStatus = CDFlib (GET_, Va.item, &valueT,
1796 NULL_);
1797 if (!sX(tStatus,&pStatus)) break;
1798 *ptr = (Int32) (valueT + 1);
1799 break;
1800 }
1801 /*******************************************************************
1802 * GET_,<Int32 [] (passed by reference) - CDF_MAX_DIMS maximum>
1803 *******************************************************************/
1804 case rVARs_DIMSIZES_:
1805 case zVAR_DIMSIZES_:
1806 case rVAR_DIMVARYS_:
1807 case zVAR_DIMVARYS_: {
1808 Int32 *ptr = va_arg (Va.ap, Int32 *);
1809 Logical Z = (Va.item == zVAR_DIMSIZES_ ||
1810 Va.item == zVAR_DIMVARYS_);
1811 long valuesT[CDF_MAX_DIMS], numDims;
1812 int dimN;
1813 if (StatusBAD(pStatus)) break;
1814 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
1815 rVARs_NUMDIMS_), &numDims,
1816 Va.item, valuesT,
1817 NULL_);
1818 if (!sX(tStatus,&pStatus)) break;
1819 for (dimN = 0; dimN < numDims; dimN++) {
1820 ptr[dimN] = (Int32) valuesT[dimN];
1821 }
1822 break;
1823 }
1824 /*******************************************************************
1825 * GET_,<void * (character string)>.
1826 *******************************************************************/
1827 case LIB_subINCREMENT_:
1828 case LIB_COPYRIGHT_:
1829 case CDF_COPYRIGHT_:
1830 case rVAR_NAME_:
1831 case zVAR_NAME_:
1832 case ATTR_NAME_: {
1833 void *ptr = va_arg (Va.ap, void *);
1834 char *ptrT;
1835 int LFS = FALSE;
1836 size_t maxLen;
1837
1838 if (currentCDFid != NULL) {
1839 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
1840 if (isLFS(CDF)) LFS = TRUE;
1841 }
1842
1843 if (StatusBAD(pStatus)) break;
1844 maxLen = PickMaxLen (Va.item, 6,
1845 LIB_subINCREMENT_, (size_t) 1,
1846 LIB_COPYRIGHT_, (size_t) CDF_DOCUMENT_LEN,
1847 CDF_COPYRIGHT_, (size_t) CDF_DOCUMENT_LEN,
1848 rVAR_NAME_, (LFS ?
1849 (size_t) CDF_VAR_NAME_LEN256 :
1850 (size_t) CDF_VAR_NAME_LEN),
1851 zVAR_NAME_, (LFS ?
1852 (size_t) CDF_VAR_NAME_LEN256 :
1853 (size_t) CDF_VAR_NAME_LEN),
1854 ATTR_NAME_, (LFS ?
1855 (size_t) CDF_ATTR_NAME_LEN256 :
1856 (size_t) CDF_ATTR_NAME_LEN));
1857 ptrT = (char *) cdf_AllocateMemory (maxLen + 1, NULL);
1858 if (ptrT == NULL) {
1859 if (!sX(BAD_MALLOC,&pStatus)) break;
1860 }
1861 tStatus = CDFlib (GET_, Va.item, ptrT,
1862 NULL_);
1863 if (!sX(tStatus,&pStatus)) {
1864 cdf_FreeMemory (ptrT, NULL);
1865 break;
1866 }
1867 #if defined(Fif_GHOSTLEN)
1868 CtoFORTstring (ptrT, ptr, sLs[sC]);
1869 sC++;
1870 #else
1871 CtoFORTstring (ptrT, ptr, (int) maxLen);
1872 #endif
1873 cdf_FreeMemory (ptrT, NULL);
1874 break;
1875 }
1876 /*******************************************************************
1877 * GET_,<in: void * (character string), out: (Int32 *) + 1>
1878 *******************************************************************/
1879 case rVAR_NUMBER_:
1880 case zVAR_NUMBER_:
1881 case ATTR_NUMBER_: {
1882 void *ptr1 = va_arg (Va.ap, void *);
1883 Int32 *ptr2 = va_arg (Va.ap, Int32 *);
1884 long valueT;
1885 int LFS = FALSE;
1886 size_t maxLen;
1887
1888 if (currentCDFid != NULL) {
1889 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
1890 if (isLFS(CDF)) LFS = TRUE;
1891 }
1892
1893 #if !defined(Fif_GHOSTLEN)
1894 maxLen = PickMaxLen (Va.item, 3,
1895 rVAR_NUMBER_, (LFS ?
1896 (size_t) CDF_VAR_NAME_LEN256 :
1897 (size_t) CDF_VAR_NAME_LEN),
1898 zVAR_NUMBER_, (LFS ?
1899 (size_t) CDF_VAR_NAME_LEN256 :
1900 (size_t) CDF_VAR_NAME_LEN),
1901 ATTR_NUMBER_, (LFS ?
1902 (size_t) CDF_ATTR_NAME_LEN256 :
1903 (size_t) CDF_ATTR_NAME_LEN));
1904 #endif
1905
1906 if (StatusBAD(pStatus)) break;
1907
1908 tStatus = CDFlib (GET_, Va.item,
1909 #if defined(Fif_DESCR)
1910 DESCRtoREFnul(ptr1,maxLen,&ssh),
1911 #endif
1912 #if defined(Fif_GHOSTLEN)
1913 NULterminate(ptr1,sLs[sC],&ssh),
1914 #endif
1915 #if defined(Fif_NOLEN)
1916 FindEndNUL(ptr1,maxLen,&ssh),
1917 #endif
1918 &valueT,
1919 NULL_);
1920 if (!sX(tStatus,&pStatus)) break;
1921
1922 #if defined(Fif_GHOSTLEN)
1923 sC++;
1924 #endif
1925 *ptr2 = (Int32) (valueT + 1);
1926 break;
1927 }
1928 /*******************************************************************
1929 * GET_,CDF_INFO_:
1930 *******************************************************************/
1931 case CDF_INFO_: {
1932 void *ptr1 = va_arg (Va.ap, void *);
1933 Int32 *ptr2 = va_arg (Va.ap, Int32 *);
1934 Int32 *ptr3 = va_arg (Va.ap, Int32 *);
1935 void *ptr4 = va_arg (Va.ap, void *);
1936 void *ptr5 = va_arg (Va.ap, void *);
1937 long cType, cParms[CDF_MAX_PARMS]; /* cSize, uSize;*/ int p;
1938 void *cSize, *uSize;
1939 int LFS = FALSE;
1940 if (currentCDFid != NULL) {
1941 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
1942 if (isLFS(CDF)) LFS = TRUE;
1943 }
1944 if (LFS) {
1945 cSize = (OFF_T *) malloc(sizeof(OFF_T));
1946 uSize = (OFF_T *) malloc(sizeof(OFF_T));
1947 } else {
1948 cSize = (long *) malloc(sizeof(long));
1949 uSize = (long *) malloc(sizeof(long));
1950 }
1951 tStatus = CDFlib (GET_, Va.item,
1952 #if defined(Fif_DESCR)
1953 DESCRtoREFnul(ptr1,
1954 CDF_PATHNAME_LEN,
1955 &ssh),
1956 #endif
1957 #if defined(Fif_GHOSTLEN)
1958 NULterminate(ptr1,sLs[sC],&ssh),
1959 #endif
1960 #if defined(Fif_NOLEN)
1961 FindEndNUL(ptr1,
1962 CDF_PATHNAME_LEN,
1963 &ssh),
1964 #endif
1965 &cType, cParms, cSize, uSize,
1966 NULL_);
1967 if (!sX(tStatus,&pStatus)) break;
1968 #if defined(Fif_GHOSTLEN)
1969 sC++;
1970 #endif
1971 *ptr2 = (Int32) cType;
1972 for (p = 0; p < CompressionParmsCount((Int32)cType); p++) {
1973 ptr3[p] = (Int32) cParms[p];
1974 }
1975 memcpy(ptr4, cSize, sizeof(cSize));
1976 memcpy(ptr5, uSize, sizeof(uSize));
1977 free (cSize);
1978 free (uSize);
1979 break;
1980 }
1981 /*******************************************************************
1982 * GET_,CDF_COMPRESSION_
1983 * GET_,rVAR_COMPRESSION_
1984 * GET_,zVAR_COMPRESSION_
1985 * GET_,rVAR_SPARSEARRAYS_
1986 * GET_,zVAR_SPARSEARRAYS_
1987 *******************************************************************/
1988 case CDF_COMPRESSION_:
1989 case rVAR_COMPRESSION_:
1990 case zVAR_COMPRESSION_:
1991 case rVAR_SPARSEARRAYS_:
1992 case zVAR_SPARSEARRAYS_: {
1993 Logical sparse = (Va.item == rVAR_SPARSEARRAYS_ ||
1994 Va.item == zVAR_SPARSEARRAYS_);
1995 Int32 *ptr1 = va_arg (Va.ap, Int32 *);
1996 Int32 *ptr2 = va_arg (Va.ap, Int32 *);
1997 Int32 *ptr3 = va_arg (Va.ap, Int32 *);
1998 long type, parms[CDF_MAX_PARMS], pct; int pCount, p;
1999 if (StatusBAD(pStatus)) break;
2000 tStatus = CDFlib (GET_, Va.item, &type, parms, &pct,
2001 NULL_);
2002 if (!sX(tStatus,&pStatus)) break;
2003 *ptr1 = (Int32) type;
2004 pCount = BOO(sparse,SparsenessParmsCount((Int32)type),
2005 CompressionParmsCount((Int32)type));
2006 for (p = 0; p < pCount; p++) ptr2[p] = (Int32) parms[p];
2007 *ptr3 = (Int32) pct;
2008 break;
2009 }
2010 /*******************************************************************
2011 * GET_,<void * (depends on data type) - variable value(s)>
2012 *******************************************************************/
2013 case rVAR_PADVALUE_:
2014 case zVAR_PADVALUE_:
2015 case rVAR_DATA_:
2016 case zVAR_DATA_:
2017 case rVAR_HYPERDATA_:
2018 case zVAR_HYPERDATA_:
2019 case rVAR_SEQDATA_:
2020 case zVAR_SEQDATA_: {
2021 void *ptr = va_arg (Va.ap, void *);
2022 Logical Z = (Va.item == zVAR_PADVALUE_ ||
2023 Va.item == zVAR_DATA_ ||
2024 Va.item == zVAR_HYPERDATA_ ||
2025 Va.item == zVAR_SEQDATA_);
2026 long dataType;
2027
2028 if (StatusBAD(pStatus)) break;
2029
2030 tStatus = CDFlib (GET_, BOO(Z,zVAR_DATATYPE_,
2031 rVAR_DATATYPE_), &dataType,
2032 NULL_);
2033 if (!sX(tStatus,&pStatus)) break;
2034
2035 tStatus = CDFlib (GET_, Va.item,
2036 #if defined(Fif_DESCR)
2037 STRINGdataType(dataType) ?
2038 DESCRtoREF(ptr) : ptr,
2039 #else
2040 ptr,
2041 #endif
2042 NULL_);
2043 if (!sX(tStatus,&pStatus)) break;
2044
2045 #if defined(Fif_GHOSTLEN)
2046 if (STRINGdataType(dataType)) sC++;
2047 #endif
2048 break;
2049 }
2050 /*******************************************************************
2051 * GET_,r/zVARs_RECDATA_
2052 *******************************************************************/
2053 case rVARs_RECDATA_:
2054 case zVARs_RECDATA_: {
2055 Int32 *nVars = va_arg (Va.ap, Int32 *);
2056 Int32 *varNs = va_arg (Va.ap, Int32 *);
2057 void *ptr = va_arg (Va.ap, void *);
2058 long *tVarNs; int varX;
2059 if (StatusBAD(pStatus)) break;
2060 if (*nVars < 1) {
2061 if (!sX(BAD_NUM_VARS,&pStatus)) break;
2062 }
2063 tVarNs = (long *) cdf_AllocateMemory ((size_t)(*nVars*sizeof(long)),
2064 NULL);
2065 if (tVarNs == NULL) {
2066 if (!sX(BAD_MALLOC,&pStatus)) break;
2067 }
2068 for (varX = 0; varX < *nVars; varX++) {
2069 tVarNs[varX] = (long) (varNs[varX] - 1);
2070 }
2071 tStatus = CDFlib (GET_, Va.item, (long) *nVars, tVarNs, ptr,
2072 NULL_);
2073 cdf_FreeMemory (tVarNs, NULL); /*Before checking status.*/
2074 if (!sX(tStatus,&pStatus)) break;
2075 break;
2076 }
2077 /*******************************************************************
2078 * GET_,gENTRY_DATA_/rENTRY_DATA_/zENTRY_DATA_
2079 *******************************************************************/
2080 case gENTRY_DATA_:
2081 case rENTRY_DATA_:
2082 case zENTRY_DATA_: {
2083 void *value = va_arg (Va.ap, void *);
2084 int Et = E3p(Va.item,gENTRY_DATA_,rENTRY_DATA_,zENTRY_DATA_);
2085 long dataType;
2086
2087 if (StatusBAD(pStatus)) break;
2088
2089 tStatus = CDFlib (GET_, E3(Et,gENTRY_DATATYPE_,
2090 rENTRY_DATATYPE_,
2091 zENTRY_DATATYPE_), &dataType,
2092 NULL_);
2093 if (!sX(tStatus,&pStatus)) break;
2094
2095 tStatus = CDFlib (GET_, Va.item,
2096 #if defined(Fif_DESCR)
2097 STRINGdataType(dataType) ?
2098 DESCRtoREF(value) : value,
2099 #else
2100 value,
2101 #endif
2102 NULL_);
2103 if (!sX(tStatus,&pStatus)) break;
2104
2105 #if defined(Fif_GHOSTLEN)
2106 if (STRINGdataType(dataType)) sC++;
2107 #endif
2108 break;
2109 }
2110 /*******************************************************************
2111 * GET_,STATUS_TEXT_
2112 *******************************************************************/
2113 case STATUS_TEXT_: {
2114 void *textPtr = va_arg (Va.ap, void *);
2115 char textT[CDF_STATUSTEXT_LEN+1];
2116
2117 if (StatusBAD(pStatus)) break;
2118
2119 tStatus = CDFlib (GET_, STATUS_TEXT_, textT,
2120 NULL_);
2121 if (!sX(tStatus,&pStatus)) break;
2122
2123 #if defined(Fif_GHOSTLEN)
2124 CtoFORTstring (textT, textPtr, sLs[sC]);
2125 sC++;
2126 #else
2127 CtoFORTstring (textT, textPtr, CDF_STATUSTEXT_LEN);
2128 #endif
2129 break;
2130 }
2131 /*******************************************************************
2132 * Unknown item - hopefully the next function.
2133 *******************************************************************/
2134 default: {
2135 Va.fnc = Va.item;
2136 break;
2137 }
2138 }
2139 if (Va.fnc == Va.item) break;
2140 }
2141 break;
2142
2143 /**************************************************************************
2144 * PUT_
2145 **************************************************************************/
2146 case PUT_:
2147 for (;;) {
2148 Va.item = (long) *(va_arg (Va.ap, Int32 *));
2149 switch (Va.item) {
2150 /*******************************************************************
2151 * PUT_,<Int32 *>
2152 *******************************************************************/
2153 case CDF_ENCODING_:
2154 case CDF_MAJORITY_:
2155 case CDF_FORMAT_:
2156 case rVAR_RECVARY_:
2157 case zVAR_RECVARY_:
2158 case rVAR_ALLOCATERECS_:
2159 case zVAR_ALLOCATERECS_:
2160 case rVAR_INITIALRECS_:
2161 case zVAR_INITIALRECS_:
2162 case rVAR_BLOCKINGFACTOR_:
2163 case zVAR_BLOCKINGFACTOR_:
2164 case rVAR_SPARSERECORDS_:
2165 case zVAR_SPARSERECORDS_:
2166 case ATTR_SCOPE_:
2167 case CDF_CHECKSUM_: {
2168 Int32 *ptr = va_arg (Va.ap, Int32 *);
2169 if (StatusBAD(pStatus)) break;
2170 tStatus = CDFlib (PUT_, Va.item, (long) *ptr,
2171 NULL_);
2172 if (!sX(tStatus,&pStatus)) break;
2173 break;
2174 }
2175 /*******************************************************************
2176 * PUT_,<Int32 []>
2177 *******************************************************************/
2178 case rVAR_DIMVARYS_:
2179 case zVAR_DIMVARYS_: {
2180 Int32 *ptr = va_arg (Va.ap, Int32 *);
2181 Logical Z = (Va.item == zVAR_DIMVARYS_);
2182 long valuesT[CDF_MAX_DIMS], numDims;
2183 int dimN;
2184 if (StatusBAD(pStatus)) break;
2185 tStatus = CDFlib (GET_, BOO(Z,zVAR_NUMDIMS_,
2186 rVARs_NUMDIMS_), &numDims,
2187 NULL_);
2188 if (!sX(tStatus,&pStatus)) break;
2189 for (dimN = 0; dimN < numDims; dimN++) {
2190 valuesT[dimN] = (long) ptr[dimN];
2191 }
2192 tStatus = CDFlib (PUT_, Va.item, valuesT,
2193 NULL_);
2194 if (!sX(tStatus,&pStatus)) break;
2195 break;
2196 }
2197 /*******************************************************************
2198 * PUT_,CDF_COMPRESSION_
2199 * PUT_,rVAR_COMPRESSION_
2200 * PUT_,zVAR_COMPRESSION_
2201 * PUT_,rVAR_SPARSEARRAYS_
2202 * PUT_,zVAR_SPARSEARRAYS_
2203 *******************************************************************/
2204 case CDF_COMPRESSION_:
2205 case rVAR_COMPRESSION_:
2206 case zVAR_COMPRESSION_:
2207 case rVAR_SPARSEARRAYS_:
2208 case zVAR_SPARSEARRAYS_: {
2209 Logical sparse = (Va.item == rVAR_SPARSEARRAYS_ ||
2210 Va.item == zVAR_SPARSEARRAYS_);
2211 Int32 *ptr1 = va_arg (Va.ap, Int32 *);
2212 Int32 *ptr2 = va_arg (Va.ap, Int32 *);
2213 int p, pCount = BOO(sparse,SparsenessParmsCount(*ptr1),
2214 CompressionParmsCount(*ptr1));
2215 long parms[CDF_MAX_PARMS];
2216 if (StatusBAD(pStatus)) break;
2217 for (p = 0; p < pCount; p++) parms[p] = (long) ptr2[p];
2218 tStatus = CDFlib (PUT_, Va.item, (long) *ptr1, parms,
2219 NULL_);
2220 if (!sX(tStatus,&pStatus)) break;
2221 break;
2222 }
2223 /*******************************************************************
2224 * PUT_,<Int32 *, Int32 *>
2225 *******************************************************************/
2226 case rVAR_DATASPEC_:
2227 case zVAR_DATASPEC_:
2228 case gENTRY_DATASPEC_:
2229 case rENTRY_DATASPEC_:
2230 case zENTRY_DATASPEC_: {
2231 Int32 value1 = *(va_arg (Va.ap, Int32 *));
2232 Int32 value2 = *(va_arg (Va.ap, Int32 *));
2233 if (StatusBAD(pStatus)) break;
2234 tStatus = CDFlib (PUT_, Va.item, (long) value1, (long) value2,
2235 NULL_);
2236 if (!sX(tStatus,&pStatus)) break;
2237 break;
2238 }
2239 /*******************************************************************
2240 * PUT_,<(Int32 *) - 1, (Int32 *) - 1>
2241 *******************************************************************/
2242 case rVAR_ALLOCATEBLOCK_:
2243 case zVAR_ALLOCATEBLOCK_: {
2244 Int32 value1 = *(va_arg (Va.ap, Int32 *)) - 1;
2245 Int32 value2 = *(va_arg (Va.ap, Int32 *)) - 1;
2246 if (StatusBAD(pStatus)) break;
2247 tStatus = CDFlib (PUT_, Va.item, (long) value1, (long) value2,
2248 NULL_);
2249 if (!sX(tStatus,&pStatus)) break;
2250 break;
2251 }
2252 /*******************************************************************
2253 * PUT_,<void * (character string)>
2254 *******************************************************************/
2255 case rVAR_NAME_:
2256 case zVAR_NAME_:
2257 case ATTR_NAME_: {
2258 void *ptr = va_arg (Va.ap, void *);
2259 int LFS = FALSE;
2260 size_t maxLen;
2261
2262 if (currentCDFid != NULL) {
2263 struct CDFstruct *CDF = (struct CDFstruct *)currentCDFid;
2264 if (isLFS(CDF)) LFS = TRUE;
2265 }
2266
2267 #if !defined(Fif_GHOSTLEN)
2268 maxLen = PickMaxLen (Va.item, 3,
2269 rVAR_NAME_,(LFS ?
2270 (size_t) CDF_VAR_NAME_LEN256 :
2271 (size_t) CDF_VAR_NAME_LEN),
2272 zVAR_NAME_,(LFS?
2273 (size_t) CDF_VAR_NAME_LEN256 :
2274 (size_t) CDF_VAR_NAME_LEN),
2275 ATTR_NAME_,(LFS?
2276 (size_t) CDF_ATTR_NAME_LEN256 :
2277 (size_t) CDF_ATTR_NAME_LEN));
2278 #endif
2279 if (StatusBAD(pStatus)) break;
2280 tStatus = CDFlib (PUT_, Va.item,
2281 #if defined(Fif_DESCR)
2282 DESCRtoREFnul(ptr,maxLen,&ssh),
2283 #endif
2284 #if defined(Fif_GHOSTLEN)
2285 NULterminate(ptr,sLs[sC],&ssh),
2286 #endif
2287 #if defined(Fif_NOLEN)
2288 FindEndNUL(ptr,maxLen,&ssh),
2289 #endif
2290 NULL_);
2291 if (!sX(tStatus,&pStatus)) break;
2292
2293 #if defined(Fif_GHOSTLEN)
2294 sC++;
2295 #endif
2296 break;
2297 }
2298 /*******************************************************************
2299 * PUT_,<void * (depends on data type) - variable value(s)>
2300 *******************************************************************/
2301 case rVAR_PADVALUE_:
2302 case zVAR_PADVALUE_:
2303 case rVAR_DATA_:
2304 case zVAR_DATA_:
2305 case rVAR_HYPERDATA_:
2306 case zVAR_HYPERDATA_:
2307 case rVAR_SEQDATA_:
2308 case zVAR_SEQDATA_: {
2309 void *ptr = va_arg (Va.ap, void *);
2310 Logical Z = (Va.item == zVAR_PADVALUE_ ||
2311 Va.item == zVAR_DATA_ ||
2312 Va.item == zVAR_HYPERDATA_ ||
2313 Va.item == zVAR_SEQDATA_);
2314 long dataType;
2315 if (StatusBAD(pStatus)) break;
2316 tStatus = CDFlib (GET_, BOO(Z,zVAR_DATATYPE_,
2317 rVAR_DATATYPE_), &dataType,
2318 NULL_);
2319 if (!sX(tStatus,&pStatus)) break;
2320 tStatus = CDFlib (PUT_, Va.item,
2321 #if defined(Fif_DESCR)
2322 STRINGdataType(dataType) ?
2323 DESCRtoREF(ptr) : ptr,
2324 #else
2325 ptr,
2326 #endif
2327 NULL_);
2328 if (!sX(tStatus,&pStatus)) break;
2329 #if defined(Fif_GHOSTLEN)
2330 if (STRINGdataType(dataType)) sC++;
2331 #endif
2332 break;
2333 }
2334 /*******************************************************************
2335 * PUT_,r/zVARs_RECDATA_
2336 *******************************************************************/
2337 case rVARs_RECDATA_:
2338 case zVARs_RECDATA_: {
2339 Int32 *nVars = va_arg (Va.ap, Int32 *);
2340 Int32 *varNs = va_arg (Va.ap, Int32 *);
2341 void *ptr = va_arg (Va.ap, void *);
2342 long *tVarNs; int varX;
2343 if (StatusBAD(pStatus)) break;
2344 if (*nVars < 1) {
2345 if (!sX(BAD_NUM_VARS,&pStatus)) break;
2346 }
2347 tVarNs = (long *) cdf_AllocateMemory ((size_t)(*nVars*sizeof(long)),
2348 NULL);
2349 if (tVarNs == NULL) {
2350 if (!sX(BAD_MALLOC,&pStatus)) break;
2351 }
2352 for (varX = 0; varX < *nVars; varX++) {
2353 tVarNs[varX] = (long) (varNs[varX] - 1);
2354 }
2355 tStatus = CDFlib (PUT_, Va.item, (long) *nVars, tVarNs, ptr,
2356 NULL_);
2357 cdf_FreeMemory (tVarNs, NULL); /*Before checking status.*/
2358 if (!sX(tStatus,&pStatus)) break;
2359 break;
2360 }
2361 /*******************************************************************
2362 * PUT_,gENTRY_DATA_/rENTRY_DATA_/zENTRY_DATA_
2363 *******************************************************************/
2364 case gENTRY_DATA_:
2365 case rENTRY_DATA_:
2366 case zENTRY_DATA_: {
2367 Int32 dataType = *(va_arg (Va.ap, Int32 *));
2368 Int32 numElements = *(va_arg (Va.ap, Int32 *));
2369 void *value = va_arg (Va.ap, void *);
2370 if (StatusBAD(pStatus)) break;
2371 tStatus = CDFlib (PUT_, Va.item, (long) dataType,
2372 (long) numElements,
2373 #if defined(Fif_DESCR)
2374 STRINGdataType(dataType) ?
2375 DESCRtoREF(value) : value,
2376 #else
2377 value,
2378 #endif
2379 NULL_);
2380 if (!sX(tStatus,&pStatus)) break;
2381 #if defined(Fif_GHOSTLEN)
2382 if (STRINGdataType(dataType)) sC++;
2383 #endif
2384 break;
2385 }
2386 /*******************************************************************
2387 * Unknown item - hopefully the next function.
2388 *******************************************************************/
2389 default: {
2390 Va.fnc = Va.item;
2391 break;
2392 }
2393 }
2394 if (Va.fnc == Va.item) break;
2395 }
2396 break;
2397 /**************************************************************************
2398 * Unknown function/item. This is bad - we're lost.
2399 **************************************************************************/
2400 default: {
2401 #if defined(Fif_GHOSTLEN)
2402 if (sLs != NULL) cdf_FreeMemory (sLs, NULL);
2403 #endif
2404 FreeStrings (ssh);
2405 va_end (Va.ap);
2406 return ((Int32) BAD_FNC_OR_ITEM);
2407 }
2408 }
2409
2410 #if defined(Fif_GHOSTLEN)
2411 if (sLs != NULL) cdf_FreeMemory (sLs, NULL);
2412 #endif
2413
2414 status = va_arg (Va.ap, Int32 *);
2415 *status = (Int32) pStatus;
2416
2417 va_end (Va.ap);
2418
2419 FreeStrings (ssh);
2420 return ((Int32) pStatus);
2421 }
2422
2423 /******************************************************************************
2424 * PickMaxLen.
2425 * Syntax: len = PickMaxLen (targetItem, nListed,
2426 * listItem1, listLen1,
2427 * listItem2, listLen2,
2428 * .
2429 * .
2430 * .
2431 * listItemN, listLenN);
2432 ******************************************************************************/
2433
PickMaxLen(long requiredArgument,...)2434 static size_t PickMaxLen
2435 #if defined(STDARG)
2436 (long requiredArgument, ...)
2437 #else
2438 (va_alist)
2439 va_dcl
2440 #endif
2441 {
2442 va_list ap;
2443 long targetItem; /* The item being sought. */
2444 int nListed; /* The number of listed items (the list
2445 being searched for the target item). */
2446 int listN; /* Index into list of item/length pairs. */
2447 #if defined(STDARG)
2448 va_start (ap, requiredArgument);
2449 targetItem = requiredArgument;
2450 #else
2451 VA_START (ap);
2452 targetItem = va_arg (ap, long);
2453 #endif
2454 nListed = va_arg (ap, int);
2455 for (listN = 0; listN < nListed; listN++) {
2456 long listItem = va_arg (ap, long);
2457 size_t listLen = va_arg (ap, size_t);
2458 if (listItem == targetItem) {
2459 va_end (ap);
2460 return listLen;
2461 }
2462 }
2463 va_end (ap);
2464 return (size_t) 0;
2465 }
2466
2467 /******************************************************************************
2468 * CDF_lib_4.
2469 ******************************************************************************/
2470
2471 VISIBLE_PREFIX
2472 Fif_PREFIXa
2473 Int32
2474 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_4__,cdf_lib_4_,cdf_lib_4,CDF_LIB_4)2475 Fif_ENTRYPOINT(cdf_lib_4__,cdf_lib_4_,cdf_lib_4,CDF_LIB_4)
2476 #if defined(STDARG)
2477 (void *a0, void *a1, void *a2, void *a3, ...)
2478 #else
2479 (va_alist)
2480 va_dcl
2481 #endif
2482 {
2483 #if defined(Fif_GHOSTLEN)
2484 #if defined(STDARG)
2485 Int32 sC = 0; Fif_GHOSTTYPE l[4]; int i; va_list ap; CDFstatus tStatus;
2486 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3);
2487 if (StatusBAD(tStatus)) return tStatus;
2488 va_start (ap, a3);
2489 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2490 va_end (ap);
2491 return CDF_LIBx (a0, a1, a2, a3, l[0], l[1], l[2], l[3]);
2492 #else
2493 Int32 sC = 0; Fif_GHOSTTYPE l[4]; int i; void *a[4];
2494 va_list ap; CDFstatus tStatus;
2495 VA_START (ap);
2496 for (i = 0; i < 4; i++) a[i] = va_arg (ap, void *);
2497 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3]);
2498 if (StatusBAD(tStatus)) return tStatus;
2499 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2500 va_end (ap);
2501 return CDF_LIBx (a[0], a[1], a[2], a[3], l[0], l[1], l[2], l[3]);
2502 #endif
2503 #else
2504 #if defined(STDARG)
2505 return CDF_LIBx (a0, a1, a2, a3);
2506 #else
2507 void *a[4]; int i; va_list ap;
2508 VA_START (ap);
2509 for (i = 0; i < 4; i++) a[i] = va_arg (ap, void *);
2510 va_end (ap);
2511 return CDF_LIBx (a[0], a[1], a[2], a[3]);
2512 #endif
2513 #endif
2514 }
2515
2516 /******************************************************************************
2517 * CDF_lib_5.
2518 ******************************************************************************/
2519
2520 VISIBLE_PREFIX
2521 Fif_PREFIXa
2522 Int32
2523 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_5__,cdf_lib_5_,cdf_lib_5,CDF_LIB_5)2524 Fif_ENTRYPOINT(cdf_lib_5__,cdf_lib_5_,cdf_lib_5,CDF_LIB_5)
2525 #if defined(STDARG)
2526 (void *a0, void *a1, void *a2, void *a3, void *a4, ...)
2527 #else
2528 (va_alist)
2529 va_dcl
2530 #endif
2531 {
2532 #if defined(Fif_GHOSTLEN)
2533 #if defined(STDARG)
2534 Int32 sC = 0; Fif_GHOSTTYPE l[5]; int i; va_list ap; CDFstatus tStatus;
2535 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4);
2536 if (StatusBAD(tStatus)) return tStatus;
2537 va_start (ap, a4);
2538 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2539 va_end (ap);
2540 return CDF_LIBx (a0, a1, a2, a3, a4,
2541 l[0], l[1], l[2], l[3], l[4]);
2542 #else
2543 Int32 sC = 0; Fif_GHOSTTYPE l[5]; int i; void *a[5];
2544 va_list ap; CDFstatus tStatus;
2545 VA_START (ap);
2546 for (i = 0; i < 5; i++) a[i] = va_arg (ap, void *);
2547 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4]);
2548 if (StatusBAD(tStatus)) return tStatus;
2549 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2550 va_end (ap);
2551 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4],
2552 l[0], l[1], l[2], l[3], l[4]);
2553 #endif
2554 #else
2555 #if defined(STDARG)
2556 return CDF_LIBx (a0, a1, a2, a3, a4);
2557 #else
2558 void *a[5]; int i; va_list ap;
2559 VA_START (ap);
2560 for (i = 0; i < 5; i++) a[i] = va_arg (ap, void *);
2561 va_end (ap);
2562 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4]);
2563 #endif
2564 #endif
2565 }
2566
2567 /******************************************************************************
2568 * CDF_lib_6.
2569 ******************************************************************************/
2570
2571 VISIBLE_PREFIX
2572 Fif_PREFIXa
2573 Int32
2574 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_6__,cdf_lib_6_,cdf_lib_6,CDF_LIB_6)2575 Fif_ENTRYPOINT(cdf_lib_6__,cdf_lib_6_,cdf_lib_6,CDF_LIB_6)
2576 #if defined(STDARG)
2577 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, ...)
2578 #else
2579 (va_alist)
2580 va_dcl
2581 #endif
2582 {
2583 #if defined(Fif_GHOSTLEN)
2584 #if defined(STDARG)
2585 Int32 sC = 0; Fif_GHOSTTYPE l[6]; int i; va_list ap; CDFstatus tStatus;
2586 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5);
2587 if (StatusBAD(tStatus)) return tStatus;
2588 va_start (ap, a5);
2589 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2590 va_end (ap);
2591 return CDF_LIBx (a0, a1, a2, a3, a4, a5,
2592 l[0], l[1], l[2], l[3], l[4], l[5]);
2593 #else
2594 Int32 sC = 0; Fif_GHOSTTYPE l[6]; int i; void *a[6];
2595 va_list ap; CDFstatus tStatus;
2596 VA_START (ap);
2597 for (i = 0; i < 6; i++) a[i] = va_arg (ap, void *);
2598 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5]);
2599 if (StatusBAD(tStatus)) return tStatus;
2600 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2601 va_end (ap);
2602 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5],
2603 l[0], l[1], l[2], l[3], l[4], l[5]);
2604 #endif
2605 #else
2606 #if defined(STDARG)
2607 return CDF_LIBx (a0, a1, a2, a3, a4, a5);
2608 #else
2609 void *a[6]; int i; va_list ap;
2610 VA_START (ap);
2611 for (i = 0; i < 6; i++) a[i] = va_arg (ap, void *);
2612 va_end (ap);
2613 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5]);
2614 #endif
2615 #endif
2616 }
2617
2618 /******************************************************************************
2619 * CDF_lib_7.
2620 ******************************************************************************/
2621
2622 VISIBLE_PREFIX
2623 Fif_PREFIXa
2624 Int32
2625 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_7__,cdf_lib_7_,cdf_lib_7,CDF_LIB_7)2626 Fif_ENTRYPOINT(cdf_lib_7__,cdf_lib_7_,cdf_lib_7,CDF_LIB_7)
2627 #if defined(STDARG)
2628 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6, ...)
2629 #else
2630 (va_alist)
2631 va_dcl
2632 #endif
2633 {
2634 #if defined(Fif_GHOSTLEN)
2635 #if defined(STDARG)
2636 Int32 sC = 0; Fif_GHOSTTYPE l[7]; int i; va_list ap; CDFstatus tStatus;
2637 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6);
2638 if (StatusBAD(tStatus)) return tStatus;
2639 va_start (ap, a6);
2640 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2641 va_end (ap);
2642 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6,
2643 l[0], l[1], l[2], l[3], l[4], l[5], l[6]);
2644 #else
2645 Int32 sC = 0; Fif_GHOSTTYPE l[7]; int i; void *a[7];
2646 va_list ap; CDFstatus tStatus;
2647 VA_START (ap);
2648 for (i = 0; i < 7; i++) a[i] = va_arg (ap, void *);
2649 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6]);
2650 if (StatusBAD(tStatus)) return tStatus;
2651 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2652 va_end (ap);
2653 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6],
2654 l[0], l[1], l[2], l[3], l[4], l[5], l[6]);
2655 #endif
2656 #else
2657 #if defined(STDARG)
2658 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6);
2659 #else
2660 void *a[7]; int i; va_list ap;
2661 VA_START (ap);
2662 for (i = 0; i < 7; i++) a[i] = va_arg (ap, void *);
2663 va_end (ap);
2664 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6]);
2665 #endif
2666 #endif
2667 }
2668
2669 /******************************************************************************
2670 * CDF_lib_8.
2671 ******************************************************************************/
2672
2673 VISIBLE_PREFIX
2674 Fif_PREFIXa
2675 Int32
2676 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_8__,cdf_lib_8_,cdf_lib_8,CDF_LIB_8)2677 Fif_ENTRYPOINT(cdf_lib_8__,cdf_lib_8_,cdf_lib_8,CDF_LIB_8)
2678 #if defined(STDARG)
2679 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
2680 void *a7, ...)
2681 #else
2682 (va_alist)
2683 va_dcl
2684 #endif
2685 {
2686 #if defined(Fif_GHOSTLEN)
2687 #if defined(STDARG)
2688 Int32 sC = 0; Fif_GHOSTTYPE l[8]; int i; va_list ap; CDFstatus tStatus;
2689 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7);
2690 if (StatusBAD(tStatus)) return tStatus;
2691 va_start (ap, a7);
2692 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2693 va_end (ap);
2694 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7,
2695 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7]);
2696 #else
2697 Int32 sC = 0; Fif_GHOSTTYPE l[8]; int i; void *a[8];
2698 va_list ap; CDFstatus tStatus;
2699 VA_START (ap);
2700 for (i = 0; i < 8; i++) a[i] = va_arg (ap, void *);
2701 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
2702 if (StatusBAD(tStatus)) return tStatus;
2703 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2704 va_end (ap);
2705 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
2706 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7]);
2707 #endif
2708 #else
2709 #if defined(STDARG)
2710 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7);
2711 #else
2712 void *a[8]; int i; va_list ap;
2713 VA_START (ap);
2714 for (i = 0; i < 8; i++) a[i] = va_arg (ap, void *);
2715 va_end (ap);
2716 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
2717 #endif
2718 #endif
2719 }
2720
2721 /******************************************************************************
2722 * CDF_lib_9.
2723 ******************************************************************************/
2724
2725 VISIBLE_PREFIX
2726 Fif_PREFIXa
2727 Int32
2728 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_9__,cdf_lib_9_,cdf_lib_9,CDF_LIB_9)2729 Fif_ENTRYPOINT(cdf_lib_9__,cdf_lib_9_,cdf_lib_9,CDF_LIB_9)
2730 #if defined(STDARG)
2731 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
2732 void *a7, void *a8, ...)
2733 #else
2734 (va_alist)
2735 va_dcl
2736 #endif
2737 {
2738 #if defined(Fif_GHOSTLEN)
2739 #if defined(STDARG)
2740 Int32 sC = 0; Fif_GHOSTTYPE l[9]; int i; va_list ap; CDFstatus tStatus;
2741 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8);
2742 if (StatusBAD(tStatus)) return tStatus;
2743 va_start (ap, a8);
2744 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2745 va_end (ap);
2746 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8,
2747 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8]);
2748 #else
2749 Int32 sC = 0; Fif_GHOSTTYPE l[9]; int i; void *a[9];
2750 va_list ap; CDFstatus tStatus;
2751 VA_START (ap);
2752 for (i = 0; i < 9; i++) a[i] = va_arg (ap, void *);
2753 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
2754 a[8]);
2755 if (StatusBAD(tStatus)) return tStatus;
2756 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2757 va_end (ap);
2758 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8],
2759 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8]);
2760 #endif
2761 #else
2762 #if defined(STDARG)
2763 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8);
2764 #else
2765 void *a[9]; int i; va_list ap;
2766 VA_START (ap);
2767 for (i = 0; i < 9; i++) a[i] = va_arg (ap, void *);
2768 va_end (ap);
2769 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
2770 #endif
2771 #endif
2772 }
2773
2774 /******************************************************************************
2775 * CDF_lib_10.
2776 ******************************************************************************/
2777
2778 VISIBLE_PREFIX
2779 Fif_PREFIXa
2780 Int32
2781 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_10__,cdf_lib_10_,cdf_lib_10,CDF_LIB_10)2782 Fif_ENTRYPOINT(cdf_lib_10__,cdf_lib_10_,cdf_lib_10,CDF_LIB_10)
2783 #if defined(STDARG)
2784 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
2785 void *a7, void *a8, void *a9, ...)
2786 #else
2787 (va_alist)
2788 va_dcl
2789 #endif
2790 {
2791 #if defined(Fif_GHOSTLEN)
2792 #if defined(STDARG)
2793 Int32 sC = 0; Fif_GHOSTTYPE l[10]; int i; va_list ap; CDFstatus tStatus;
2794 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
2795 if (StatusBAD(tStatus)) return tStatus;
2796 va_start (ap, a9);
2797 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2798 va_end (ap);
2799 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
2800 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]);
2801 #else
2802 Int32 sC = 0; Fif_GHOSTTYPE l[10]; int i; void *a[10]; va_list ap;
2803 CDFstatus tStatus;
2804 VA_START (ap);
2805 for (i = 0; i < 10; i++) a[i] = va_arg (ap, void *);
2806 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
2807 a[8], a[9]);
2808 if (StatusBAD(tStatus)) return tStatus;
2809 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2810 va_end (ap);
2811 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
2812 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]);
2813 #endif
2814 #else
2815 #if defined(STDARG)
2816 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
2817 #else
2818 void *a[10]; int i; va_list ap;
2819 VA_START (ap);
2820 for (i = 0; i < 10; i++) a[i] = va_arg (ap, void *);
2821 va_end (ap);
2822 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
2823 #endif
2824 #endif
2825 }
2826
2827 /******************************************************************************
2828 * CDF_lib_11.
2829 ******************************************************************************/
2830
2831 VISIBLE_PREFIX
2832 Fif_PREFIXa
2833 Int32
2834 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_11__,cdf_lib_11_,cdf_lib_11,CDF_LIB_11)2835 Fif_ENTRYPOINT(cdf_lib_11__,cdf_lib_11_,cdf_lib_11,CDF_LIB_11)
2836 #if defined(STDARG)
2837 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
2838 void *a7, void *a8, void *a9, void *a10, ...)
2839 #else
2840 (va_alist)
2841 va_dcl
2842 #endif
2843 {
2844 #if defined(Fif_GHOSTLEN)
2845 #if defined(STDARG)
2846 Int32 sC = 0; Fif_GHOSTTYPE l[11]; int i; va_list ap; CDFstatus tStatus;
2847 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2848 if (StatusBAD(tStatus)) return tStatus;
2849 va_start (ap, a10);
2850 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2851 va_end (ap);
2852 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
2853 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
2854 l[10]);
2855 #else
2856 Int32 sC = 0; Fif_GHOSTTYPE l[11]; int i; void *a[11]; va_list ap;
2857 CDFstatus tStatus;
2858 VA_START (ap);
2859 for (i = 0; i < 11; i++) a[i] = va_arg (ap, void *);
2860 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
2861 a[8], a[9], a[10]);
2862 if (StatusBAD(tStatus)) return tStatus;
2863 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2864 va_end (ap);
2865 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
2866 a[10],
2867 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
2868 l[10]);
2869 #endif
2870 #else
2871 #if defined(STDARG)
2872 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2873 #else
2874 void *a[11]; int i; va_list ap;
2875 VA_START (ap);
2876 for (i = 0; i < 11; i++) a[i] = va_arg (ap, void *);
2877 va_end (ap);
2878 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
2879 a[10]);
2880 #endif
2881 #endif
2882 }
2883
2884 /******************************************************************************
2885 * CDF_lib_12.
2886 ******************************************************************************/
2887
2888 VISIBLE_PREFIX
2889 Fif_PREFIXa
2890 Int32
2891 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_12__,cdf_lib_12_,cdf_lib_12,CDF_LIB_12)2892 Fif_ENTRYPOINT(cdf_lib_12__,cdf_lib_12_,cdf_lib_12,CDF_LIB_12)
2893 #if defined(STDARG)
2894 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
2895 void *a7, void *a8, void *a9, void *a10, void *a11, ...)
2896 #else
2897 (va_alist)
2898 va_dcl
2899 #endif
2900 {
2901 #if defined(Fif_GHOSTLEN)
2902 #if defined(STDARG)
2903 Int32 sC = 0; Fif_GHOSTTYPE l[12]; int i; va_list ap; CDFstatus tStatus;
2904 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
2905 if (StatusBAD(tStatus)) return tStatus;
2906 va_start (ap, a11);
2907 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2908 va_end (ap);
2909 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
2910 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
2911 l[10], l[11]);
2912 #else
2913 Int32 sC = 0; Fif_GHOSTTYPE l[12]; int i; void *a[12]; va_list ap;
2914 CDFstatus tStatus;
2915 VA_START (ap);
2916 for (i = 0; i < 12; i++) a[i] = va_arg (ap, void *);
2917 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
2918 a[8], a[9], a[10], a[11]);
2919 if (StatusBAD(tStatus)) return tStatus;
2920 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2921 va_end (ap);
2922 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
2923 a[10], a[11],
2924 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
2925 l[10], l[11]);
2926 #endif
2927 #else
2928 #if defined(STDARG)
2929 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
2930 #else
2931 void *a[12]; int i; va_list ap;
2932 VA_START (ap);
2933 for (i = 0; i < 12; i++) a[i] = va_arg (ap, void *);
2934 va_end (ap);
2935 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
2936 a[10], a[11]);
2937 #endif
2938 #endif
2939 }
2940
2941 /******************************************************************************
2942 * CDF_lib_13.
2943 ******************************************************************************/
2944
2945 VISIBLE_PREFIX
2946 Fif_PREFIXa
2947 Int32
2948 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_13__,cdf_lib_13_,cdf_lib_13,CDF_LIB_13)2949 Fif_ENTRYPOINT(cdf_lib_13__,cdf_lib_13_,cdf_lib_13,CDF_LIB_13)
2950 #if defined(STDARG)
2951 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
2952 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, ...)
2953 #else
2954 (va_alist)
2955 va_dcl
2956 #endif
2957 {
2958 #if defined(Fif_GHOSTLEN)
2959 #if defined(STDARG)
2960 Int32 sC = 0; Fif_GHOSTTYPE l[13]; int i; va_list ap; CDFstatus tStatus;
2961 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
2962 a12);
2963 if (StatusBAD(tStatus)) return tStatus;
2964 va_start (ap, a12);
2965 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2966 va_end (ap);
2967 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
2968 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
2969 l[10], l[11], l[12]);
2970 #else
2971 Int32 sC = 0; Fif_GHOSTTYPE l[13]; int i; void *a[13]; va_list ap;
2972 CDFstatus tStatus;
2973 VA_START (ap);
2974 for (i = 0; i < 13; i++) a[i] = va_arg (ap, void *);
2975 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
2976 a[8], a[9], a[10], a[11], a[12]);
2977 if (StatusBAD(tStatus)) return tStatus;
2978 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
2979 va_end (ap);
2980 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
2981 a[10], a[11], a[12],
2982 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
2983 l[10], l[11], l[12]);
2984 #endif
2985 #else
2986 #if defined(STDARG)
2987 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
2988 #else
2989 void *a[13]; int i; va_list ap;
2990 VA_START (ap);
2991 for (i = 0; i < 13; i++) a[i] = va_arg (ap, void *);
2992 va_end (ap);
2993 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
2994 a[10], a[11], a[12]);
2995 #endif
2996 #endif
2997 }
2998
2999 /******************************************************************************
3000 * CDF_lib_14.
3001 ******************************************************************************/
3002
3003 VISIBLE_PREFIX
3004 Fif_PREFIXa
3005 Int32
3006 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_14__,cdf_lib_14_,cdf_lib_14,CDF_LIB_14)3007 Fif_ENTRYPOINT(cdf_lib_14__,cdf_lib_14_,cdf_lib_14,CDF_LIB_14)
3008 #if defined(STDARG)
3009 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3010 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13, ...)
3011 #else
3012 (va_alist)
3013 va_dcl
3014 #endif
3015 {
3016 #if defined(Fif_GHOSTLEN)
3017 #if defined(STDARG)
3018 Int32 sC = 0; Fif_GHOSTTYPE l[14]; int i; va_list ap; CDFstatus tStatus;
3019 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3020 a12, a13);
3021 if (StatusBAD(tStatus)) return tStatus;
3022 va_start (ap, a13);
3023 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3024 va_end (ap);
3025 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3026 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3027 l[10], l[11], l[12], l[13]);
3028 #else
3029 Int32 sC = 0; Fif_GHOSTTYPE l[14]; int i; void *a[14]; va_list ap;
3030 CDFstatus tStatus;
3031 VA_START (ap);
3032 for (i = 0; i < 14; i++) a[i] = va_arg (ap, void *);
3033 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3034 a[8], a[9], a[10], a[11], a[12], a[13]);
3035 if (StatusBAD(tStatus)) return tStatus;
3036 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3037 va_end (ap);
3038 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3039 a[10], a[11], a[12], a[13],
3040 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3041 l[10], l[11], l[12], l[13]);
3042 #endif
3043 #else
3044 #if defined(STDARG)
3045 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
3046 #else
3047 void *a[14]; int i; va_list ap;
3048 VA_START (ap);
3049 for (i = 0; i < 14; i++) a[i] = va_arg (ap, void *);
3050 va_end (ap);
3051 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3052 a[10], a[11], a[12], a[13]);
3053 #endif
3054 #endif
3055 }
3056
3057 /******************************************************************************
3058 * CDF_lib_15.
3059 ******************************************************************************/
3060
3061 VISIBLE_PREFIX
3062 Fif_PREFIXa
3063 Int32
3064 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_15__,cdf_lib_15_,cdf_lib_15,CDF_LIB_15)3065 Fif_ENTRYPOINT(cdf_lib_15__,cdf_lib_15_,cdf_lib_15,CDF_LIB_15)
3066 #if defined(STDARG)
3067 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3068 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3069 void *a14, ...)
3070 #else
3071 (va_alist)
3072 va_dcl
3073 #endif
3074 {
3075 #if defined(Fif_GHOSTLEN)
3076 #if defined(STDARG)
3077 Int32 sC = 0; Fif_GHOSTTYPE l[15]; int i; va_list ap; CDFstatus tStatus;
3078 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3079 a12, a13, a14);
3080 if (StatusBAD(tStatus)) return tStatus;
3081 va_start (ap, a14);
3082 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3083 va_end (ap);
3084 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3085 a14,
3086 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3087 l[10], l[11], l[12], l[13], l[14]);
3088 #else
3089 Int32 sC = 0; Fif_GHOSTTYPE l[15]; int i; void *a[15]; va_list ap;
3090 CDFstatus tStatus;
3091 VA_START (ap);
3092 for (i = 0; i < 15; i++) a[i] = va_arg (ap, void *);
3093 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3094 a[8], a[9], a[10], a[11], a[12], a[13], a[14]);
3095 if (StatusBAD(tStatus)) return tStatus;
3096 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3097 va_end (ap);
3098 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3099 a[10], a[11], a[12], a[13], a[14],
3100 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3101 l[10], l[11], l[12], l[13], l[14]);
3102 #endif
3103 #else
3104 #if defined(STDARG)
3105 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3106 a14);
3107 #else
3108 void *a[15]; int i; va_list ap;
3109 VA_START (ap);
3110 for (i = 0; i < 15; i++) a[i] = va_arg (ap, void *);
3111 va_end (ap);
3112 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3113 a[10], a[11], a[12], a[13], a[14]);
3114 #endif
3115 #endif
3116 }
3117
3118 /******************************************************************************
3119 * CDF_lib_16.
3120 ******************************************************************************/
3121
3122 VISIBLE_PREFIX
3123 Fif_PREFIXa
3124 Int32
3125 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_16__,cdf_lib_16_,cdf_lib_16,CDF_LIB_16)3126 Fif_ENTRYPOINT(cdf_lib_16__,cdf_lib_16_,cdf_lib_16,CDF_LIB_16)
3127 #if defined(STDARG)
3128 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3129 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3130 void *a14, void *a15, ...)
3131 #else
3132 (va_alist)
3133 va_dcl
3134 #endif
3135 {
3136 #if defined(Fif_GHOSTLEN)
3137 #if defined(STDARG)
3138 Int32 sC = 0; Fif_GHOSTTYPE l[16]; int i; va_list ap; CDFstatus tStatus;
3139 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3140 a12, a13, a14, a15);
3141 if (StatusBAD(tStatus)) return tStatus;
3142 va_start (ap, a15);
3143 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3144 va_end (ap);
3145 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3146 a14, a15,
3147 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3148 l[10], l[11], l[12], l[13], l[14], l[15]);
3149 #else
3150 Int32 sC = 0; Fif_GHOSTTYPE l[16]; int i; void *a[16]; va_list ap;
3151 CDFstatus tStatus;
3152 VA_START (ap);
3153 for (i = 0; i < 16; i++) a[i] = va_arg (ap, void *);
3154 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3155 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);
3156 if (StatusBAD(tStatus)) return tStatus;
3157 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3158 va_end (ap);
3159 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3160 a[10], a[11], a[12], a[13], a[14], a[15],
3161 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3162 l[10], l[11], l[12], l[13], l[14], l[15]);
3163 #endif
3164 #else
3165 #if defined(STDARG)
3166 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3167 a14, a15);
3168 #else
3169 void *a[16]; int i; va_list ap;
3170 VA_START (ap);
3171 for (i = 0; i < 16; i++) a[i] = va_arg (ap, void *);
3172 va_end (ap);
3173 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3174 a[10], a[11], a[12], a[13], a[14], a[15]);
3175 #endif
3176 #endif
3177 }
3178
3179 /******************************************************************************
3180 * CDF_lib_17.
3181 ******************************************************************************/
3182
3183 VISIBLE_PREFIX
3184 Fif_PREFIXa
3185 Int32
3186 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_17__,cdf_lib_17_,cdf_lib_17,CDF_LIB_17)3187 Fif_ENTRYPOINT(cdf_lib_17__,cdf_lib_17_,cdf_lib_17,CDF_LIB_17)
3188 #if defined(STDARG)
3189 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3190 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3191 void *a14, void *a15, void *a16, ...)
3192 #else
3193 (va_alist)
3194 va_dcl
3195 #endif
3196 {
3197 #if defined(Fif_GHOSTLEN)
3198 #if defined(STDARG)
3199 Int32 sC = 0; Fif_GHOSTTYPE l[17]; int i; va_list ap; CDFstatus tStatus;
3200 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3201 a12, a13, a14, a15, a16);
3202 if (StatusBAD(tStatus)) return tStatus;
3203 va_start (ap, a16);
3204 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3205 va_end (ap);
3206 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3207 a14, a15, a16,
3208 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3209 l[10], l[11], l[12], l[13], l[14], l[15], l[16]);
3210 #else
3211 Int32 sC = 0; Fif_GHOSTTYPE l[17]; int i; void *a[17]; va_list ap;
3212 CDFstatus tStatus;
3213 VA_START (ap);
3214 for (i = 0; i < 17; i++) a[i] = va_arg (ap, void *);
3215 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3216 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3217 a[16]);
3218 if (StatusBAD(tStatus)) return tStatus;
3219 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3220 va_end (ap);
3221 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3222 a[10], a[11], a[12], a[13], a[14], a[15], a[16],
3223 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3224 l[10], l[11], l[12], l[13], l[14], l[15], l[16]);
3225 #endif
3226 #else
3227 #if defined(STDARG)
3228 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3229 a14, a15, a16);
3230 #else
3231 void *a[17]; int i; va_list ap;
3232 VA_START (ap);
3233 for (i = 0; i < 17; i++) a[i] = va_arg (ap, void *);
3234 va_end (ap);
3235 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3236 a[10], a[11], a[12], a[13], a[14], a[15], a[16]);
3237 #endif
3238 #endif
3239 }
3240
3241 /******************************************************************************
3242 * CDF_lib_18.
3243 ******************************************************************************/
3244
3245 VISIBLE_PREFIX
3246 Fif_PREFIXa
3247 Int32
3248 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_18__,cdf_lib_18_,cdf_lib_18,CDF_LIB_18)3249 Fif_ENTRYPOINT(cdf_lib_18__,cdf_lib_18_,cdf_lib_18,CDF_LIB_18)
3250 #if defined(STDARG)
3251 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3252 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3253 void *a14, void *a15, void *a16, void *a17, ...)
3254 #else
3255 (va_alist)
3256 va_dcl
3257 #endif
3258 {
3259 #if defined(Fif_GHOSTLEN)
3260 #if defined(STDARG)
3261 Int32 sC = 0; Fif_GHOSTTYPE l[18]; int i; va_list ap; CDFstatus tStatus;
3262 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3263 a12, a13, a14, a15, a16, a17);
3264 if (StatusBAD(tStatus)) return tStatus;
3265 va_start (ap, a17);
3266 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3267 va_end (ap);
3268 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3269 a14, a15, a16, a17, l[0], l[1], l[2], l[3], l[4], l[5],
3270 l[6], l[7], l[8], l[9], l[10], l[11], l[12], l[13], l[14],
3271 l[15], l[16], l[17]);
3272 #else
3273 Int32 sC = 0; Fif_GHOSTTYPE l[18]; int i; void *a[18]; va_list ap;
3274 CDFstatus tStatus;
3275 VA_START (ap);
3276 for (i = 0; i < 18; i++) a[i] = va_arg (ap, void *);
3277 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3278 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3279 a[16], a[17]);
3280 if (StatusBAD(tStatus)) return tStatus;
3281 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3282 va_end (ap);
3283 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3284 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3285 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3286 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17]);
3287 #endif
3288 #else
3289 #if defined(STDARG)
3290 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3291 a14, a15, a16, a17);
3292 #else
3293 void *a[18]; int i; va_list ap;
3294 VA_START (ap);
3295 for (i = 0; i < 18; i++) a[i] = va_arg (ap, void *);
3296 va_end (ap);
3297 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3298 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17]);
3299 #endif
3300 #endif
3301 }
3302
3303 /******************************************************************************
3304 * CDF_lib_19.
3305 ******************************************************************************/
3306
3307 VISIBLE_PREFIX
3308 Fif_PREFIXa
3309 Int32
3310 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_19__,cdf_lib_19_,cdf_lib_19,CDF_LIB_19)3311 Fif_ENTRYPOINT(cdf_lib_19__,cdf_lib_19_,cdf_lib_19,CDF_LIB_19)
3312 #if defined(STDARG)
3313 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3314 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3315 void *a14, void *a15, void *a16, void *a17, void *a18, ...)
3316 #else
3317 (va_alist)
3318 va_dcl
3319 #endif
3320 {
3321 #if defined(Fif_GHOSTLEN)
3322 #if defined(STDARG)
3323 Int32 sC = 0; Fif_GHOSTTYPE l[19]; int i; va_list ap; CDFstatus tStatus;
3324 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3325 a12, a13, a14, a15, a16, a17, a18);
3326 if (StatusBAD(tStatus)) return tStatus;
3327 va_start (ap, a18);
3328 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3329 va_end (ap);
3330 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3331 a14, a15, a16, a17, a18,
3332 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3333 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3334 l[18]);
3335 #else
3336 Int32 sC = 0; Fif_GHOSTTYPE l[19]; int i; void *a[19]; va_list ap;
3337 CDFstatus tStatus;
3338 VA_START (ap);
3339 for (i = 0; i < 19; i++) a[i] = va_arg (ap, void *);
3340 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3341 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3342 a[16], a[17], a[18]);
3343 if (StatusBAD(tStatus)) return tStatus;
3344 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3345 va_end (ap);
3346 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3347 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3348 a[18],
3349 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3350 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3351 l[18]);
3352 #endif
3353 #else
3354 #if defined(STDARG)
3355 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3356 a14, a15, a16, a17, a18);
3357 #else
3358 void *a[19]; int i; va_list ap;
3359 VA_START (ap);
3360 for (i = 0; i < 19; i++) a[i] = va_arg (ap, void *);
3361 va_end (ap);
3362 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3363 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3364 a[18]);
3365 #endif
3366 #endif
3367 }
3368
3369 /******************************************************************************
3370 * CDF_lib_20.
3371 ******************************************************************************/
3372
3373 VISIBLE_PREFIX
3374 Fif_PREFIXa
3375 Int32
3376 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_20__,cdf_lib_20_,cdf_lib_20,CDF_LIB_20)3377 Fif_ENTRYPOINT(cdf_lib_20__,cdf_lib_20_,cdf_lib_20,CDF_LIB_20)
3378 #if defined(STDARG)
3379 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3380 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3381 void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, ...)
3382 #else
3383 (va_alist)
3384 va_dcl
3385 #endif
3386 {
3387 #if defined(Fif_GHOSTLEN)
3388 #if defined(STDARG)
3389 Int32 sC = 0; Fif_GHOSTTYPE l[20]; int i; va_list ap; CDFstatus tStatus;
3390 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3391 a12, a13, a14, a15, a16, a17, a18, a19);
3392 if (StatusBAD(tStatus)) return tStatus;
3393 va_start (ap, a19);
3394 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3395 va_end (ap);
3396 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3397 a14, a15, a16, a17, a18, a19,
3398 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3399 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3400 l[18], l[19]);
3401 #else
3402 Int32 sC = 0; Fif_GHOSTTYPE l[20]; int i; void *a[20]; va_list ap;
3403 CDFstatus tStatus;
3404 VA_START (ap);
3405 for (i = 0; i < 20; i++) a[i] = va_arg (ap, void *);
3406 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3407 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3408 a[16], a[17], a[18], a[19]);
3409 if (StatusBAD(tStatus)) return tStatus;
3410 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3411 va_end (ap);
3412 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3413 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3414 a[18], a[19],
3415 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3416 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3417 l[18], l[19]);
3418 #endif
3419 #else
3420 #if defined(STDARG)
3421 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3422 a14, a15, a16, a17, a18, a19);
3423 #else
3424 void *a[20]; int i; va_list ap;
3425 VA_START (ap);
3426 for (i = 0; i < 20; i++) a[i] = va_arg (ap, void *);
3427 va_end (ap);
3428 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3429 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3430 a[18], a[19]);
3431 #endif
3432 #endif
3433 }
3434
3435 /******************************************************************************
3436 * CDF_lib_21.
3437 ******************************************************************************/
3438
3439 VISIBLE_PREFIX
3440 Fif_PREFIXa
3441 Int32
3442 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_21__,cdf_lib_21_,cdf_lib_21,CDF_LIB_21)3443 Fif_ENTRYPOINT(cdf_lib_21__,cdf_lib_21_,cdf_lib_21,CDF_LIB_21)
3444 #if defined(STDARG)
3445 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3446 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3447 void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
3448 ...)
3449 #else
3450 (va_alist)
3451 va_dcl
3452 #endif
3453 {
3454 #if defined(Fif_GHOSTLEN)
3455 #if defined(STDARG)
3456 Int32 sC = 0; Fif_GHOSTTYPE l[21]; int i; va_list ap; CDFstatus tStatus;
3457 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3458 a12, a13, a14, a15, a16, a17, a18, a19, a20);
3459 if (StatusBAD(tStatus)) return tStatus;
3460 va_start (ap, a20);
3461 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3462 va_end (ap);
3463 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3464 a14, a15, a16, a17, a18, a19, a20,
3465 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3466 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3467 l[18], l[19], l[20]);
3468 #else
3469 Int32 sC = 0; Fif_GHOSTTYPE l[21]; int i; void *a[21]; va_list ap;
3470 CDFstatus tStatus;
3471 VA_START (ap);
3472 for (i = 0; i < 21; i++) a[i] = va_arg (ap, void *);
3473 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3474 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3475 a[16], a[17], a[18], a[19], a[20]);
3476 if (StatusBAD(tStatus)) return tStatus;
3477 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3478 va_end (ap);
3479 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3480 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3481 a[18], a[19], a[20],
3482 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3483 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3484 l[18], l[19], l[20]);
3485 #endif
3486 #else
3487 #if defined(STDARG)
3488 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3489 a14, a15, a16, a17, a18, a19, a20);
3490 #else
3491 void *a[21]; int i; va_list ap;
3492 VA_START (ap);
3493 for (i = 0; i < 21; i++) a[i] = va_arg (ap, void *);
3494 va_end (ap);
3495 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3496 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3497 a[18], a[19], a[20]);
3498 #endif
3499 #endif
3500 }
3501
3502 /******************************************************************************
3503 * CDF_lib_22.
3504 ******************************************************************************/
3505
3506 VISIBLE_PREFIX
3507 Fif_PREFIXa
3508 Int32
3509 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_22__,cdf_lib_22_,cdf_lib_22,CDF_LIB_22)3510 Fif_ENTRYPOINT(cdf_lib_22__,cdf_lib_22_,cdf_lib_22,CDF_LIB_22)
3511 #if defined(STDARG)
3512 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3513 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3514 void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
3515 void *a21, ...)
3516 #else
3517 (va_alist)
3518 va_dcl
3519 #endif
3520 {
3521 #if defined(Fif_GHOSTLEN)
3522 #if defined(STDARG)
3523 Int32 sC = 0; Fif_GHOSTTYPE l[22]; int i; va_list ap; CDFstatus tStatus;
3524 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3525 a12, a13, a14, a15, a16, a17, a18, a19, a20, a21);
3526 if (StatusBAD(tStatus)) return tStatus;
3527 va_start (ap, a21);
3528 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3529 va_end (ap);
3530 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3531 a14, a15, a16, a17, a18, a19, a20, a21,
3532 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3533 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3534 l[18], l[19], l[20], l[21]);
3535 #else
3536 Int32 sC = 0; Fif_GHOSTTYPE l[22]; int i; void *a[22]; va_list ap;
3537 CDFstatus tStatus;
3538 VA_START (ap);
3539 for (i = 0; i < 22; i++) a[i] = va_arg (ap, void *);
3540 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3541 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3542 a[16], a[17], a[18], a[19], a[20], a[21]);
3543 if (StatusBAD(tStatus)) return tStatus;
3544 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3545 va_end (ap);
3546 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3547 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3548 a[18], a[19], a[20], a[21],
3549 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3550 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3551 l[18], l[19], l[20], l[21]);
3552 #endif
3553 #else
3554 #if defined(STDARG)
3555 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3556 a14, a15, a16, a17, a18, a19, a20, a21);
3557 #else
3558 void *a[22]; int i; va_list ap;
3559 VA_START (ap);
3560 for (i = 0; i < 22; i++) a[i] = va_arg (ap, void *);
3561 va_end (ap);
3562 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3563 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3564 a[18], a[19], a[20], a[21]);
3565 #endif
3566 #endif
3567 }
3568
3569 /******************************************************************************
3570 * CDF_lib_23.
3571 ******************************************************************************/
3572
3573 VISIBLE_PREFIX
3574 Fif_PREFIXa
3575 Int32
3576 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_23__,cdf_lib_23_,cdf_lib_23,CDF_LIB_23)3577 Fif_ENTRYPOINT(cdf_lib_23__,cdf_lib_23_,cdf_lib_23,CDF_LIB_23)
3578 #if defined(STDARG)
3579 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3580 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3581 void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
3582 void *a21, void *a22, ...)
3583 #else
3584 (va_alist)
3585 va_dcl
3586 #endif
3587 {
3588 #if defined(Fif_GHOSTLEN)
3589 #if defined(STDARG)
3590 Int32 sC = 0; Fif_GHOSTTYPE l[23]; int i; va_list ap; CDFstatus tStatus;
3591 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3592 a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22);
3593 if (StatusBAD(tStatus)) return tStatus;
3594 va_start (ap, a22);
3595 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3596 va_end (ap);
3597 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3598 a14, a15, a16, a17, a18, a19, a20, a21, a22,
3599 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3600 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3601 l[18], l[19], l[20], l[21], l[22]);
3602 #else
3603 Int32 sC = 0; Fif_GHOSTTYPE l[23]; int i; void *a[23]; va_list ap;
3604 CDFstatus tStatus;
3605 VA_START (ap);
3606 for (i = 0; i < 23; i++) a[i] = va_arg (ap, void *);
3607 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3608 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3609 a[16], a[17], a[18], a[19], a[20], a[21], a[22]);
3610 if (StatusBAD(tStatus)) return tStatus;
3611 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3612 va_end (ap);
3613 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3614 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3615 a[18], a[19], a[20], a[21], a[22],
3616 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3617 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3618 l[18], l[19], l[20], l[21], l[22]);
3619 #endif
3620 #else
3621 #if defined(STDARG)
3622 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3623 a14, a15, a16, a17, a18, a19, a20, a21, a22);
3624 #else
3625 void *a[23]; int i; va_list ap;
3626 VA_START (ap);
3627 for (i = 0; i < 23; i++) a[i] = va_arg (ap, void *);
3628 va_end (ap);
3629 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3630 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3631 a[18], a[19], a[20], a[21], a[22]);
3632 #endif
3633 #endif
3634 }
3635
3636 /******************************************************************************
3637 * CDF_lib_24.
3638 ******************************************************************************/
3639
3640 VISIBLE_PREFIX
3641 Fif_PREFIXa
3642 Int32
3643 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_24__,cdf_lib_24_,cdf_lib_24,CDF_LIB_24)3644 Fif_ENTRYPOINT(cdf_lib_24__,cdf_lib_24_,cdf_lib_24,CDF_LIB_24)
3645 #if defined(STDARG)
3646 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3647 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3648 void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
3649 void *a21, void *a22, void *a23, ...)
3650 #else
3651 (va_alist)
3652 va_dcl
3653 #endif
3654 {
3655 #if defined(Fif_GHOSTLEN)
3656 #if defined(STDARG)
3657 Int32 sC = 0; Fif_GHOSTTYPE l[24]; int i; va_list ap; CDFstatus tStatus;
3658 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3659 a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22,
3660 a23);
3661 if (StatusBAD(tStatus)) return tStatus;
3662 va_start (ap, a23);
3663 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3664 va_end (ap);
3665 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3666 a14, a15, a16, a17, a18, a19, a20, a21, a22, a23,
3667 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3668 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3669 l[18], l[19], l[20], l[21], l[22], l[23]);
3670 #else
3671 Int32 sC = 0; Fif_GHOSTTYPE l[24]; int i; void *a[24]; va_list ap;
3672 CDFstatus tStatus;
3673 VA_START (ap);
3674 for (i = 0; i < 24; i++) a[i] = va_arg (ap, void *);
3675 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3676 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3677 a[16], a[17], a[18], a[19], a[20], a[21], a[22], a[23]);
3678 if (StatusBAD(tStatus)) return tStatus;
3679 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3680 va_end (ap);
3681 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3682 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3683 a[18], a[19], a[20], a[21], a[22], a[23],
3684 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3685 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3686 l[18], l[19], l[20], l[21], l[22], l[23]);
3687 #endif
3688 #else
3689 #if defined(STDARG)
3690 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3691 a14, a15, a16, a17, a18, a19, a20, a21, a22, a23);
3692 #else
3693 void *a[24]; int i; va_list ap;
3694 VA_START (ap);
3695 for (i = 0; i < 24; i++) a[i] = va_arg (ap, void *);
3696 va_end (ap);
3697 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3698 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3699 a[18], a[19], a[20], a[21], a[22], a[23]);
3700 #endif
3701 #endif
3702 }
3703
3704 /******************************************************************************
3705 * CDF_lib_25.
3706 ******************************************************************************/
3707
3708 VISIBLE_PREFIX
3709 Fif_PREFIXa
3710 Int32
3711 Fif_PREFIXb
Fif_ENTRYPOINT(cdf_lib_25__,cdf_lib_25_,cdf_lib_25,CDF_LIB_25)3712 Fif_ENTRYPOINT(cdf_lib_25__,cdf_lib_25_,cdf_lib_25,CDF_LIB_25)
3713 #if defined(STDARG)
3714 (void *a0, void *a1, void *a2, void *a3, void *a4, void *a5, void *a6,
3715 void *a7, void *a8, void *a9, void *a10, void *a11, void *a12, void *a13,
3716 void *a14, void *a15, void *a16, void *a17, void *a18, void *a19, void *a20,
3717 void *a21, void *a22, void *a23, void *a24, ...)
3718 #else
3719 (va_alist)
3720 va_dcl
3721 #endif
3722 {
3723 #if defined(Fif_GHOSTLEN)
3724 #if defined(STDARG)
3725 Int32 sC = 0; Fif_GHOSTTYPE l[25]; int i; va_list ap; CDFstatus tStatus;
3726 tStatus = CDF_LIBx (&sC, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
3727 a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22,
3728 a23, a24);
3729 if (StatusBAD(tStatus)) return tStatus;
3730 va_start (ap, a24);
3731 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3732 va_end (ap);
3733 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3734 a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24,
3735 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3736 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3737 l[18], l[19], l[20], l[21], l[22], l[23], l[24]);
3738 #else
3739 Int32 sC = 0; Fif_GHOSTTYPE l[25]; int i; void *a[25]; va_list ap;
3740 CDFstatus tStatus;
3741 VA_START (ap);
3742 for (i = 0; i < 25; i++) a[i] = va_arg (ap, void *);
3743 tStatus = CDF_LIBx (&sC, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7],
3744 a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15],
3745 a[16], a[17], a[18], a[19], a[20], a[21], a[22], a[23],
3746 a[24]);
3747 if (StatusBAD(tStatus)) return tStatus;
3748 for (i = 0; i < sC; i++) l[i] = va_arg (ap, Fif_GHOSTTYPE);
3749 va_end (ap);
3750 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3751 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3752 a[18], a[19], a[20], a[21], a[22], a[23], a[24],
3753 l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9],
3754 l[10], l[11], l[12], l[13], l[14], l[15], l[16], l[17],
3755 l[18], l[19], l[20], l[21], l[22], l[23], l[24]);
3756 #endif
3757 #else
3758 #if defined(STDARG)
3759 return CDF_LIBx (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13,
3760 a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24);
3761 #else
3762 void *a[25]; int i; va_list ap;
3763 VA_START (ap);
3764 for (i = 0; i < 25; i++) a[i] = va_arg (ap, void *);
3765 va_end (ap);
3766 return CDF_LIBx (a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9],
3767 a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17],
3768 a[18], a[19], a[20], a[21], a[22], a[23], a[24]);
3769 #endif
3770 #endif
3771 }
3772