1 /******************************************************************************
2 *
3 * NSSDC/CDF Write to internal record.
4 *
5 * Version 1.5a, 28-Feb-97, Hughes STX.
6 *
7 * Modification history:
8 *
9 * V1.0 4-Nov-93, J Love Original version.
10 * V1.1 15-Nov-94, J Love CDF V2.5.
11 * V1.2 5-Jan-95, J Love Encode/decode changes.
12 * V1.2a 30-Jan-95, J Love `Write32s' now checks count.
13 * V1.2b 24-Feb-95, J Love Solaris 2.3 IDL i/f.
14 * V1.3 26-May-95, J Love CDF V2.4 compatibility mode. What?
15 * V1.4 14-Jun-95, J Love Use `ReadXYZ' routines.
16 * V1.4a 6-Sep-95, J Love CDFexport-related changes.
17 * V1.5 3-Apr-96, J Love CDF V2.6.
18 * V1.5a 28-Feb-97, J Love Windows NT for MS Visual C/C++ on an IBM PC.
19 * V2.0 29-Jun-04, M Liu Added LFS (Large File Support > 2G).
20 * V3.2a 11-Apr-08, M Liu Modified Write32s_64 and Write64s_64 to
21 * eliminate the potential buffer overflow.
22 *
23 ******************************************************************************/
24
25 #include "cdflib.h"
26 #include "cdflib64.h"
27
28 /******************************************************************************
29 * Local macro definitions.
30 ******************************************************************************/
31
32 #define CWE CDF_WRITE_ERROR
33
34 /******************************************************************************
35 * Write32_64.
36 ******************************************************************************/
37
Write32_64(fp,value)38 STATICforIDL Logical Write32_64 (fp, value)
39 vFILE *fp;
40 Int32 *value;
41 {
42 #if defined(NETWORKbyteORDERcpu)
43 if (!WRITEv64(value,(size_t)4,(size_t)1,fp)) return FALSE;
44 #else
45 Int32 tValue;
46 REVERSE4bIO (value, &tValue)
47 if (!WRITEv64(&tValue,(size_t)4,(size_t)1,fp)) return FALSE;
48 #endif
49 return TRUE;
50 }
51
52 /******************************************************************************
53 * Write32s_64.
54 ******************************************************************************/
55
Write32s_64(fp,buffer,count)56 STATICforIDL Logical Write32s_64 (fp, buffer, count)
57 vFILE *fp;
58 Int32 *buffer;
59 int count;
60 {
61 #define MAX_tBUFFER_SIZE 10 /* This must be set to the maximum
62 value that `count' may ever be.
63 Currently, that is either the
64 maximum number of dimensions or
65 the number of entries in a VXR. */
66 #if defined(NETWORKbyteORDERcpu)
67 if (count == 0) return TRUE;
68 if (count < 0 || count > MAX_tBUFFER_SIZE) return FALSE;
69 if (!WRITEv64(buffer,(size_t)4,(size_t)count,fp)) return FALSE;
70 #else
71 Int32 tBuffer[MAX_tBUFFER_SIZE]; int i;
72 if (count == 0) return TRUE;
73 if (count < 0 || count > MAX_tBUFFER_SIZE) return FALSE;
74 for (i = 0; i < count; i++) {
75 REVERSE4bIO (&buffer[i], &tBuffer[i])
76 }
77 if (!WRITEv64(tBuffer,(size_t)4,(size_t)count,fp)) return FALSE;
78 #endif
79 return TRUE;
80 }
81
82 /******************************************************************************
83 * Write64_64.
84 ******************************************************************************/
85
Write64_64(fp,value)86 STATICforIDL Logical Write64_64 (fp, value)
87 vFILE *fp;
88 OFF_T *value;
89 {
90 #if defined(NETWORKbyteORDERcpu)
91 if (!WRITEv64(value,(size_t)8,(size_t)1,fp)) return FALSE;
92 #else
93 OFF_T tValue;
94 REVERSE8bIO (value, &tValue)
95 if (!WRITEv64(&tValue,(size_t)8,(size_t)1,fp)) return FALSE;
96 #endif
97 return TRUE;
98 }
99
100 /******************************************************************************
101 * Write64s_64.
102 ******************************************************************************/
103
Write64s_64(fp,buffer,count)104 STATICforIDL Logical Write64s_64 (fp, buffer, count)
105 vFILE *fp;
106 OFF_T *buffer;
107 int count;
108 {
109 #define MAX_tBUFFER_SIZE 10 /* This must be set to the maximum
110 value that `count' may ever be.
111 Currently, that is either the
112 maximum number of dimensions or
113 the number of entries in a VXR. */
114 #if defined(NETWORKbyteORDERcpu)
115 if (count == 0) return TRUE;
116 if (count < 0 || count > MAX_tBUFFER_SIZE) return FALSE;
117 if (!WRITEv64(buffer,(size_t)8,(size_t)count,fp)) return FALSE;
118 #else
119 OFF_T tBuffer[MAX_tBUFFER_SIZE]; int i;
120 if (count == 0) return TRUE;
121 if (count < 0 || count > MAX_tBUFFER_SIZE) return FALSE;
122 for (i = 0; i < count; i++) {
123 REVERSE8bIO (&buffer[i], &tBuffer[i])
124 }
125 if (!WRITEv64(tBuffer,(size_t)8,(size_t)count,fp)) return FALSE;
126 #endif
127 return TRUE;
128 }
129
130 /******************************************************************************
131 * WriteIrSize64.
132 * The size is always in the first 8-byte field.
133 ******************************************************************************/
134
WriteIrSize64(fp,offset,irSize)135 STATICforIDL CDFstatus WriteIrSize64 (fp, offset, irSize)
136 vFILE *fp;
137 OFF_T offset;
138 OFF_T *irSize;
139 {
140 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
141 if (!Write64_64(fp,irSize)) return CWE;
142 return CDF_OK;
143 }
144
145 /******************************************************************************
146 * WriteIrType64.
147 * The type is always in the second field (4-byte).
148 ******************************************************************************/
149
WriteIrType64(fp,offset,irType)150 STATICforIDL CDFstatus WriteIrType64 (fp, offset, irType)
151 vFILE *fp;
152 OFF_T offset;
153 Int32 *irType;
154 {
155 OFF_T irTypeOffset = offset + sizeof(OFF_T);
156 if (!SEEKv64(fp,irTypeOffset,vSEEK_SET)) return CWE;
157 if (!Write32_64(fp,irType)) return CWE;
158 return CDF_OK;
159 }
160
161 /******************************************************************************
162 * WriteCDR64.
163 ******************************************************************************/
164
165 #if defined(STDARG)
WriteCDR64(vFILE * fp,OFF_T offset,...)166 STATICforIDL CDFstatus WriteCDR64 (vFILE *fp, OFF_T offset, ...)
167 #else
168 STATICforIDL CDFstatus WriteCDR64 (va_alist)
169 va_dcl
170 #endif
171 {
172 va_list ap; CDFstatus pStatus = CDF_OK;
173 #if defined(STDARG)
174 va_start (ap, offset);
175 #else
176 vFILE *fp; OFF_T offset;
177 VA_START (ap);
178 fp = va_arg (ap, vFILE *);
179 offset = va_arg (ap, OFF_T);
180 #endif
181 for (;;) {
182 int field = va_arg (ap, int);
183 switch (field) {
184 case CDR_NULL:
185 va_end (ap);
186 return pStatus;
187 case CDR_RECORD: {
188 struct CDRstruct64 *CDR = va_arg (ap, struct CDRstruct64 *);
189 char *copyRight = va_arg (ap, char *);
190 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
191 if (!Write64_64(fp,&(CDR->RecordSize))) return CWE;
192 if (!Write32_64(fp,&(CDR->RecordType))) return CWE;
193 if (!Write64_64(fp,&(CDR->GDRoffset))) return CWE;
194 if (!Write32_64(fp,&(CDR->Version))) return CWE;
195 if (!Write32_64(fp,&(CDR->Release))) return CWE;
196 if (!Write32_64(fp,&(CDR->Encoding))) return CWE;
197 if (!Write32_64(fp,&(CDR->Flags))) return CWE;
198 if (!Write32_64(fp,&(CDR->rfuA))) return CWE;
199 if (!Write32_64(fp,&(CDR->rfuB))) return CWE;
200 if (!Write32_64(fp,&(CDR->Increment))) return CWE;
201 if (!Write32_64(fp,&(CDR->rfuD))) return CWE;
202 if (!Write32_64(fp,&(CDR->rfuE))) return CWE;
203 if (copyRight != NULL) {
204 if (!WRITEv64(copyRight,CDF_COPYRIGHT_LEN,1,fp)) return CWE;
205 }
206 break;
207 }
208 case CDR_COPYRIGHT: {
209 char *copyRight = va_arg (ap, char *);
210 OFF_T tOffset = offset + CDR_COPYRIGHT_OFFSET64;
211 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
212 if (!WRITEv64(copyRight,CDF_COPYRIGHT_LEN,1,fp)) return CWE;
213 break;
214 }
215 case CDR_RECORDSIZE:
216 case CDR_GDROFFSET: {
217 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
218 switch (field) {
219 case CDR_RECORDSIZE: tOffset += (OFF_T) CDR_RECORDSIZE_OFFSET64; break;
220 case CDR_GDROFFSET: tOffset += (OFF_T) CDR_GDROFFSET_OFFSET64; break;
221 default: return CDF_INTERNAL_ERROR;
222 }
223 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
224 if (!Write64_64(fp,buffer)) return CWE;
225 break;
226 }
227 default: {
228 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
229 switch (field) {
230 /* case CDR_RECORDSIZE: tOffset += (OFF_T) CDR_RECORDSIZE_OFFSET64; break; */
231 case CDR_RECORDTYPE: tOffset += (OFF_T) CDR_RECORDTYPE_OFFSET64; break;
232 /* case CDR_GDROFFSET: tOffset += (OFF_T) CDR_GDROFFSET_OFFSET64; break; */
233 case CDR_VERSION: tOffset += (OFF_T) CDR_VERSION_OFFSET64; break;
234 case CDR_RELEASE: tOffset += (OFF_T) CDR_RELEASE_OFFSET64; break;
235 case CDR_ENCODING: tOffset += (OFF_T) CDR_ENCODING_OFFSET64; break;
236 case CDR_FLAGS: tOffset += (OFF_T) CDR_FLAGS_OFFSET64; break;
237 case CDR_INCREMENT: tOffset += (OFF_T) CDR_INCREMENT_OFFSET64; break;
238 default: return CDF_INTERNAL_ERROR;
239 }
240 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
241 if (!Write32_64(fp,buffer)) return CWE;
242 break;
243 }
244 }
245 }
246 }
247
248 /******************************************************************************
249 * WriteGDR64.
250 ******************************************************************************/
251
252 #if defined(STDARG)
WriteGDR64(vFILE * fp,OFF_T offset,...)253 STATICforIDL CDFstatus WriteGDR64 (vFILE *fp, OFF_T offset, ...)
254 #else
255 STATICforIDL CDFstatus WriteGDR64 (va_alist)
256 va_dcl
257 #endif
258 {
259 va_list ap; CDFstatus pStatus = CDF_OK;
260 #if defined(STDARG)
261 va_start (ap, offset);
262 #else
263 vFILE *fp; OFF_T offset;
264 VA_START (ap);
265 fp = va_arg (ap, vFILE *);
266 offset = va_arg (ap, OFF_T);
267 #endif
268 for (;;) {
269 int field = va_arg (ap, int);
270 switch (field) {
271 case GDR_NULL:
272 va_end (ap);
273 return pStatus;
274 case GDR_RECORD: {
275 struct GDRstruct64 *GDR = va_arg (ap, struct GDRstruct64 *);
276 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
277 if (!Write64_64(fp,&(GDR->RecordSize))) return CWE;
278 if (!Write32_64(fp,&(GDR->RecordType))) return CWE;
279 if (!Write64_64(fp,&(GDR->rVDRhead))) return CWE;
280 if (!Write64_64(fp,&(GDR->zVDRhead))) return CWE;
281 if (!Write64_64(fp,&(GDR->ADRhead))) return CWE;
282 if (!Write64_64(fp,&(GDR->eof))) return CWE;
283 if (!Write32_64(fp,&(GDR->NrVars))) return CWE;
284 if (!Write32_64(fp,&(GDR->NumAttr))) return CWE;
285 if (!Write32_64(fp,&(GDR->rMaxRec))) return CWE;
286 if (!Write32_64(fp,&(GDR->rNumDims))) return CWE;
287 if (!Write32_64(fp,&(GDR->NzVars))) return CWE;
288 if (!Write64_64(fp,&(GDR->UIRhead))) return CWE;
289 if (!Write32_64(fp,&(GDR->rfuC))) return CWE;
290 if (!Write32_64(fp,&(GDR->rfuD))) return CWE;
291 if (!Write32_64(fp,&(GDR->rfuE))) return CWE;
292 if (!Write32s_64(fp,GDR->rDimSizes,(int)GDR->rNumDims)) return CWE;
293 break;
294 }
295 case GDR_rDIMSIZES: {
296 Int32 *rDimSizes = va_arg (ap, Int32 *), rNumDims; OFF_T tOffset;
297 if (!sX(ReadGDR64(fp,offset,
298 GDR_rNUMDIMS,&rNumDims,
299 GDR_NULL),&pStatus)) return pStatus;
300 tOffset = offset + GDR_rDIMSIZES_OFFSET64;
301 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
302 if (!Write32s_64(fp,rDimSizes,(int)rNumDims)) return CWE;
303 break;
304 }
305 case GDR_RECORDSIZE:
306 case GDR_rVDRHEAD:
307 case GDR_zVDRHEAD:
308 case GDR_ADRHEAD:
309 case GDR_EOF:
310 case GDR_UIRHEAD: {
311 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
312 switch (field) {
313 case GDR_RECORDSIZE: tOffset += (OFF_T) GDR_RECORDSIZE_OFFSET64; break;
314 case GDR_rVDRHEAD: tOffset += (OFF_T) GDR_rVDRHEAD_OFFSET64; break;
315 case GDR_zVDRHEAD: tOffset += (OFF_T) GDR_zVDRHEAD_OFFSET64; break;
316 case GDR_ADRHEAD: tOffset += (OFF_T) GDR_ADRHEAD_OFFSET64; break;
317 case GDR_EOF: tOffset += (OFF_T) GDR_EOF_OFFSET64; break;
318 case GDR_UIRHEAD: tOffset += (OFF_T) GDR_UIRHEAD_OFFSET64; break;
319 default: return CDF_INTERNAL_ERROR;
320 }
321 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
322 if (!Write64_64(fp,buffer)) return CWE;
323 break;
324 }
325 default: {
326 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
327 switch (field) {
328 /* case GDR_RECORDSIZE: tOffset += (OFF_T) GDR_RECORDSIZE_OFFSET64; break; */
329 case GDR_RECORDTYPE: tOffset += (OFF_T) GDR_RECORDTYPE_OFFSET64; break;
330 /* case GDR_rVDRHEAD: tOffset += (OFF_T) GDR_rVDRHEAD_OFFSET64; break; */
331 /* case GDR_zVDRHEAD: tOffset += (OFF_T) GDR_zVDRHEAD_OFFSET64; break; */
332 /* case GDR_ADRHEAD: tOffset += (OFF_T) GDR_ADRHEAD_OFFSET64; break; */
333 /* case GDR_EOF: tOffset += (OFF_T) GDR_EOF_OFFSET64; break; */
334 case GDR_NrVARS: tOffset += (OFF_T) GDR_NrVARS_OFFSET64; break;
335 case GDR_NUMATTR: tOffset += (OFF_T) GDR_NUMATTR_OFFSET64; break;
336 case GDR_rMAXREC: tOffset += (OFF_T) GDR_rMAXREC_OFFSET64; break;
337 case GDR_rNUMDIMS: tOffset += (OFF_T) GDR_rNUMDIMS_OFFSET64; break;
338 case GDR_NzVARS: tOffset += (OFF_T) GDR_NzVARS_OFFSET64; break;
339 /* case GDR_UIRHEAD: tOffset += (OFF_T) GDR_UIRHEAD_OFFSET64; break; */
340 default: return CDF_INTERNAL_ERROR;
341 }
342 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
343 if (!Write32_64(fp,buffer)) return CWE;
344 break;
345 }
346 }
347 }
348 }
349
350 /******************************************************************************
351 * WriteADR64.
352 ******************************************************************************/
353
354 #if defined(STDARG)
WriteADR64(vFILE * fp,OFF_T offset,...)355 STATICforIDL CDFstatus WriteADR64 (vFILE *fp, OFF_T offset, ...)
356 #else
357 STATICforIDL CDFstatus WriteADR64 (va_alist)
358 va_dcl
359 #endif
360 {
361 va_list ap; CDFstatus pStatus = CDF_OK;
362 #if defined(STDARG)
363 va_start (ap, offset);
364 #else
365 vFILE *fp; OFF_T offset;
366 VA_START (ap);
367 fp = va_arg (ap, vFILE *);
368 offset = va_arg (ap, OFF_T);
369 #endif
370 for (;;) {
371 int field = va_arg (ap, int);
372 switch (field) {
373 case ADR_NULL:
374 va_end (ap);
375 return pStatus;
376 case ADR_RECORD: {
377 struct ADRstruct64 *ADR = va_arg (ap, struct ADRstruct64 *);
378 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
379 if (!Write64_64(fp,&(ADR->RecordSize))) return CWE;
380 if (!Write32_64(fp,&(ADR->RecordType))) return CWE;
381 if (!Write64_64(fp,&(ADR->ADRnext))) return CWE;
382 if (!Write64_64(fp,&(ADR->AgrEDRhead))) return CWE;
383 if (!Write32_64(fp,&(ADR->Scope))) return CWE;
384 if (!Write32_64(fp,&(ADR->Num))) return CWE;
385 if (!Write32_64(fp,&(ADR->NgrEntries))) return CWE;
386 if (!Write32_64(fp,&(ADR->MAXgrEntry))) return CWE;
387 if (!Write32_64(fp,&(ADR->rfuA))) return CWE;
388 if (!Write64_64(fp,&(ADR->AzEDRhead))) return CWE;
389 if (!Write32_64(fp,&(ADR->NzEntries))) return CWE;
390 if (!Write32_64(fp,&(ADR->MAXzEntry))) return CWE;
391 if (!Write32_64(fp,&(ADR->rfuE))) return CWE;
392 if (!WRITEv64(ADR->Name,CDF_ATTR_NAME_LEN256,1,fp)) return CWE;
393 break;
394 }
395 case ADR_NAME: {
396 char *aName = va_arg (ap, char *);
397 OFF_T tOffset = offset + ADR_NAME_OFFSET64;
398 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
399 if (!WRITEv64(aName,CDF_ATTR_NAME_LEN256,1,fp)) return CWE;
400 break;
401 }
402 case ADR_RECORDSIZE:
403 case ADR_ADRNEXT:
404 case ADR_AgrEDRHEAD:
405 case ADR_AzEDRHEAD: {
406 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
407 switch (field) {
408 case ADR_RECORDSIZE: tOffset += (OFF_T) ADR_RECORDSIZE_OFFSET64; break;
409 case ADR_ADRNEXT: tOffset += (OFF_T) ADR_ADRNEXT_OFFSET64; break;
410 case ADR_AgrEDRHEAD: tOffset += (OFF_T) ADR_AgrEDRHEAD_OFFSET64; break;
411 case ADR_AzEDRHEAD: tOffset += (OFF_T) ADR_AzEDRHEAD_OFFSET64; break;
412 default: return CDF_INTERNAL_ERROR;
413 }
414 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
415 if (!Write64_64(fp,buffer)) return CWE;
416 break;
417 }
418 default: {
419 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
420 switch (field) {
421 /* case ADR_RECORDSIZE: tOffset += (OFF_T) ADR_RECORDSIZE_OFFSET64; break; */
422 case ADR_RECORDTYPE: tOffset += (OFF_T) ADR_RECORDTYPE_OFFSET64; break;
423 /* case ADR_ADRNEXT: tOffset += (OFF_T) ADR_ADRNEXT_OFFSET64; break; */
424 /* case ADR_AgrEDRHEAD: tOffset += (OFF_T) ADR_AgrEDRHEAD_OFFSET64; break; */
425 case ADR_SCOPE: tOffset += (OFF_T) ADR_SCOPE_OFFSET64; break;
426 case ADR_NUM: tOffset += (OFF_T) ADR_NUM_OFFSET64; break;
427 case ADR_NgrENTRIES: tOffset += (OFF_T) ADR_NgrENTRIES_OFFSET64; break;
428 case ADR_MAXgrENTRY: tOffset += (OFF_T) ADR_MAXgrENTRY_OFFSET64; break;
429 /* case ADR_AzEDRHEAD: tOffset += (OFF_T) ADR_AzEDRHEAD_OFFSET64; break; */
430 case ADR_NzENTRIES: tOffset += (OFF_T) ADR_NzENTRIES_OFFSET64; break;
431 case ADR_MAXzENTRY: tOffset += (OFF_T) ADR_MAXzENTRY_OFFSET64; break;
432 default: return CDF_INTERNAL_ERROR;
433 }
434 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
435 if (!Write32_64(fp,buffer)) return CWE;
436 break;
437 }
438 }
439 }
440 }
441
442 /******************************************************************************
443 * WriteAgrEDR64/AzEDR64.
444 * If the entry value is being written, it is assumed that the value passed
445 * in is in the host machine's encoding.
446 ******************************************************************************/
447
448 #if defined(STDARG)
WriteAEDR64(struct CDFstruct * CDF,vFILE * fp,OFF_T offset,...)449 STATICforIDL CDFstatus WriteAEDR64 (struct CDFstruct *CDF, vFILE *fp,
450 OFF_T offset, ...)
451 #else
452 STATICforIDL CDFstatus WriteAEDR64 (va_alist)
453 va_dcl
454 #endif
455 {
456 va_list ap; CDFstatus pStatus = CDF_OK;
457 #if defined(STDARG)
458 va_start (ap, offset);
459 #else
460 struct CDFstruct *CDF; vFILE *fp; OFF_T offset;
461 VA_START (ap);
462 CDF = va_arg (ap, struct CDFstruct *);
463 fp = va_arg (ap, vFILE *);
464 offset = va_arg (ap, OFF_T);
465 #endif
466 for (;;) {
467 int field = va_arg (ap, int);
468 switch (field) {
469 case AEDR_NULL:
470 va_end (ap);
471 return pStatus;
472 case AEDR_RECORD: {
473 struct AEDRstruct64 *AEDR = va_arg (ap, struct AEDRstruct64 *);
474 void *value = va_arg (ap, void *);
475 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
476 if (!Write64_64(fp,&(AEDR->RecordSize))) return CWE;
477 if (!Write32_64(fp,&(AEDR->RecordType))) return CWE;
478 if (!Write64_64(fp,&(AEDR->AEDRnext))) return CWE;
479 if (!Write32_64(fp,&(AEDR->AttrNum))) return CWE;
480 if (!Write32_64(fp,&(AEDR->DataType))) return CWE;
481 if (!Write32_64(fp,&(AEDR->Num))) return CWE;
482 if (!Write32_64(fp,&(AEDR->NumElems))) return CWE;
483 if (!Write32_64(fp,&(AEDR->rfuA))) return CWE;
484 if (!Write32_64(fp,&(AEDR->rfuB))) return CWE;
485 if (!Write32_64(fp,&(AEDR->rfuC))) return CWE;
486 if (!Write32_64(fp,&(AEDR->rfuD))) return CWE;
487 if (!Write32_64(fp,&(AEDR->rfuE))) return CWE;
488 if (value != NULL) {
489 if (!sX(WriteBuffer64(CDF,fp,AEDR->DataType,
490 AEDR->NumElems,value),&pStatus)) return pStatus;
491 }
492 break;
493 }
494 case AEDR_VALUE: {
495 void *value = va_arg (ap, void *);
496 Int32 dataType, numElems; OFF_T tOffset;
497 if (!sX(ReadAEDR64(fp,offset,
498 AEDR_DATATYPE,&dataType,
499 AEDR_NUMELEMS,&numElems,
500 AEDR_NULL),&pStatus)) return pStatus;
501 tOffset = offset + AEDR_VALUE_OFFSET64;
502 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
503 if (!sX(WriteBuffer64(CDF,fp,dataType,
504 numElems,value),&pStatus)) return pStatus;
505 break;
506 }
507 case AEDR_RECORDSIZE:
508 case AEDR_AEDRNEXT: {
509 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
510 switch (field) {
511 case AEDR_RECORDSIZE: tOffset += (OFF_T) AEDR_RECORDSIZE_OFFSET64; break;
512 case AEDR_AEDRNEXT: tOffset += (OFF_T) AEDR_AEDRNEXT_OFFSET64; break;
513 default: return CDF_INTERNAL_ERROR;
514 }
515 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
516 if (!Write64_64(fp,buffer)) return CWE;
517 break;
518 }
519 default: {
520 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
521 switch (field) {
522 /* case AEDR_RECORDSIZE: tOffset += (OFF_T) AEDR_RECORDSIZE_OFFSET64; break; */
523 case AEDR_RECORDTYPE: tOffset += (OFF_T) AEDR_RECORDTYPE_OFFSET64; break;
524 /* case AEDR_AEDRNEXT: tOffset += (OFF_T) AEDR_AEDRNEXT_OFFSET64; break; */
525 case AEDR_ATTRNUM: tOffset += (OFF_T) AEDR_ATTRNUM_OFFSET64; break;
526 case AEDR_DATATYPE: tOffset += (OFF_T) AEDR_DATATYPE_OFFSET64; break;
527 case AEDR_NUM: tOffset += (OFF_T) AEDR_NUM_OFFSET64; break;
528 case AEDR_NUMELEMS: tOffset += (OFF_T) AEDR_NUMELEMS_OFFSET64; break;
529 default: return CDF_INTERNAL_ERROR;
530 }
531 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
532 if (!Write32_64(fp,buffer)) return CWE;
533 break;
534 }
535 }
536 }
537 }
538
539 /******************************************************************************
540 * WriterVDR64/zVDR64.
541 * If the pad value is being written, it is assumed that the value passed
542 * in is in the host machine's encoding.
543 ******************************************************************************/
544
545 #if defined(STDARG)
WriteVDR64(struct CDFstruct * CDF,vFILE * fp,OFF_T offset,Logical zVar,...)546 STATICforIDL CDFstatus WriteVDR64 (struct CDFstruct *CDF, vFILE *fp,
547 OFF_T offset, Logical zVar, ...)
548 #else
549 STATICforIDL CDFstatus WriteVDR64 (va_alist)
550 va_dcl
551 #endif
552 {
553 va_list ap; CDFstatus pStatus = CDF_OK;
554 #if defined(STDARG)
555 va_start (ap, zVar);
556 #else
557 struct CDFstruct *CDF; vFILE *fp; OFF_T offset; Logical zVar;
558 VA_START (ap);
559 CDF = va_arg (ap, struct CDFstruct *);
560 fp = va_arg (ap, vFILE *);
561 offset = va_arg (ap, OFF_T);
562 zVar = va_arg (ap, Logical);
563 #endif
564 for (;;) {
565 int field = va_arg (ap, int);
566 switch (field) {
567 case VDR_NULL:
568 va_end (ap);
569 return pStatus;
570 case VDR_RECORD: {
571 struct VDRstruct64 *VDR = va_arg (ap, struct VDRstruct64 *);
572 void *padValue = va_arg (ap, void *);
573 Int32 nDims;
574 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
575 if (!Write64_64(fp,&(VDR->RecordSize))) return CWE;
576 if (!Write32_64(fp,&(VDR->RecordType))) return CWE;
577 if (!Write64_64(fp,&(VDR->VDRnext))) return CWE;
578 if (!Write32_64(fp,&(VDR->DataType))) return CWE;
579 if (!Write32_64(fp,&(VDR->MaxRec))) return CWE;
580 if (!Write64_64(fp,&(VDR->VXRhead))) return CWE;
581 if (!Write64_64(fp,&(VDR->VXRtail))) return CWE;
582 if (!Write32_64(fp,&(VDR->Flags))) return CWE;
583 if (!Write32_64(fp,&(VDR->sRecords))) return CWE;
584 if (!Write32_64(fp,&(VDR->rfuB))) return CWE;
585 if (!Write32_64(fp,&(VDR->rfuC))) return CWE;
586 if (!Write32_64(fp,&(VDR->rfuF))) return CWE;
587 if (!Write32_64(fp,&(VDR->NumElems))) return CWE;
588 if (!Write32_64(fp,&(VDR->Num))) return CWE;
589 if (!Write64_64(fp,&(VDR->CPRorSPRoffset))) return CWE;
590 if (!Write32_64(fp,&(VDR->blockingFactor))) return CWE;
591 if (!WRITEv64(VDR->Name,CDF_VAR_NAME_LEN256,1,fp)) return CWE;
592 if (zVar) {
593 if (!Write32_64(fp,&(VDR->zNumDims))) return CWE;
594 if (!Write32s_64(fp,VDR->zDimSizes,
595 (int)VDR->zNumDims)) return CWE;
596 }
597 if (zVar)
598 nDims = VDR->zNumDims;
599 else {
600 OFF_T tOffset = V_tell64 (fp); OFF_T GDRoffset;
601 if (!sX(ReadCDR64(fp,V3_CDR_OFFSET64,
602 CDR_GDROFFSET,&GDRoffset,
603 CDR_NULL),&pStatus)) return pStatus;
604 if (!sX(ReadGDR64(fp,GDRoffset,
605 GDR_rNUMDIMS,&nDims,
606 GDR_NULL),&pStatus)) return pStatus;
607 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
608 }
609 if (!Write32s_64(fp,VDR->DimVarys,(int)nDims)) return CWE;
610 if (PADvalueBITset(VDR->Flags) && padValue != NULL) {
611 if (!sX(WriteBuffer64(CDF,fp,VDR->DataType,
612 VDR->NumElems,
613 padValue),&pStatus)) return pStatus;
614 }
615 break;
616 }
617 case VDR_NAME: {
618 char *vName = va_arg (ap, char *);
619 OFF_T tOffset = offset + VDR_NAME_OFFSET64;
620 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
621 if (!WRITEv64(vName,CDF_VAR_NAME_LEN256,1,fp)) return CWE;
622 break;
623 }
624 case VDR_zNUMDIMS: {
625 Int32 *numDims = va_arg (ap, Int32 *);
626 OFF_T tOffset = offset + zVDR_zNUMDIMS_OFFSET64;
627 if (!zVar) return CDF_INTERNAL_ERROR;
628 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
629 if (!Write32_64(fp,numDims)) return CWE;
630 break;
631 }
632 case VDR_zDIMSIZES: {
633 Int32 *zDimSizes = va_arg (ap, Int32 *), zNumDims;
634 int dimN; OFF_T tOffset;
635 if (!zVar) return CDF_INTERNAL_ERROR;
636 if (!sX(ReadVDR64(CDF,fp,offset,zVar,
637 VDR_zNUMDIMS,&zNumDims,
638 VDR_NULL),&pStatus)) return pStatus;
639 tOffset = offset + zVDR_zDIMSIZES_OFFSET64;
640 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
641 for (dimN = 0; dimN < zNumDims; dimN++) {
642 if (!Write32_64(fp,&(zDimSizes[dimN]))) return CWE;
643 }
644 break;
645 }
646 case VDR_DIMVARYS: {
647 Int32 *dimVarys = va_arg (ap, Int32 *), nDims; OFF_T tOffset;
648 if (zVar) {
649 if (!sX(ReadVDR64(CDF,fp,offset,zVar,
650 VDR_zNUMDIMS,&nDims,
651 VDR_NULL),&pStatus)) return pStatus;
652 tOffset = offset + (OFF_T) (zVDR_DIMVARYS_OFFSETb64 +
653 (nDims * sizeof(Int32)));
654 }
655 else {
656 OFF_T GDRoffset;
657 if (!sX(ReadCDR64(fp,V3_CDR_OFFSET64,
658 CDR_GDROFFSET,&GDRoffset,
659 CDR_NULL),&pStatus)) return pStatus;
660 if (!sX(ReadGDR64(fp,GDRoffset,
661 GDR_rNUMDIMS,&nDims,
662 GDR_NULL),&pStatus)) return pStatus;
663 tOffset = offset + rVDR_DIMVARYS_OFFSET64;
664 }
665 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
666 if (!Write32s_64(fp,dimVarys,(int)nDims)) return CWE;
667 break;
668 }
669 case VDR_PADVALUE: {
670 void *padValue = va_arg (ap, void *);
671 Int32 dataType, numElems; OFF_T tOffset;
672 if (!sX(ReadVDR64(CDF,fp,offset,zVar,
673 VDR_DATATYPE,&dataType,
674 VDR_NUMELEMS,&numElems,
675 VDR_NULL),&pStatus)) return pStatus;
676 if (zVar) {
677 Int32 zNumDims;
678 if (!sX(ReadVDR64(CDF,fp,offset,zVar,
679 VDR_zNUMDIMS,&zNumDims,
680 VDR_NULL),&pStatus)) return pStatus;
681 tOffset = offset + (OFF_T) (zVDR_PADVALUE_OFFSETb64 +
682 (zNumDims * sizeof(Int32)) +
683 (zNumDims * sizeof(Int32)));
684 }
685 else {
686 Int32 rNumDims; OFF_T GDRoffset;
687 if (!sX(ReadCDR64(fp,V3_CDR_OFFSET64,
688 CDR_GDROFFSET,&GDRoffset,
689 CDR_NULL),&pStatus)) return pStatus;
690 if (!sX(ReadGDR64(fp,GDRoffset,
691 GDR_rNUMDIMS,&rNumDims,
692 GDR_NULL),&pStatus)) return pStatus;
693 tOffset = offset + (OFF_T) (rVDR_PADVALUE_OFFSETb64 +
694 (rNumDims*sizeof(Int32)));
695 }
696 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
697 if (!sX(WriteBuffer64(CDF,fp,dataType,
698 numElems,padValue),&pStatus)) return pStatus;
699 break;
700 }
701 case VDR_RECORDSIZE:
702 case VDR_VDRNEXT:
703 case VDR_VXRHEAD:
704 case VDR_VXRTAIL:
705 case VDR_CPRorSPR: {
706 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
707 switch (field) {
708 case VDR_RECORDSIZE: tOffset += (OFF_T) VDR_RECORDSIZE_OFFSET64; break;
709 case VDR_VDRNEXT: tOffset += (OFF_T) VDR_VDRNEXT_OFFSET64; break;
710 case VDR_VXRHEAD: tOffset += (OFF_T) VDR_VXRHEAD_OFFSET64; break;
711 case VDR_VXRTAIL: tOffset += (OFF_T) VDR_VXRTAIL_OFFSET64; break;
712 case VDR_CPRorSPR: tOffset += (OFF_T) VDR_CPRorSPR_OFFSET64; break;
713 default: return CDF_INTERNAL_ERROR;
714 }
715 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
716 if (!Write64_64(fp,buffer)) return CWE;
717 break;
718 }
719 default: {
720 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
721 switch (field) {
722 /* case VDR_RECORDSIZE: tOffset += (OFF_T) VDR_RECORDSIZE_OFFSET64; break; */
723 case VDR_RECORDTYPE: tOffset += (OFF_T) VDR_RECORDTYPE_OFFSET64; break;
724 /* case VDR_VDRNEXT: tOffset += (OFF_T) VDR_VDRNEXT_OFFSET64; break; */
725 case VDR_DATATYPE: tOffset += (OFF_T) VDR_DATATYPE_OFFSET64; break;
726 case VDR_MAXREC: tOffset += (OFF_T) VDR_MAXREC_OFFSET64; break;
727 /* case VDR_VXRHEAD: tOffset += (OFF_T) VDR_VXRHEAD_OFFSET64; break; */
728 /* case VDR_VXRTAIL: tOffset += (OFF_T) VDR_VXRTAIL_OFFSET64; break; */
729 case VDR_FLAGS: tOffset += (OFF_T) VDR_FLAGS_OFFSET64; break;
730 case VDR_sRECORDS: tOffset += (OFF_T) VDR_sRECORDS_OFFSET64; break;
731 case VDR_NUMELEMS: tOffset += (OFF_T) VDR_NUMELEMS_OFFSET64; break;
732 case VDR_NUM: tOffset += (OFF_T) VDR_NUM_OFFSET64; break;
733 /* case VDR_CPRorSPR: tOffset += (OFF_T) VDR_CPRorSPR_OFFSET64; break; */
734 case VDR_BLOCKING: tOffset += (OFF_T) VDR_BLOCKING_OFFSET64; break;
735 default: return CDF_INTERNAL_ERROR;
736 }
737 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
738 if (!Write32_64(fp,buffer)) return CWE;
739 break;
740 }
741 }
742 }
743 }
744
745 /******************************************************************************
746 * WriteVXR64.
747 ******************************************************************************/
748
749 #if defined(STDARG)
WriteVXR64(vFILE * fp,OFF_T offset,...)750 STATICforIDL CDFstatus WriteVXR64 (vFILE *fp, OFF_T offset, ...)
751 #else
752 STATICforIDL CDFstatus WriteVXR64 (va_alist)
753 va_dcl
754 #endif
755 {
756 va_list ap; CDFstatus pStatus = CDF_OK;
757 #if defined(STDARG)
758 va_start (ap, offset);
759 #else
760 vFILE *fp; OFF_T offset;
761 VA_START (ap);
762 fp = va_arg (ap, vFILE *);
763 offset = va_arg (ap, OFF_T);
764 #endif
765 for (;;) {
766 int field = va_arg (ap, int);
767 switch (field) {
768 case VXR_NULL:
769 va_end (ap);
770 return pStatus;
771 case VXR_RECORD: {
772 struct VXRstruct64 *VXR = va_arg (ap, struct VXRstruct64 *);
773 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
774 if (!Write64_64(fp,&(VXR->RecordSize))) return CWE;
775 if (!Write32_64(fp,&(VXR->RecordType))) return CWE;
776 if (!Write64_64(fp,&(VXR->VXRnext))) return CWE;
777 if (!Write32_64(fp,&(VXR->Nentries))) return CWE;
778 if (!Write32_64(fp,&(VXR->NusedEntries))) return CWE;
779 if (!Write32s_64(fp,VXR->First,(int)VXR->Nentries)) return CWE;
780 if (!Write32s_64(fp,VXR->Last,(int)VXR->Nentries)) return CWE;
781 if (!Write64s_64(fp,VXR->Offset,(int)VXR->Nentries)) return CWE;
782 break;
783 }
784 case VXR_FIRSTREC:
785 case VXR_LASTREC: {
786 Int32 *buffer = va_arg (ap, Int32 *), nEntries;
787 OFF_T tOffset = offset + VXR_FIRSTREC_OFFSET64;
788 if (!sX(ReadVXR64(fp,offset,
789 VXR_NENTRIES,&nEntries,
790 VXR_NULL),&pStatus)) return pStatus;
791 switch (field) {
792 case VXR_FIRSTREC: break;
793 case VXR_LASTREC: tOffset += (OFF_T) nEntries * sizeof(Int32); break;
794 default: return CDF_INTERNAL_ERROR;
795 }
796 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
797 if (!Write32s_64(fp,buffer,(int)nEntries)) return CWE;
798 break;
799 }
800 case VXR_OFFSET: {
801 OFF_T *buffer = va_arg (ap, OFF_T *), nEntries;
802 OFF_T tOffset = offset + VXR_FIRSTREC_OFFSET64;
803 if (!sX(ReadVXR64(fp,offset,
804 VXR_NENTRIES,&nEntries,
805 VXR_NULL),&pStatus)) return pStatus;
806 tOffset += (OFF_T) (2 * nEntries * sizeof(Int32));
807 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
808 if (!Write64s_64(fp,buffer,(int)nEntries)) return CWE;
809 break;
810 }
811 case VXR_RECORDSIZE:
812 case VXR_VXRNEXT: {
813 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
814 switch (field) {
815 case VXR_RECORDSIZE: tOffset += (OFF_T) VXR_RECORDSIZE_OFFSET64; break;
816 case VXR_VXRNEXT: tOffset += (OFF_T) VXR_VXRNEXT_OFFSET64; break;
817 default: return CDF_INTERNAL_ERROR;
818 }
819 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
820 if (!Write64_64(fp,buffer)) return CWE;
821 break;
822 }
823 default: {
824 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
825 switch (field) {
826 /* case VXR_RECORDSIZE: tOffset += (OFF_T) VXR_RECORDSIZE_OFFSET64; break; */
827 case VXR_RECORDTYPE: tOffset += (OFF_T) VXR_RECORDTYPE_OFFSET64; break;
828 /* case VXR_VXRNEXT: tOffset += (OFF_T) VXR_VXRNEXT_OFFSET64; break; */
829 case VXR_NENTRIES: tOffset += (OFF_T) VXR_NENTRIES_OFFSET64; break;
830 case VXR_NUSEDENTRIES: tOffset += (OFF_T) VXR_NUSEDENTRIES_OFFSET64; break;
831 default: return CDF_INTERNAL_ERROR;
832 }
833 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
834 if (!Write32_64(fp,buffer)) return CWE;
835 break;
836 }
837 }
838 }
839 }
840
841 /******************************************************************************
842 * WriteVVR64.
843 ******************************************************************************/
844
845 #if defined(STDARG)
WriteVVR64(vFILE * fp,OFF_T offset,...)846 STATICforIDL CDFstatus WriteVVR64 (vFILE *fp, OFF_T offset, ...)
847 #else
848 STATICforIDL CDFstatus WriteVVR64 (va_alist)
849 va_dcl
850 #endif
851 {
852 va_list ap; CDFstatus pStatus = CDF_OK;
853 #if defined(STDARG)
854 va_start (ap, offset);
855 #else
856 vFILE *fp; OFF_T offset;
857 VA_START (ap);
858 fp = va_arg (ap, vFILE *);
859 offset = va_arg (ap, OFF_T);
860 #endif
861 for (;;) {
862 int field = va_arg (ap, int);
863 switch (field) {
864 case VVR_NULL:
865 va_end (ap);
866 return pStatus;
867 case VVR_RECORDx: {
868 struct VVRstruct64 *VVR = va_arg (ap, struct VVRstruct64 *);
869 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
870 if (!Write64_64(fp,&(VVR->RecordSize))) return CWE;
871 if (!Write32_64(fp,&(VVR->RecordType))) return CWE;
872 break;
873 }
874 case VVR_RECORDSIZE: {
875 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
876 tOffset += (OFF_T) VVR_RECORDSIZE_OFFSET64;
877 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
878 if (!Write64_64(fp,buffer)) return CWE;
879 break;
880 }
881 default: {
882 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
883 switch (field) {
884 /* case VVR_RECORDSIZE: tOffset += (OFF_T) VVR_RECORDSIZE_OFFSET64; break; */
885 case VVR_RECORDTYPE: tOffset += (OFF_T) VVR_RECORDTYPE_OFFSET64; break;
886 default: return CDF_INTERNAL_ERROR;
887 }
888 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
889 if (!Write32_64(fp,buffer)) return CWE;
890 break;
891 }
892 }
893 }
894 }
895
896 /******************************************************************************
897 * WriteUIR64.
898 ******************************************************************************/
899
900 #if defined(STDARG)
WriteUIR64(vFILE * fp,OFF_T offset,...)901 STATICforIDL CDFstatus WriteUIR64 (vFILE *fp, OFF_T offset, ...)
902 #else
903 STATICforIDL CDFstatus WriteUIR64 (va_alist)
904 va_dcl
905 #endif
906 {
907 va_list ap; CDFstatus pStatus = CDF_OK;
908 #if defined(STDARG)
909 va_start (ap, offset);
910 #else
911 vFILE *fp; OFF_T offset;
912 VA_START (ap);
913 fp = va_arg (ap, vFILE *);
914 offset = va_arg (ap, OFF_T);
915 #endif
916 for (;;) {
917 int field = va_arg (ap, int);
918 switch (field) {
919 case UIR_NULL:
920 va_end (ap);
921 return pStatus;
922 case UIR_RECORD: {
923 struct UIRstruct64 *UIR = va_arg (ap, struct UIRstruct64 *);
924 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
925 if (!Write64_64(fp,&(UIR->RecordSize))) return CWE;
926 if (!Write32_64(fp,&(UIR->RecordType))) return CWE;
927 if (!Write64_64(fp,&(UIR->NextUIR))) return CWE;
928 if (!Write64_64(fp,&(UIR->PrevUIR))) return CWE;
929 break;
930 }
931 case UIR_RECORDTYPE: {
932 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
933 tOffset += (OFF_T) UIR_RECORDTYPE_OFFSET64;
934 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
935 if (!Write32_64(fp,buffer)) return CWE;
936 break;
937 }
938 default: {
939 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
940 switch (field) {
941 case UIR_RECORDSIZE: tOffset += (OFF_T) UIR_RECORDSIZE_OFFSET64; break;
942 /* case UIR_RECORDTYPE: tOffset += (OFF_T) UIR_RECORDTYPE_OFFSET64; break; */
943 case UIR_NEXTUIR: tOffset += (OFF_T) UIR_NEXTUIR_OFFSET64; break;
944 case UIR_PREVUIR: tOffset += (OFF_T) UIR_PREVUIR_OFFSET64; break;
945 default: return CDF_INTERNAL_ERROR;
946 }
947 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
948 if (!Write64_64(fp,buffer)) return CWE;
949 break;
950 }
951 }
952 }
953 }
954
955 /******************************************************************************
956 * WriteCCR64.
957 ******************************************************************************/
958
959 #if defined(STDARG)
WriteCCR64(vFILE * fp,OFF_T offset,...)960 STATICforIDL CDFstatus WriteCCR64 (vFILE *fp, OFF_T offset, ...)
961 #else
962 STATICforIDL CDFstatus WriteCCR64 (va_alist)
963 va_dcl
964 #endif
965 {
966 va_list ap; CDFstatus pStatus = CDF_OK;
967 #if defined(STDARG)
968 va_start (ap, offset);
969 #else
970 vFILE *fp; OFF_T offset;
971 VA_START (ap);
972 fp = va_arg (ap, vFILE *);
973 offset = va_arg (ap, OFF_T);
974 #endif
975 for (;;) {
976 int field = va_arg (ap, int);
977 switch (field) {
978 case CCR_NULL:
979 va_end (ap);
980 return pStatus;
981 case CCR_RECORD: {
982 struct CCRstruct64 *CCR = va_arg (ap, struct CCRstruct64 *);
983 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
984 if (!Write64_64(fp,&(CCR->RecordSize))) return CWE;
985 if (!Write32_64(fp,&(CCR->RecordType))) return CWE;
986 if (!Write64_64(fp,&(CCR->CPRoffset))) return CWE;
987 if (!Write64_64(fp,&(CCR->uSize))) return CWE;
988 if (!Write32_64(fp,&(CCR->rfuA))) return CWE;
989 break;
990 }
991 case CCR_RECORDTYPE:
992 case CCR_RFUa: {
993 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
994 switch (field) {
995 case CCR_RECORDTYPE: tOffset += (OFF_T) CCR_RECORDTYPE_OFFSET64; break;
996 case CCR_RFUa: tOffset += (OFF_T) CCR_RFUa_OFFSET64; break;
997 default: return CDF_INTERNAL_ERROR;
998 }
999 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
1000 if (!Write32_64(fp,buffer)) return CWE;
1001 break;
1002 }
1003 default: {
1004 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
1005 switch (field) {
1006 case CCR_RECORDSIZE: tOffset += (OFF_T) CCR_RECORDSIZE_OFFSET64; break;
1007 /* case CCR_RECORDTYPE: tOffset += (OFF_T) CCR_RECORDTYPE_OFFSET64; break; */
1008 case CCR_CPROFFSET: tOffset += (OFF_T) CCR_CPROFFSET_OFFSET64; break;
1009 case CCR_USIZE: tOffset += (OFF_T) CCR_USIZE_OFFSET64; break;
1010 /* case CCR_RFUa: tOffset += (OFF_T) CCR_RFUa_OFFSET64; break; */
1011 default: return CDF_INTERNAL_ERROR;
1012 }
1013 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
1014 if (!Write64_64(fp,buffer)) return CWE;
1015 break;
1016 }
1017 }
1018 }
1019 }
1020
1021 /******************************************************************************
1022 * WriteCPR64.
1023 ******************************************************************************/
1024
1025 #if defined(STDARG)
WriteCPR64(vFILE * fp,OFF_T offset,...)1026 STATICforIDL CDFstatus WriteCPR64 (vFILE *fp, OFF_T offset, ...)
1027 #else
1028 STATICforIDL CDFstatus WriteCPR64 (va_alist)
1029 va_dcl
1030 #endif
1031 {
1032 va_list ap; CDFstatus pStatus = CDF_OK;
1033 #if defined(STDARG)
1034 va_start (ap, offset);
1035 #else
1036 vFILE *fp; OFF_T offset;
1037 VA_START (ap);
1038 fp = va_arg (ap, vFILE *);
1039 offset = va_arg (ap, OFF_T);
1040 #endif
1041 for (;;) {
1042 int field = va_arg (ap, int);
1043 switch (field) {
1044 case CPR_NULL:
1045 va_end (ap);
1046 return pStatus;
1047 case CPR_RECORD: {
1048 struct CPRstruct64 *CPR = va_arg (ap, struct CPRstruct64 *); int i;
1049 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
1050 if (!Write64_64(fp,&(CPR->RecordSize))) return CWE;
1051 if (!Write32_64(fp,&(CPR->RecordType))) return CWE;
1052 if (!Write32_64(fp,&(CPR->cType))) return CWE;
1053 if (!Write32_64(fp,&(CPR->rfuA))) return CWE;
1054 if (!Write32_64(fp,&(CPR->pCount))) return CWE;
1055 for (i = 0; i < CPR->pCount; i++) {
1056 if (!Write32_64(fp,&(CPR->cParms[i]))) return CWE;
1057 }
1058 break;
1059 }
1060 case CPR_RECORDSIZE: {
1061 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
1062 tOffset += (OFF_T) CPR_RECORDSIZE_OFFSET64;
1063 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
1064 if (!Write64_64(fp,buffer)) return CWE;
1065 break;
1066 }
1067 default: {
1068 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
1069 switch (field) {
1070 /* case CPR_RECORDSIZE: tOffset += (OFF_T) CPR_RECORDSIZE_OFFSET64; break; */
1071 case CPR_RECORDTYPE: tOffset += (OFF_T) CPR_RECORDTYPE_OFFSET64; break;
1072 case CPR_CTYPE: tOffset += (OFF_T) CPR_CTYPE_OFFSET64; break;
1073 case CPR_RFUa: tOffset += (OFF_T) CPR_RFUa_OFFSET64; break;
1074 case CPR_PCOUNT: tOffset += (OFF_T) CPR_PCOUNT_OFFSET64; break;
1075 case CPR_CPARM1: tOffset += (OFF_T) CPR_CPARM1_OFFSET64; break;
1076 case CPR_CPARM2: tOffset += (OFF_T) CPR_CPARM2_OFFSET64; break;
1077 case CPR_CPARM3: tOffset += (OFF_T) CPR_CPARM3_OFFSET64; break;
1078 case CPR_CPARM4: tOffset += (OFF_T) CPR_CPARM4_OFFSET64; break;
1079 case CPR_CPARM5: tOffset += (OFF_T) CPR_CPARM5_OFFSET64; break;
1080 default: return CDF_INTERNAL_ERROR;
1081 }
1082 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
1083 if (!Write32_64(fp,buffer)) return CWE;
1084 break;
1085 }
1086 }
1087 }
1088 }
1089
1090 /******************************************************************************
1091 * WriteSPR64.
1092 ******************************************************************************/
1093
1094 #if defined(STDARG)
WriteSPR64(vFILE * fp,OFF_T offset,...)1095 STATICforIDL CDFstatus WriteSPR64 (vFILE *fp, OFF_T offset, ...)
1096 #else
1097 STATICforIDL CDFstatus WriteSPR64 (va_alist)
1098 va_dcl
1099 #endif
1100 {
1101 va_list ap; CDFstatus pStatus = CDF_OK;
1102 #if defined(STDARG)
1103 va_start (ap, offset);
1104 #else
1105 vFILE *fp; OFF_T offset;
1106 VA_START (ap);
1107 fp = va_arg (ap, vFILE *);
1108 offset = va_arg (ap, OFF_T);
1109 #endif
1110 for (;;) {
1111 int field = va_arg (ap, int);
1112 switch (field) {
1113 case SPR_NULL:
1114 va_end (ap);
1115 return pStatus;
1116 case SPR_RECORD: {
1117 struct SPRstruct64 *SPR = va_arg (ap, struct SPRstruct64 *); int i;
1118 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
1119 if (!Write64_64(fp,&(SPR->RecordSize))) return CWE;
1120 if (!Write32_64(fp,&(SPR->RecordType))) return CWE;
1121 if (!Write32_64(fp,&(SPR->sArraysType))) return CWE;
1122 if (!Write32_64(fp,&(SPR->rfuA))) return CWE;
1123 if (!Write32_64(fp,&(SPR->pCount))) return CWE;
1124 for (i = 0; i < SPR->pCount; i++) {
1125 if (!Write32_64(fp,&(SPR->sArraysParms[i]))) return CWE;
1126 }
1127 break;
1128 }
1129 case SPR_RECORDSIZE: {
1130 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
1131 tOffset += (OFF_T) SPR_RECORDSIZE_OFFSET64;
1132 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
1133 if (!Write64_64(fp,buffer)) return CWE;
1134 break;
1135 }
1136 default: {
1137 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
1138 switch (field) {
1139 /* case SPR_RECORDSIZE: tOffset += (OFF_T) SPR_RECORDSIZE_OFFSET64; break; */
1140 case SPR_RECORDTYPE: tOffset += (OFF_T) SPR_RECORDTYPE_OFFSET64; break;
1141 case SPR_STYPE: tOffset += (OFF_T) SPR_STYPE_OFFSET64; break;
1142 case SPR_RFUa: tOffset += (OFF_T) SPR_RFUa_OFFSET64; break;
1143 case SPR_PCOUNT: tOffset += (OFF_T) SPR_PCOUNT_OFFSET64; break;
1144 case SPR_SPARM1: tOffset += (OFF_T) SPR_SPARM1_OFFSET64; break;
1145 case SPR_SPARM2: tOffset += (OFF_T) SPR_SPARM2_OFFSET64; break;
1146 case SPR_SPARM3: tOffset += (OFF_T) SPR_SPARM3_OFFSET64; break;
1147 case SPR_SPARM4: tOffset += (OFF_T) SPR_SPARM4_OFFSET64; break;
1148 case SPR_SPARM5: tOffset += (OFF_T) SPR_SPARM5_OFFSET64; break;
1149 default: return CDF_INTERNAL_ERROR;
1150 }
1151 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
1152 if (!Write32_64(fp,buffer)) return CWE;
1153 break;
1154 }
1155 }
1156 }
1157 }
1158
1159 /******************************************************************************
1160 * WriteCVVR64.
1161 ******************************************************************************/
1162
1163 #if defined(STDARG)
WriteCVVR64(vFILE * fp,OFF_T offset,...)1164 STATICforIDL CDFstatus WriteCVVR64 (vFILE *fp, OFF_T offset, ...)
1165 #else
1166 STATICforIDL CDFstatus WriteCVVR64 (va_alist)
1167 va_dcl
1168 #endif
1169 {
1170 va_list ap; CDFstatus pStatus = CDF_OK;
1171 #if defined(STDARG)
1172 va_start (ap, offset);
1173 #else
1174 vFILE *fp; OFF_T offset;
1175 VA_START (ap);
1176 fp = va_arg (ap, vFILE *);
1177 offset = va_arg (ap, OFF_T);
1178 #endif
1179 for (;;) {
1180 int field = va_arg (ap, int);
1181 switch (field) {
1182 case CVVR_NULL:
1183 va_end (ap);
1184 return pStatus;
1185 case CVVR_RECORDx: {
1186 struct CVVRstruct64 *CVVR = va_arg (ap, struct CVVRstruct64 *);
1187 if (!SEEKv64(fp,offset,vSEEK_SET)) return CWE;
1188 if (!Write64_64(fp,&(CVVR->RecordSize))) return CWE;
1189 if (!Write32_64(fp,&(CVVR->RecordType))) return CWE;
1190 if (!Write32_64(fp,&(CVVR->rfuA))) return CWE;
1191 if (!Write64_64(fp,&(CVVR->cSize))) return CWE;
1192 break;
1193 }
1194 case CVVR_RECORDSIZE:
1195 case CVVR_CSIZE: {
1196 OFF_T *buffer = va_arg (ap, OFF_T *); OFF_T tOffset = offset;
1197 switch (field) {
1198 case CVVR_RECORDSIZE: tOffset += (OFF_T) CVVR_RECORDSIZE_OFFSET64; break;
1199 case CVVR_CSIZE: tOffset += (OFF_T) CVVR_CSIZE_OFFSET64; break;
1200 default: return CDF_INTERNAL_ERROR;
1201 }
1202 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
1203 if (!Write64_64(fp,buffer)) return CWE;
1204 break;
1205 }
1206 default: {
1207 Int32 *buffer = va_arg (ap, Int32 *); OFF_T tOffset = offset;
1208 switch (field) {
1209 /* case CVVR_RECORDSIZE: tOffset += (OFF_T) CVVR_RECORDSIZE_OFFSET64; break; */
1210 case CVVR_RECORDTYPE: tOffset += (OFF_T) CVVR_RECORDTYPE_OFFSET64; break;
1211 case CVVR_RFUa: tOffset += (OFF_T) CVVR_RFUa_OFFSET64; break;
1212 /* case CVVR_CSIZE: tOffset += (OFF_T) CVVR_CSIZE_OFFSET64; break; */
1213 default: return CDF_INTERNAL_ERROR;
1214 }
1215 if (!SEEKv64(fp,tOffset,vSEEK_SET)) return CWE;
1216 if (!Write32_64(fp,buffer)) return CWE;
1217 break;
1218 }
1219 }
1220 }
1221 }
1222