1 /******************************************************************************
2 *
3 * NSSDC/CDF SkeletonTable.
4 *
5 * Version 1.4b, 18-Nov-97, Hughes STX.
6 *
7 * Modification history:
8 *
9 * V1.0 18-May-92, J Love Original version.
10 * V1.1 2-Sep-92, J Love CDF V2.3 (shareable/NeXT/zVar).
11 * V1.2 25-Jan-94, J Love CDF V2.4.
12 * V1.3 13-Dec-94, J Love CDF V2.5.
13 * V1.3a 10-Jan-95, J Love Uppercase file extensions on the Macintosh.
14 * V1.3b 28-Feb-95, J Love Pass `char' as `int'.
15 * V1.3c 6-Apr-95, J Love POSIX.
16 * V1.3d 9-May-95, J Love EPOCH styles.
17 * V1.3e 4-Aug-95, J Love CDFexport-related changes.
18 * V1.3f 19-Sep-95, J Love CHECKforABORTso.
19 * V1.3g 28-Sep-95, J Love Macintosh dialog filtering. Outline default
20 * button.
21 * V1.4 26-Aug-96, J Love CDF V2.6.
22 * V1.4a 24-Feb-97, J Love Removed RICE. Fixed `values' qualifier.
23 * V1.4b 18-Nov-97, J Love Windows NT/Visual C++.
24 * V1.5 13-Oct-06, M Liu Changed to allow upper and lower case CDF
25 * name to be used on win32.
26 * V3.3 10-Jan-09, M Liu Validate a file before it is used.
27 *
28 ******************************************************************************/
29
30 #include "cdf2skt.h"
31
32 /******************************************************************************
33 * Increased stack size for Borland C on IBM PC.
34 ******************************************************************************/
35
36 #if defined(BORLANDC)
37 extern unsigned _stklen = BORLANDC_STACK_SIZE;
38 #endif
39
40 /******************************************************************************
41 * Global variables.
42 ******************************************************************************/
43
44 Logical mLog;
45 FILE *SKTfp;
46 Logical useFormat;
47 Logical report[3];
48 Logical displayStats;
49
50 /******************************************************************************
51 * Main.
52 ******************************************************************************/
53
54 #if !defined(win32) || (defined(win32) && defined(ALONE))
55 MAIN {
56 Logical success = TRUE;
57 strcpyX (pgmName, "SkeletonTable", MAX_PROGRAM_NAME_LEN);
58 #if defined(mac)
59 MacExecuteSO (CreateSkeletonTable, SkeletonTableQOPs);
60 #else
61 success = CreateSkeletonTable (argc, argv);
62 #endif
63 #if defined(DEBUG)
64 if (cdf_FreeMemory(NULL,FatalError) > 0) DisplayWarning ("Abandoned buffers.");
65 #else
66 cdf_FreeMemory (NULL, FatalError);
67 #endif
68 return BOO(success,EXIT_SUCCESS_,EXIT_FAILURE_);
69 }
70 #endif
71
72 /******************************************************************************
73 * CreateSkeletonTable.
74 ******************************************************************************/
75
CreateSkeletonTable(argC,argV)76 Logical CreateSkeletonTable (argC, argV)
77 int argC;
78 char *argV[];
79 {
80 CDFstatus status; CDFid id;
81 char CDFpath[DU_MAX_PATH_LEN+1], CDFpathX[DU_MAX_PATH_LEN+1];
82 char CDFname[DU_MAX_NAME_LEN+1], dir[DU_MAX_DIR_LEN+1];
83 char SKTpath[DU_MAX_PATH_LEN+1], SKTpathX[DU_MAX_PATH_LEN+1];
84 char creationStamp[TIME_STAMP_LEN+1];
85 int count, varValues; long zMode; Logical negToPosFp0, outToScreen;
86 long workingCache, stageCache, compressCache;
87 char *variables = NULL;
88 Logical qopError = FALSE;
89 QOP *qop;
90 static char *validQuals[] = {
91 "skeleton", "nonrv", "nrvfile", "nrvtable", "log", "nolog", "zmode",
92 "neg2posfp0", "noneg2posfp0", "format", "noformat", "report", "screen",
93 "noscreen", "cache", "values", "page", "nopage", "about", "statistics",
94 "nostatistics", NULL };
95 static int optRequired[] = {
96 TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE,
97 TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, 0
98 };
99 static char *reportTokens[] = { "errors", "warnings", "informationals" };
100
101 /******************************************************************************
102 * Parse qualifiers/options/parameters (QOP).
103 ******************************************************************************/
104
105 switch (argC) {
106 case 1:
107 PageOLH ("cdf2skt.olh", argV[0]);
108 return TRUE;
109 case 2:
110 if (strcmp(argV[1],"-java") == 0) {
111 pagingOn = FALSE;
112 PageOLH ("cdf2sktj.olh", argV[0]);
113 return TRUE;
114 }
115 default:
116 qop = Qop (argC, argV, validQuals, optRequired);
117 if (qop == NULL) return FALSE;
118 /**************************************************************************
119 * Check for `about' qualifier.
120 **************************************************************************/
121 if (qop->qualEntered[ABOUTqual]) {
122 DisplayIdentification (pgmName);
123 cdf_FreeMemory (qop, FatalError);
124 return TRUE;
125 }
126 /**************************************************************************
127 * Get CDF pathname.
128 **************************************************************************/
129 if (qop->Nparms < 1) {
130 DisplayError ("Missing parameter.");
131 qopError = TRUE;
132 }
133 else {
134 strcpyX (CDFpath, qop->parms[CDFPATHparm], DU_MAX_PATH_LEN);
135 ParsePath (CDFpath, dir, CDFname);
136 }
137 /**************************************************************************
138 * Check if a skeleton table pathname was specified.
139 **************************************************************************/
140 if (qop->qualEntered[SKTqual])
141 strcpyX (SKTpath, qop->qualOpt[SKTqual], DU_MAX_PATH_LEN);
142 else {
143 if (EndsWithIgCase(CDFname, ".cdf"))
144 RemoveCDFFileExtension (CDFname, SKTpath);
145 else
146 strcpyX (SKTpath, CDFname, DU_MAX_PATH_LEN);
147 }
148 /**************************************************************************
149 * Check if which variable values should be displayed was specified.
150 **************************************************************************/
151 count = 0;
152 if (qop->qualEntered[NONRVqual]) count++;
153 if (qop->qualEntered[NRVFILEqual]) count++;
154 if (qop->qualEntered[NRVTABLEqual]) count++;
155 if (qop->qualEntered[VALUESqual]) count++;
156 switch (count) {
157 case 0:
158 varValues = DEFAULTvaluesCDF2SKT;
159 break;
160 case 1:
161 if (qop->qualEntered[NONRVqual]) {
162 varValues = NOvalues;
163 break;
164 }
165 if (qop->qualEntered[NRVFILEqual]) {
166 DisplayWarning ("NRV files are no longer supported.");
167 varValues = NRVvalues;
168 break;
169 }
170 if (qop->qualEntered[NRVTABLEqual]) {
171 varValues = NRVvalues;
172 break;
173 }
174 if (qop->qualEntered[VALUESqual]) {
175 size_t len = strlen(qop->qualOpt[VALUESqual]);
176 if (strcmpIgCase(qop->qualOpt[VALUESqual],"none") != 0)
177 varValues = NOvalues;
178 else if (strcmpIgCase(qop->qualOpt[VALUESqual],"nrv") != 0)
179 varValues = NRVvalues;
180 else if (strcmpIgCase(qop->qualOpt[VALUESqual],"rv") != 0)
181 varValues = RVvalues;
182 else if (strcmpIgCase(qop->qualOpt[VALUESqual],"all") != 0)
183 varValues = ALLvalues;
184 else {
185 varValues = NAMEDvalues;
186 variables = cdf_AllocateMemory (len + 1, FatalError);
187 strcpyX (variables, qop->qualOpt[VALUESqual], len);
188 }
189 }
190 break;
191 default:
192 DisplayError ("Specify only one variable values qualifier.");
193 qopError = TRUE;
194 }
195 /**************************************************************************
196 * Check for /ZMODE,-zmode qualifier.
197 **************************************************************************/
198 if (qop->qualEntered[ZMODEqual]) {
199 switch (qop->qualOpt[ZMODEqual][0]) {
200 case '0': zMode = zMODEoff; break;
201 case '1': zMode = zMODEon1; break;
202 case '2': zMode = zMODEon2; break;
203 default: {
204 DisplayError ("Illegal zMode.");
205 qopError = TRUE;
206 }
207 }
208 }
209 else
210 zMode = DEFAULTzModeCDF2SKT;
211 /**************************************************************************
212 * Check for `report' qualifier. If absent, use defaults.
213 **************************************************************************/
214 if (qop->qualEntered[REPORTqual]) {
215 if (!ParseOptionList(3,reportTokens,qop->qualOpt[REPORTqual],report)) {
216 DisplayError ("Illegal list of `report' options.");
217 qopError = TRUE;
218 }
219 }
220 else {
221 report[ERRORs] = REPORTerrorsDEFAULT;
222 report[WARNs] = REPORTwarningsDEFAULT;
223 report[INFOs] = REPORTinfosDEFAULT;
224 }
225 /***********************************************************************
226 * Check for `cache' qualifier.
227 ***********************************************************************/
228 if (qop->qualEntered[CACHEqual]) {
229 if (!ParseCacheSizes(qop->qualOpt[CACHEqual],
230 &workingCache,&stageCache,&compressCache)) {
231 DisplayError ("Illegal cache size/type.");
232 qopError = TRUE;
233 }
234 }
235 else {
236 workingCache = useDEFAULTcacheSIZE;
237 stageCache = useDEFAULTcacheSIZE;
238 compressCache = useDEFAULTcacheSIZE;
239 }
240 /**************************************************************************
241 * Check for `statistics', `log', `neg2posfp0', `screen', `page', and
242 * `format' qualifiers.
243 **************************************************************************/
244 qopError = qopError | !TFqualifier (qop,&displayStats,STATSqual,
245 NOSTATSqual,DEFAULTstatsCDF2SKT,
246 "statistics");
247 qopError = qopError | !TFqualifier(qop,&outToScreen,SCREENqual,
248 NOSCREENqual,DEFAULTscreenCDF2SKT,
249 "screen");
250 qopError = qopError | !TFqualifier(qop,&pagingOn,PAGEqual,NOPAGEqual,
251 DEFAULTpageCDF2SKT,"page");
252 qopError = qopError | !TFqualifier(qop,&mLog,LOGqual,NOLOGqual,
253 DEFAULTlogCDF2SKT,"log");
254 qopError = qopError | !TFqualifier(qop,&negToPosFp0,NEG2POSqual,
255 NONEG2POSqual,DEFAULT_NEGtoPOSfp0,
256 "neg2posfp0");
257 qopError = qopError | !TFqualifier(qop,&useFormat,FORMATqual,NOFORMATqual,
258 DEFAULTformatCDF2SKT,"format");
259 /**************************************************************************
260 * Check for conflicting/missing qualifiers.
261 **************************************************************************/
262 if (qop->qualEntered[SKTqual] && qop->qualEntered[SCREENqual]) {
263 DisplayError ("Conflicting qualifiers (`skeleton' and `screen').");
264 qopError = TRUE;
265 }
266 if (!qop->qualEntered[SCREENqual] && qop->qualEntered[PAGEqual]) {
267 DisplayError ("Conflicting qualifiers (`noscreen' and `page').");
268 qopError = TRUE;
269 }
270 /**************************************************************************
271 * Check for overridding qualifiers.
272 **************************************************************************/
273 if (qop->qualEntered[SCREENqual]) mLog = FALSE;
274 /**************************************************************************
275 * Free QOP memory and check for an error.
276 **************************************************************************/
277 cdf_FreeMemory (qop, FatalError);
278 if (qopError) return FALSE;
279 break;
280 }
281
282 CDFsetValidate (VALIDATEFILEon);
283 /******************************************************************************
284 * Create skeleton table.
285 ******************************************************************************/
286
287 if (mLog) {
288 WriteOut (stdout, "Name of CDF: ");
289 WriteOut (stdout, CDFname);
290 WriteOut (stdout, "\n");
291 }
292
293 TimeStamp (creationStamp);
294
295 if (outToScreen)
296 SKTfp = stdout;
297 else {
298 if (!EndsWithIgCase(SKTpath, ".skt"))
299 strcatX (SKTpath, ".skt", DU_MAX_PATH_LEN);
300 ExpandPath (SKTpath, SKTpathX);
301
302 /******************************************************************************
303 * Display information.
304 ******************************************************************************/
305
306 WriteOut (stdout, "Making a skeleton table from \"");
307 WriteOut (stdout, CDFpath);
308 if (!EndsWithIgCase(CDFpath, ".cdf"))
309 WriteOut (stdout, ".cdf");
310 WriteOut (stdout, "\" to \"");
311 WriteOut (stdout, SKTpath);
312 WriteOut (stdout, "\"...\n");
313
314 SKTfp = fopen (SKTpathX, "w");
315 if (SKTfp == NULL) {
316 WriteOut (stdout, "Error creating skeleton table (");
317 WriteOut (stdout, SKTpath);
318 WriteOut (stdout, ").\n");
319 return FALSE;
320 }
321 }
322
323 WriteOut (SKTfp, "! Skeleton table for the \"");
324 WriteOut (SKTfp, CDFname);
325 WriteOut (SKTfp, "\" CDF.");
326
327 WriteOut (SKTfp, "\n! Generated: ");
328 WriteOut (SKTfp, creationStamp);
329
330 /******************************************************************************
331 * Open CDF.
332 ******************************************************************************/
333
334 ExpandPath (CDFpath, CDFpathX);
335 status = CDFlib (OPEN_, CDF_, CDFpathX, &id,
336 SELECT_, CDF_READONLY_MODE_, READONLYon,
337 CDF_zMODE_, zMode,
338 CDF_NEGtoPOSfp0_MODE_, BOO(negToPosFp0,
339 NEGtoPOSfp0on,
340 NEGtoPOSfp0off),
341 CDF_CACHESIZE_, workingCache,
342 STAGE_CACHESIZE_, stageCache,
343 COMPRESS_CACHESIZE_, compressCache,
344 NULL_);
345 if (!StatusHandlerC2S(status)) return FALSE;
346
347 /******************************************************************************
348 * Write header section.
349 ******************************************************************************/
350
351 CHECKforABORTso
352 if (mLog) WriteOut (stdout, "Printing Header Information...\n");
353 if (!WriteHeader(CDFname)) return FALSE;
354
355 /******************************************************************************
356 * Write global scope attributes section.
357 ******************************************************************************/
358
359 if (mLog) WriteOut (stdout, "Printing Attribute Information...\n");
360 if (!WriteGlobalAttr()) return FALSE;
361
362 /******************************************************************************
363 * Write variable scope attributes section.
364 ******************************************************************************/
365
366 if (!WriteVarAttr()) return FALSE;
367
368 /******************************************************************************
369 * Write variables section.
370 ******************************************************************************/
371
372 if (mLog) WriteOut (stdout, "Printing Variable Information...\n");
373 if (!WriteVars(varValues,variables)) return FALSE;
374
375 /******************************************************************************
376 * End section.
377 ******************************************************************************/
378
379 if (!WriteEnd()) return FALSE;
380
381 /******************************************************************************
382 * Clean up.
383 ******************************************************************************/
384
385 WriteOut (SKTfp, "\n");
386 if (SKTfp != stdout) fclose (SKTfp);
387
388 if (displayStats) {
389 vSTATS vStatsDotCDF, vStatsStage, vStatsCompress;
390 status = CDFlib (CLOSE_, CDFwithSTATS_, &vStatsDotCDF,
391 &vStatsStage,
392 &vStatsCompress,
393 NULL_);
394 if (!StatusHandlerC2S(status)) return FALSE;
395 DisplayStatistics ("CDF", &vStatsDotCDF, &vStatsStage, &vStatsCompress);
396 }
397 else {
398 status = CDFlib (CLOSE_, CDF_,
399 NULL_);
400 if (!StatusHandlerC2S(status)) return FALSE;
401 }
402
403 if (variables != NULL) cdf_FreeMemory (variables, FatalError);
404
405 return TRUE;
406 }
407
408
409 /******************************************************************************
410 * WriteHeader.
411 ******************************************************************************/
412
WriteHeader(CDFname)413 Logical WriteHeader (CDFname)
414 char *CDFname;
415 {
416 CDFstatus status;
417 long encoding, majority, format;
418 long numDims;
419 long dimSizes[CDF_MAX_DIMS];
420 long numVars, numZvars, maxRec;
421 long numVattrs, numGattrs;
422 int dimN;
423 long version, release, increment;
424 char sizes[MAX_SIZES_LEN+1], subIncrement;
425 char text[MAX_TEXT_LEN+1], tempS[MAX_LINE_LEN+1];
426
427 status = CDFlib (GET_, CDF_VERSION_, &version,
428 CDF_RELEASE_, &release,
429 CDF_INCREMENT_, &increment,
430 NULL_);
431 if (!StatusHandlerC2S(status)) return FALSE;
432
433 WriteOutFP (SKTfp, "\n! CDF created/modified by CDF V%ld.%ld.%ld",
434 version, release, increment);
435
436 status = CDFlib (GET_, LIB_VERSION_, &version,
437 LIB_RELEASE_, &release,
438 LIB_INCREMENT_, &increment,
439 LIB_subINCREMENT_, &subIncrement,
440 NULL_);
441 if (!StatusHandlerC2S(status)) return FALSE;
442
443 WriteOutFP (SKTfp, "\n! Skeleton table created by CDF V%ld.%ld.%ld%c",
444 version, release, increment, subIncrement);
445
446 WriteOut (SKTfp, "\n");
447 WriteOut (SKTfp, "\n#header");
448
449 status = CDFlib (GET_, CDF_ENCODING_, &encoding,
450 CDF_MAJORITY_, &majority,
451 CDF_FORMAT_, &format,
452 rVARs_NUMDIMS_, &numDims,
453 rVARs_DIMSIZES_, dimSizes,
454 CDF_NUMrVARS_, &numVars,
455 CDF_NUMzVARS_, &numZvars,
456 CDF_NUMgATTRS_, &numGattrs,
457 CDF_NUMvATTRS_, &numVattrs,
458 rVARs_MAXREC_, &maxRec,
459 NULL_);
460 if (!StatusHandlerC2S(status)) return FALSE;
461
462 WriteOut (SKTfp, "\n");
463 WriteOut (SKTfp, "\n CDF NAME: ");
464 WriteOut (SKTfp, CDFname);
465
466 WriteOut (SKTfp, "\n DATA ENCODING: ");
467 WriteOut (SKTfp, EncodingToken(encoding));
468
469 WriteOut (SKTfp, "\n MAJORITY: ");
470 WriteOut (SKTfp, MajorityToken(majority));
471
472 WriteOut (SKTfp, "\n FORMAT: ");
473 WriteOut (SKTfp, FormatToken(format));
474
475 if (numDims > 0) {
476 sizes[0] = NUL;
477 for (dimN = 0; dimN < numDims; dimN++) {
478 sprintf (&sizes[strlen(sizes)], "%ld ", dimSizes[dimN]);
479 }
480 sizes[strlen(sizes)-1] = NUL; /* Wipe out trailing blank. */
481 }
482 else
483 strcpyX (sizes, "", MAX_SIZES_LEN);
484
485 WriteOut (SKTfp, "\n");
486 WriteOut (SKTfp,
487 "\n! Variables G.Attributes V.Attributes Records Dims ");
488
489 Ncharacters (SKTfp, FRONTpadLABEL("Sizes",sizes), (int) ' ');
490 WriteOut (SKTfp, "Sizes");
491
492 WriteOut (SKTfp,
493 "\n! --------- ------------ ------------ ------- ---- ");
494
495 Ncharacters (SKTfp, MaxInt((int)strlen("Sizes"),(int)strlen(sizes)), (int)'-');
496
497 WriteOut (SKTfp, "\n");
498 Ncharacters (SKTfp, 2, (int) ' ');
499 sprintf (text, "%ld/%ld", numVars, numZvars);
500 Ncharacters (SKTfp, MaxInt((int)(6 - strlen(text)),0), (int) ' ');
501 sprintf (tempS, "%s %7ld %7ld %5ld/z %3ld",
502 text, numGattrs, numVattrs, maxRec + 1, numDims);
503 WriteOut (SKTfp, tempS);
504
505 if (numDims > 0) {
506 WriteOut (SKTfp, " ");
507 Ncharacters (SKTfp, FRONTpadVALUE("Sizes",sizes), (int) ' ');
508 WriteOut (SKTfp, sizes);
509 }
510
511 return TRUE;
512 }
513
514
515 /******************************************************************************
516 * WriteGlobalAttr.
517 ******************************************************************************/
518
WriteGlobalAttr()519 Logical WriteGlobalAttr ()
520 {
521 CDFstatus status;
522 char delim; /* Delimeter for attribute name. */
523 long attrN, numAttrs, scope, maxEntry;
524 long dataType, numElements, entryN;
525 int ccc; /* Current Cursor Column (base is 0). */
526 void *value;
527 char attrName[CDF_ATTR_NAME_LEN256+1],
528 tempS[MAX_LINE_LEN+1];
529 int GattrCount = 0; /* Number of global scope attributes. */
530 int entryCount;
531
532 WriteOut (SKTfp, "\n\n");
533 WriteOut (SKTfp, "\n#GLOBALattributes");
534
535 status = CDFlib (GET_, CDF_NUMATTRS_, &numAttrs,
536 NULL_);
537 if (!StatusHandlerC2S(status)) return FALSE;
538
539 if (numAttrs > 0) {
540 for (attrN = 0; attrN < numAttrs; attrN++) {
541 status = CDFlib (SELECT_, ATTR_, attrN,
542 GET_, ATTR_NAME_, attrName,
543 ATTR_SCOPE_, &scope,
544 NULL_);
545 if (!StatusHandlerC2S(status)) return FALSE;
546 if (scope == GLOBAL_SCOPE) {
547 /***********************************************************************
548 * Global scope attribute...
549 ***********************************************************************/
550 GattrCount++;
551
552 status = CDFlib (GET_, ATTR_MAXgENTRY_, &maxEntry,
553 NULL_);
554 if (!StatusHandlerC2S(status)) return FALSE;
555
556 /***********************************************************************
557 * If first global scope attribute found, print field headings.
558 ***********************************************************************/
559
560 if (GattrCount == 1) {
561 WriteOut (SKTfp, "\n\n");
562 ccc = WriteOut (SKTfp, "! Attribute");
563 Ncharacters (SKTfp, ENTRY_NUM_COL - ccc, (int) ' ');
564 ccc += ENTRY_NUM_COL - ccc;
565 ccc += WriteOut (SKTfp, "Entry Data");
566
567 WriteOut (SKTfp, "\n");
568 ccc = WriteOut (SKTfp, "! Name ");
569 Ncharacters (SKTfp, ENTRY_NUM_COL - ccc, (int) ' ');
570 ccc += ENTRY_NUM_COL - ccc;
571 ccc += WriteOut (SKTfp, "Number Type Value");
572
573 WriteOut (SKTfp, "\n");
574 ccc = WriteOut (SKTfp, "! ---------");
575 Ncharacters (SKTfp, ENTRY_NUM_COL - ccc, (int) ' ');
576 ccc += ENTRY_NUM_COL - ccc;
577 ccc += WriteOut (SKTfp, "------ ---- -----");
578 }
579
580 /***********************************************************************
581 * Write name.
582 ***********************************************************************/
583
584 delim = PickDelimiter (attrName, strlen(attrName));
585 WriteOut (SKTfp, "\n\n");
586 sprintf (tempS, " %c%s%c", delim, attrName, delim);
587 ccc = WriteOut (SKTfp, tempS);
588
589 /***********************************************************************
590 * Write each entry.
591 ***********************************************************************/
592
593 entryCount = 0;
594
595 for (entryN = 0; entryN <= maxEntry; entryN++) {
596 status = CDFlib (SELECT_, gENTRY_, entryN,
597 GET_, gENTRY_DATATYPE_, &dataType,
598 gENTRY_NUMELEMS_, &numElements,
599 NULL_);
600 if (status != NO_SUCH_ENTRY) {
601 if (!StatusHandlerC2S(status)) return FALSE;
602 entryCount++;
603
604 value = cdf_AllocateMemory ((size_t) (CDFelemSize(dataType) *
605 numElements),
606 FatalError);
607
608 status = CDFlib (GET_, gENTRY_DATA_, value,
609 NULL_);
610 if (!StatusHandlerC2S(status)) return FALSE;
611
612 if (entryCount == 1) {
613 if (ccc > ENTRY_NUM_COL - 1) {
614 WriteOut (SKTfp, "\n");
615 ccc = 0;
616 }
617 }
618 else {
619 WriteOut (SKTfp, "\n");
620 ccc = 0;
621 }
622
623 Ncharacters (SKTfp, ENTRY_NUM_COL - ccc, (int) ' ');
624 ccc += ENTRY_NUM_COL - ccc;
625
626 sprintf (tempS, "%*ld: %s ", ENTRY_NUM_WIDTH, entryN + 1,
627 DataTypePaddedString(dataType));
628 ccc += WriteOut (SKTfp, tempS);
629
630 ccc += WriteOut (SKTfp, "{ ");
631 WriteEntryValue (SKTfp, dataType, numElements, value, ccc,
632 MAX_COL_TO_USE - 4);
633 /* -4 for possible " } ." */
634 ccc += WriteOut (SKTfp, " }");
635
636 cdf_FreeMemory (value, FatalError);
637 }
638 CHECKforABORTso
639 }
640 /***********************************************************************
641 * Write '.' after last entry.
642 ***********************************************************************/
643 WriteOut (SKTfp, " .");
644 }
645 CHECKforABORTso
646 }
647 if (GattrCount == 0) WriteOut (SKTfp, "\n\n! No global scope attributes.");
648 }
649 else
650 WriteOut (SKTfp, "\n\n! No global scope attributes.");
651
652 return TRUE;
653 }
654
655
656 /******************************************************************************
657 * WriteVarAttr.
658 ******************************************************************************/
659
WriteVarAttr()660 Logical WriteVarAttr ()
661 {
662 CDFstatus status;
663 char delim, /* Delimeter for attribute name. */
664 tempS[MAX_LINE_LEN+1];
665 long attrN, numAttrs, scope;
666 char attrName[CDF_ATTR_NAME_LEN256+1];
667 int VattrCount = 0; /* Number of variable scope attributes. */
668
669 WriteOut (SKTfp, "\n\n");
670 WriteOut (SKTfp, "\n#VARIABLEattributes");
671 WriteOut (SKTfp, "\n");
672
673 status = CDFlib (GET_, CDF_NUMATTRS_, &numAttrs,
674 NULL_);
675 if (!StatusHandlerC2S(status)) return FALSE;
676
677 if (numAttrs > 0) {
678 for (attrN = 0; attrN < numAttrs; attrN++) {
679 status = CDFlib (SELECT_, ATTR_, attrN,
680 GET_, ATTR_NAME_, attrName,
681 ATTR_SCOPE_, &scope,
682 NULL_);
683 if (!StatusHandlerC2S(status)) return FALSE;
684 if (scope == VARIABLE_SCOPE) {
685 /***********************************************************************
686 * Variable scope attribute...
687 ***********************************************************************/
688 VattrCount++;
689 delim = PickDelimiter (attrName, strlen(attrName));
690 sprintf (tempS, "\n %c%s%c", delim, attrName, delim);
691 WriteOut (SKTfp, tempS);
692 }
693 CHECKforABORTso
694 }
695 if (VattrCount == 0) WriteOut (SKTfp, "\n! No variable scope attributes.");
696 }
697 else
698 WriteOut (SKTfp, "\n! No variable scope attributes.");
699
700 return TRUE;
701 }
702
703
704 /******************************************************************************
705 * WriteVars.
706 ******************************************************************************/
707
WriteVars(varValues,variables)708 Logical WriteVars (varValues, variables)
709 int varValues;
710 char *variables;
711 {
712 CDFstatus status;
713 long numVars;
714 long numZvars;
715 long varN;
716
717 status = CDFlib (GET_, CDF_NUMrVARS_, &numVars,
718 CDF_NUMzVARS_, &numZvars,
719 NULL_);
720 if (!StatusHandlerC2S(status)) return FALSE;
721
722 WriteOut (SKTfp, "\n\n");
723 WriteOut (SKTfp, "\n#variables");
724
725 if (numVars == 0)
726 WriteOut (SKTfp, "\n\n! No rVariables.");
727 else
728 for (varN = 0; varN < numVars; varN++) {
729 if (!WriteVar(varN,varValues,variables,FALSE)) return FALSE;
730 }
731
732 WriteOut (SKTfp, "\n\n");
733 WriteOut (SKTfp, "\n#zVariables");
734
735 if (numZvars == 0)
736 WriteOut (SKTfp, "\n\n! No zVariables.");
737 else
738 for (varN = 0; varN < numZvars; varN++) {
739 if (!WriteVar(varN,varValues,variables,TRUE)) return FALSE;
740 }
741
742 return TRUE;
743 }
744
745 /******************************************************************************
746 * WriteVar.
747 ******************************************************************************/
748
WriteVar(varN,varValues,variables,zVar)749 Logical WriteVar (varN, varValues, variables, zVar)
750 long varN;
751 int varValues;
752 char *variables;
753 Logical zVar;
754 {
755 CDFstatus status;
756 long numDims, dimSizes[CDF_MAX_DIMS];
757 long numAttrs;
758 long maxRec;
759 long varDataType, varNumElements;
760 long entryDataType, entryNumElements;
761 long recVary, dimVarys[CDF_MAX_DIMS];
762 char varName[CDF_VAR_NAME_LEN256+1];
763 char attrName[CDF_ATTR_NAME_LEN256+1];
764 char delim;
765 long attrN;
766 long scope;
767 int dimN;
768 int ccc; /* Current Cursor Column (base is 0). */
769 void *value;
770 int VattrCount;
771 char varys[MAX_VARYS_LEN+1];
772 char sizes[MAX_SIZES_LEN+1];
773 char tempS[MAX_LINE_LEN+1];
774
775 status = CDFlib (SELECT_, VAR(zVar), varN,
776 GET_, VAR_NAME(zVar), varName,
777 VAR_DATATYPE(zVar), &varDataType,
778 VAR_NUMELEMS(zVar), &varNumElements,
779 VAR_RECVARY(zVar), &recVary,
780 VAR_DIMVARYS(zVar), dimVarys,
781 VAR_MAXREC(zVar), &maxRec,
782 NULL_);
783 if (!StatusHandlerC2S(status)) return FALSE;
784
785 if (zVar)
786 status = CDFlib (SELECT_, zVAR_, varN,
787 GET_, zVAR_NUMDIMS_, &numDims,
788 zVAR_DIMSIZES_, dimSizes,
789 NULL_);
790 else
791 status = CDFlib (GET_, rVARs_NUMDIMS_, &numDims,
792 rVARs_DIMSIZES_, dimSizes,
793 NULL_);
794 if (!StatusHandlerC2S(status)) return FALSE;
795
796 /***************************************************************************
797 * If zVariable, build dimension sizes string.
798 ***************************************************************************/
799
800 if (numDims > 0) {
801 sizes[0] = NUL;
802 for (dimN = 0; dimN < numDims; dimN++) {
803 sprintf (&sizes[strlen(sizes)], "%ld ", dimSizes[dimN]);
804 }
805 sizes[strlen(sizes)-1] = NUL; /* Wipe out trailing blank. */
806 }
807 else
808 strcpyX (sizes, "", MAX_SIZES_LEN);
809
810 /***************************************************************************
811 * Build dimension variance string.
812 ***************************************************************************/
813
814 if (numDims > 0) {
815 strcpyX (varys, "", MAX_VARYS_LEN);
816 for (dimN = 0; dimN < numDims; dimN++) {
817 strcatX (varys, TFvarianceToken(dimVarys[dimN]), MAX_VARYS_LEN);
818 strcatX (varys, " ", MAX_VARYS_LEN);
819 }
820 varys[strlen(varys)-1] = NUL; /* Wipe out trailing blank. */
821 }
822 else
823 strcpyX (varys, "", MAX_VARYS_LEN);
824
825 /***************************************************************************
826 * Write headings.
827 ***************************************************************************/
828
829 if (varN != 0) WriteOut (SKTfp, "\n"); /* Skip 2 lines after first
830 variable. */
831 WriteOut (SKTfp, "\n\n");
832 ccc = WriteOut (SKTfp, "! Variable");
833 Ncharacters (SKTfp, VAR_DATATYPE_COL - ccc, (int) ' ');
834 WriteOut (SKTfp, " Data Number ");
835
836 if (zVar) {
837 Ncharacters (SKTfp, 4, (int) ' ');
838 Ncharacters (SKTfp, 2, (int) ' ');
839 Ncharacters (SKTfp, MaxInt((int)strlen(sizes),
840 (int)strlen("Sizes")), (int) ' ');
841 Ncharacters (SKTfp, 2, (int) ' ');
842 }
843
844 WriteOut (SKTfp, " Record ");
845 Ncharacters (SKTfp, FRONTpadLABEL("Dimension",varys), (int) ' ');
846 WriteOut (SKTfp, "Dimension");
847
848 WriteOut (SKTfp, "\n");
849 ccc = WriteOut (SKTfp, "! Name ");
850 Ncharacters (SKTfp, VAR_DATATYPE_COL - ccc, (int) ' ');
851 WriteOut (SKTfp, " Type Elements ");
852
853 if (zVar) {
854 WriteOut (SKTfp, "Dims");
855 Ncharacters (SKTfp, 2, (int) ' ');
856 Ncharacters (SKTfp, FRONTpadLABEL("Sizes",sizes), (int) ' ');
857 WriteOut (SKTfp, "Sizes");
858 Ncharacters (SKTfp, BACKpadLABEL("Sizes",sizes), (int) ' ');
859 Ncharacters (SKTfp, 2, (int) ' ');
860 }
861
862 WriteOut (SKTfp, "Variance ");
863
864 Ncharacters (SKTfp, FRONTpadLABEL("Variances",varys), (int) ' ');
865 WriteOut (SKTfp, "Variances");
866
867 WriteOut (SKTfp, "\n");
868 ccc = WriteOut (SKTfp, "! --------");
869 Ncharacters (SKTfp, VAR_DATATYPE_COL - ccc, (int) ' ');
870 WriteOut (SKTfp, " ---- -------- ");
871
872 if (zVar) {
873 Ncharacters (SKTfp, 4, (int) '-');
874 Ncharacters (SKTfp, 2, (int) ' ');
875 Ncharacters (SKTfp, MaxInt((int)strlen("Sizes"),
876 (int)strlen(sizes)), (int) '-');
877 Ncharacters (SKTfp, 2, (int) ' ');
878 }
879
880 WriteOut (SKTfp, "-------- ");
881
882 Ncharacters (SKTfp, MaxInt((int)strlen("Variances"),
883 (int)strlen(varys)), (int) '-');
884
885 /***************************************************************************
886 * Write variable definition line.
887 ***************************************************************************/
888
889 WriteOut (SKTfp, "\n");
890
891 delim = PickDelimiter (varName, strlen(varName));
892 WriteOut (SKTfp, "\n");
893 sprintf (tempS, " %c%s%c", delim, varName, delim);
894 ccc = WriteOut (SKTfp, tempS);
895
896 if (ccc > VAR_DATATYPE_COL - 3) {
897 WriteOut (SKTfp, "\n");
898 ccc = 0;
899 }
900
901 Ncharacters (SKTfp, VAR_DATATYPE_COL - ccc, (int) ' ');
902
903 sprintf (tempS, "%s %*ld ", DataTypePaddedString(varDataType),
904 VAR_NUMELEMS_WIDTH, varNumElements);
905 WriteOut (SKTfp, tempS);
906
907 Ncharacters (SKTfp, 2, (int) ' ');
908
909 if (zVar) {
910 sprintf (tempS, " %*ld ", zVAR_NUMDIMS_WIDTH, numDims);
911 WriteOut (SKTfp, tempS);
912 Ncharacters (SKTfp, 2, (int) ' ');
913 Ncharacters (SKTfp, FRONTpadVALUE("Sizes",sizes), (int) ' ');
914 WriteOut (SKTfp, sizes);
915 Ncharacters (SKTfp, BACKpadVALUE("Sizes",sizes), (int) ' ');
916 Ncharacters (SKTfp, 2, (int) ' ');
917 }
918
919 WriteOut (SKTfp, " ");
920 WriteOut (SKTfp, TFvarianceToken(recVary));
921
922 if (numDims > 0) {
923 Ncharacters (SKTfp, 3, (int) ' ');
924 Ncharacters (SKTfp, 2, (int) ' ');
925 Ncharacters (SKTfp, FRONTpadVALUE("Variances",varys), (int) ' ');
926 WriteOut (SKTfp, varys);
927 }
928
929 CHECKforABORTso
930
931 /***************************************************************************
932 * Write corresponding attribute entries.
933 ***************************************************************************/
934
935 status = CDFlib (GET_, CDF_NUMATTRS_, &numAttrs,
936 NULL_);
937 if (!StatusHandlerC2S(status)) return FALSE;
938
939 VattrCount = 0;
940
941 WriteOut (SKTfp, "\n");
942
943 for (attrN = 0; attrN < numAttrs; attrN++) {
944 status = CDFlib (SELECT_, ATTR_, attrN,
945 GET_, ATTR_SCOPE_, &scope,
946 ATTR_NAME_, attrName,
947 NULL_);
948 if (!StatusHandlerC2S(status)) return FALSE;
949
950 if (scope == VARIABLE_SCOPE) {
951 status = CDFlib (SELECT_, BOO(zVar,zENTRY_,rENTRY_), varN,
952 GET_, BOO(zVar,zENTRY_DATATYPE_,
953 rENTRY_DATATYPE_), &entryDataType,
954 BOO(zVar,zENTRY_NUMELEMS_,
955 rENTRY_NUMELEMS_), &entryNumElements,
956 NULL_);
957 if (status != NO_SUCH_ENTRY) {
958 if (!StatusHandlerC2S(status)) return FALSE;
959 VattrCount++;
960
961 if (VattrCount == 1) {
962 WriteOut (SKTfp, "\n");
963 ccc = WriteOut (SKTfp, " ! Attribute");
964 Ncharacters (SKTfp, ENTRY_DATATYPE_COL - ccc, (int) ' ');
965 ccc += ENTRY_DATATYPE_COL - ccc;
966 ccc += WriteOut (SKTfp, " Data");
967
968 WriteOut (SKTfp, "\n");
969 ccc = WriteOut (SKTfp, " ! Name ");
970 Ncharacters (SKTfp, ENTRY_DATATYPE_COL - ccc, (int) ' ');
971 ccc += ENTRY_DATATYPE_COL - ccc;
972 ccc += WriteOut (SKTfp, " Type Value");
973
974 WriteOut (SKTfp, "\n");
975 ccc = WriteOut (SKTfp, " ! --------");
976 Ncharacters (SKTfp, ENTRY_DATATYPE_COL - ccc, (int) ' ');
977 ccc += ENTRY_DATATYPE_COL - ccc;
978 ccc += WriteOut (SKTfp, " ---- -----");
979
980 WriteOut (SKTfp, "\n");
981 }
982
983 value = cdf_AllocateMemory ((size_t) (entryNumElements *
984 CDFelemSize(entryDataType)),
985 FatalError);
986
987 status = CDFlib (GET_, BOO(zVar,zENTRY_DATA_,rENTRY_DATA_), value,
988 NULL_);
989 if (!StatusHandlerC2S(status)) return FALSE;
990
991 delim = PickDelimiter (attrName, strlen(attrName));
992 WriteOut (SKTfp, "\n");
993 sprintf (tempS, " %c%s%c", delim, attrName, delim);
994 ccc = WriteOut (SKTfp, tempS);
995
996 if (ccc > ENTRY_DATATYPE_COL - 2) {
997 WriteOut (SKTfp, "\n");
998 ccc = 0;
999 }
1000
1001 Ncharacters (SKTfp, ENTRY_DATATYPE_COL - ccc, (int) ' ');
1002 ccc += ENTRY_DATATYPE_COL - ccc;
1003
1004 ccc += WriteOut (SKTfp, DataTypePaddedString(entryDataType));
1005 ccc += WriteOut (SKTfp, " ");
1006
1007 ccc += WriteOut (SKTfp, "{ ");
1008 WriteEntryValue (SKTfp, entryDataType, entryNumElements,
1009 value, ccc, MAX_COL_TO_USE - 4);
1010 /* -4 for possible " } ." */
1011 ccc += WriteOut (SKTfp, " }");
1012
1013 cdf_FreeMemory (value, FatalError);
1014 }
1015 }
1016 CHECKforABORTso
1017 }
1018
1019 if (VattrCount == 0) {
1020 WriteOut (SKTfp,
1021 "\n ! No variable scope attribute entries for this variable.");
1022 }
1023
1024 /***************************************************************************
1025 * Write terminating period.
1026 ***************************************************************************/
1027
1028 if (VattrCount == 0) {
1029 WriteOut (SKTfp, "\n\n .");
1030 WriteOut (SKTfp,
1031 " ! Terminating period required.");
1032 }
1033 else
1034 WriteOut (SKTfp, " .");
1035
1036 /***************************************************************************
1037 * Write data values (if requested).
1038 ***************************************************************************/
1039
1040 switch (varValues) {
1041 case NOvalues:
1042 WriteOut (SKTfp, "\n\n ! Values were not requested.");
1043 break;
1044 case NRVvalues:
1045 if (recVary)
1046 WriteOut (SKTfp, "\n\n ! RV values were not requested.");
1047 else
1048 if (maxRec == 0) {
1049 WriteOut (SKTfp, "\n\n ! NRV values follow...\n");
1050 if (!WriteVariableData(SKTfp,zVar,varN,varDataType,
1051 varNumElements,numDims,dimSizes,
1052 recVary,dimVarys,maxRec)) return FALSE;
1053 }
1054 else
1055 WriteOut (SKTfp, "\n\n ! No values (no records for this variable).");
1056 break;
1057 case RVvalues:
1058 if (!recVary)
1059 WriteOut (SKTfp, "\n\n ! NRV values were not requested.");
1060 else
1061 if (maxRec > -1) {
1062 WriteOut (SKTfp, "\n\n ! RV values follow...\n");
1063 if (!WriteVariableData(SKTfp,zVar,varN,varDataType,
1064 varNumElements,numDims,dimSizes,
1065 recVary,dimVarys,maxRec)) return FALSE;
1066 }
1067 else
1068 WriteOut (SKTfp, "\n\n ! No values (no records for this variable).");
1069 break;
1070 case ALLvalues:
1071 if (maxRec > -1) {
1072 WriteOut (SKTfp, "\n\n ! Values follow...\n");
1073 if (!WriteVariableData(SKTfp,zVar,varN,varDataType,
1074 varNumElements,numDims,dimSizes,
1075 recVary,dimVarys,maxRec)) return FALSE;
1076 }
1077 else
1078 WriteOut (SKTfp, "\n\n ! No values (no records for this variable).");
1079 break;
1080 case NAMEDvalues:
1081 if (VariableSelected(varName,variables))
1082 if (maxRec > -1) {
1083 WriteOut (SKTfp, "\n\n ! Values follow...\n");
1084 if (!WriteVariableData(SKTfp,zVar,varN,varDataType,
1085 varNumElements,numDims,dimSizes,
1086 recVary,dimVarys,maxRec)) return FALSE;
1087 }
1088 else
1089 WriteOut (SKTfp, "\n\n ! No values (no records for this variable).");
1090 else
1091 WriteOut (SKTfp, "\n\n ! Values were not requested.");
1092 break;
1093 }
1094
1095 return TRUE;
1096 }
1097
1098 /******************************************************************************
1099 * WriteEnd.
1100 ******************************************************************************/
1101
WriteEnd()1102 Logical WriteEnd ()
1103 {
1104 WriteOut (SKTfp, "\n\n");
1105 WriteOut (SKTfp, "\n#end");
1106 return TRUE;
1107 }
1108
1109 /******************************************************************************
1110 * WriteVariableData.
1111 * It is assumed that there is at least one record in the CDF.
1112 ******************************************************************************/
1113
WriteVariableData(fp,zVar,varN,dataType,numElements,numDims,dimSizes,recVary,dimVarys,maxRec)1114 Logical WriteVariableData (fp, zVar, varN, dataType, numElements, numDims,
1115 dimSizes, recVary, dimVarys, maxRec)
1116 FILE *fp;
1117 Logical zVar;
1118 long varN;
1119 long dataType;
1120 long numElements;
1121 long numDims;
1122 long dimSizes[];
1123 long recVary;
1124 long dimVarys[];
1125 long maxRec;
1126 {
1127 CDFstatus status;
1128 long indices[CDF_MAX_DIMS];
1129 long counts[CDF_MAX_DIMS];
1130 void *value;
1131 long majority;
1132 int ccc;
1133 long nRecValues, i, recN;
1134 int dimN;
1135 char Evalue[80+1], *format, tempS[MAX_LINE_LEN+1];
1136 status = CDFlib (SELECT_, VAR(zVar), varN,
1137 GET_, CDF_MAJORITY_, &majority,
1138 NULL_);
1139 if (!StatusHandlerC2S(status)) return FALSE;
1140 nRecValues = 1;
1141 if (numDims > 0) {
1142 for (dimN = 0; dimN < numDims; dimN++) {
1143 indices[dimN] = 0;
1144 if (dimVarys[dimN]) {
1145 nRecValues *= dimSizes[dimN];
1146 counts[dimN] = dimSizes[dimN];
1147 }
1148 else
1149 counts[dimN] = 1;
1150 }
1151 }
1152 value = cdf_AllocateMemory ((size_t) (numElements * CDFelemSize(dataType)),
1153 FatalError);
1154 if (useFormat) {
1155 status = GetFormatEntry (zVar, varN, &format);
1156 if (!StatusHandlerC2S(status)) {
1157 cdf_FreeMemory (value, FatalError);
1158 return FALSE;
1159 }
1160 }
1161 else
1162 format = NULL;
1163 for (recN = 0; recN <= maxRec; recN++) {
1164 status = CDFlib (SELECT_, BOO(zVar,zVAR_RECNUMBER_,
1165 rVARs_RECNUMBER_), recN,
1166 NULL_);
1167 if (!StatusHandlerC2S(status)) {
1168 cdf_FreeMemory (value, FatalError);
1169 if (format != NULL) cdf_FreeMemory (format, FatalError);
1170 return FALSE;
1171 }
1172 for (i = 0; i < nRecValues; i++) {
1173 status = CDFlib (SELECT_, BOO(zVar,zVAR_DIMINDICES_,
1174 rVARs_DIMINDICES_), indices,
1175 GET_, VAR_DATA(zVar), value,
1176 NULL_);
1177 if (!StatusHandlerC2S(status)) {
1178 cdf_FreeMemory (value, FatalError);
1179 if (format != NULL) cdf_FreeMemory (format, FatalError);
1180 return FALSE;
1181 }
1182 ccc = WriteOut (fp, "\n ");
1183 if (recVary) {
1184 sprintf (tempS, "%ld:[", recN + 1);
1185 }
1186 else
1187 strcpyX (tempS, "[", MAX_LINE_LEN);
1188 if (numDims > 0) {
1189 for (dimN = 0; dimN < numDims; dimN++) {
1190 sprintf (EofS(tempS), "%ld", indices[dimN] + 1);
1191 if (dimN != numDims-1) strcatX (tempS, ",", MAX_LINE_LEN);
1192 }
1193 }
1194 strcatX (tempS, "] = ",MAX_LINE_LEN);
1195 ccc += WriteOut (SKTfp, tempS);
1196 if (STRINGdataType(dataType)) {
1197 ccc += WriteOut (fp, "{ ");
1198 WriteStringValue (fp, numElements, value, ccc,
1199 MAX_COL_TO_USE - 2); /* -2 for " }" */
1200 WriteOut (fp, " }");
1201 }
1202 else {
1203 EncodeValuesFormat (dataType, 1L, value, Evalue,
1204 format, 0, 0, EPOCH0_STYLE);
1205 /* Don't care about width. */
1206 WriteOut (fp, Evalue);
1207 }
1208 if (ROWmajor(majority))
1209 INCRindicesROW (numDims, counts, indices);
1210 else
1211 INCRindicesCOL (numDims, counts, indices);
1212 CHECKforABORTso
1213 }
1214 }
1215 cdf_FreeMemory (value, FatalError);
1216 if (format != NULL) cdf_FreeMemory (format, FatalError);
1217 return TRUE;
1218 }
1219
1220 /******************************************************************************
1221 * VariableSelected.
1222 * The assumed format of the list of delimited variable names is...
1223 * <delim><chars><delim>,<delim><chars><delim>,...,<delim><chars><delim>
1224 ******************************************************************************/
1225
VariableSelected(varName,variables)1226 Logical VariableSelected (varName, variables)
1227 char *varName;
1228 char *variables;
1229 {
1230 char *d1, *d2, varNameT[CDF_VAR_NAME_LEN256+1];
1231 size_t len;
1232 d1 = variables;
1233 for (;;) {
1234 while (*d1 != NUL && Spacing(*d1)) d1++;
1235 if (*d1 == NUL) return FALSE;
1236 d2 = d1 + 1;
1237 while (*d2 != NUL && *d2 != *d1) d2++;
1238 if (*d2 == NUL) return FALSE;
1239 len = (size_t) (d2 - d1 - 1);
1240 strcpyX (varNameT, d1 + 1, MINIMUM(len,CDF_VAR_NAME_LEN256));
1241 if (!strcmpITB(varName,varNameT)) return TRUE;
1242 d1 = d2 + 1;
1243 while (*d1 != NUL && *d1 != ',') d1++;
1244 if (*d1 == NUL) return FALSE;
1245 d1++;
1246 }
1247 }
1248
1249 /******************************************************************************
1250 * DataTypePaddedString.
1251 * Strings are blank-padded on the end to all be the same length.
1252 ******************************************************************************/
1253
DataTypePaddedString(dataType)1254 char *DataTypePaddedString (dataType)
1255 long dataType;
1256 {
1257 switch (dataType) {
1258 case CDF_BYTE: return "CDF_BYTE ";
1259 case CDF_INT1: return "CDF_INT1 ";
1260 case CDF_INT2: return "CDF_INT2 ";
1261 case CDF_INT4: return "CDF_INT4 ";
1262 case CDF_UINT1: return "CDF_UINT1 ";
1263 case CDF_UINT2: return "CDF_UINT2 ";
1264 case CDF_UINT4: return "CDF_UINT4 ";
1265 case CDF_REAL4: return "CDF_REAL4 ";
1266 case CDF_REAL8: return "CDF_REAL8 ";
1267 case CDF_FLOAT: return "CDF_FLOAT ";
1268 case CDF_DOUBLE: return "CDF_DOUBLE";
1269 case CDF_EPOCH: return "CDF_EPOCH ";
1270 case CDF_CHAR: return "CDF_CHAR ";
1271 case CDF_UCHAR: return "CDF_UCHAR ";
1272 case CDF_EPOCH16: return "CDF_EPOCH16";
1273 }
1274 return "??????????";
1275 }
1276
1277 /******************************************************************************
1278 * StatusHandlerC2S.
1279 ******************************************************************************/
1280
StatusHandlerC2S(status)1281 Logical StatusHandlerC2S (status)
1282 CDFstatus status;
1283 {
1284 char text[CDF_STATUSTEXT_LEN + 1];
1285
1286 if (StatusERROR(status)) {
1287 if (report[ERRORs]) {
1288 CDFlib (SELECT_, CDF_STATUS_, status,
1289 GET_, STATUS_TEXT_, text,
1290 NULL_);
1291 WriteOut (stdout, "\nERROR> ");
1292 WriteOut (stdout, text);
1293 WriteOut (stdout, "\n");
1294 }
1295 CDFlib (CLOSE_, CDF_,
1296 NULL_);
1297 WriteOut (stdout, "**** THE SKELETON TABLE IS INCOMPLETE ****\n");
1298 if (SKTfp != stdout) {
1299 WriteOut (SKTfp, "\n");
1300 WriteOut (SKTfp, "\n**** THIS SKELETON TABLE IS NOT COMPLETE ****");
1301 WriteOut (SKTfp, "\n");
1302 fclose (SKTfp);
1303 }
1304 return FALSE;
1305 }
1306
1307 if (StatusWARN(status) && report[WARNs]) {
1308 CDFlib (SELECT_, CDF_STATUS_, status,
1309 GET_, STATUS_TEXT_, text,
1310 NULL_);
1311 WriteOut (stdout, "\nWARNING> ");
1312 WriteOut (stdout, text);
1313 WriteOut (stdout, "\n");
1314 return TRUE;
1315 }
1316
1317 if (StatusINFO(status) && report[INFOs]) {
1318 CDFlib (SELECT_, CDF_STATUS_, status,
1319 GET_, STATUS_TEXT_, text,
1320 NULL_);
1321 WriteOut (stdout, "\nINFO> ");
1322 WriteOut (stdout, text);
1323 WriteOut (stdout, "\n");
1324 return TRUE;
1325 }
1326
1327 return TRUE; /* CDF_OK */
1328 }
1329
1330 /******************************************************************************
1331 * SkeletonTableQOPs.
1332 * Returns TRUE if execution should continue.
1333 ******************************************************************************/
1334
1335 #if defined(mac)
SkeletonTableQOPs(argC,argV)1336 Logical SkeletonTableQOPs (argC, argV)
1337 int *argC;
1338 char **argV[];
1339 {
1340 DialogPtr dialogP;
1341 DialogRecord dRecord;
1342 WindowPtr behind = (WindowPtr) -1;
1343 ControlHandle controlHs[MAXIMUMin+1];
1344 Rect iRect;
1345 #ifdef __MWERKS__
1346 ModalFilterUPP FilterDialogQOPsoUPP;
1347 FileFilterUPP FilterForCDFsUPP;
1348 UserItemUPP OutlineDefaultButtonUPP;
1349 #endif
1350 short itemN, iType, i;
1351 static Logical first = TRUE;
1352 char cancelTitle[] = "Cancel";
1353 static Logical outToScreen = DEFAULTscreenCDF2SKT;
1354 static Logical useFormat = DEFAULTformatCDF2SKT;
1355 static Logical negToPos = DEFAULT_NEGtoPOSfp0;
1356 static Logical pageOutput = DEFAULTpageCDF2SKT;
1357 static Logical reportInfos = REPORTinfosDEFAULT;
1358 static Logical reportWarns = REPORTwarningsDEFAULT;
1359 static Logical reportErrors = REPORTerrorsDEFAULT;
1360 static Logical logMsg = DEFAULTlogCDF2SKT;
1361 static Logical dispStats = DEFAULTstatsEDIT;
1362 static int zModeSrc = DEFAULTzModeCDF2SKT;
1363 static int varValues = DEFAULTvaluesCDF2SKT;
1364 static Str255 CDFtext = "\p";
1365 static Str255 sktText = "\p";
1366 static Str255 cacheText = "\p";
1367 static Str255 varsText = "\p";
1368 /****************************************************************************
1369 * Create the dialog and get the control handles.
1370 ****************************************************************************/
1371 dialogP = GetNewDialog (QOPri, &dRecord, behind);
1372 for (itemN = 1; itemN <= MAXIMUMin; itemN++) {
1373 GetDItem (dialogP, itemN, &iType, (Handle *) &controlHs[itemN], &iRect);
1374 }
1375 /****************************************************************************
1376 * Set the control values.
1377 ****************************************************************************/
1378 SetIText ((Handle) controlHs[CDFTEXTin], CDFtext);
1379 SetIText ((Handle) controlHs[SKTTEXTin], sktText);
1380 SetIText ((Handle) controlHs[CACHEin], cacheText);
1381 SetIText ((Handle) controlHs[VARSin], varsText);
1382 if (outToScreen) SetCtlValue (controlHs[SCREENin], 1);
1383 if (useFormat) SetCtlValue (controlHs[FORMATin], 1);
1384 if (negToPos) SetCtlValue (controlHs[NEGZin], 1);
1385 if (pageOutput) SetCtlValue (controlHs[PAGEin], 1);
1386 if (reportInfos) SetCtlValue (controlHs[INFOin], 1);
1387 if (reportWarns) SetCtlValue (controlHs[WARNin], 1);
1388 if (reportErrors) SetCtlValue (controlHs[ERRORin], 1);
1389 if (dispStats) SetCtlValue (controlHs[STATSin], 1);
1390 if (logMsg) SetCtlValue (controlHs[LOGin], 1);
1391 SetCtlValue (controlHs[ZMODEinBASE+zModeSrc], 1);
1392 SetCtlValue (controlHs[VALUESinBASE+varValues], 1);
1393
1394 #ifndef __MWERKS__
1395 SetDItem (dialogP, (short) ODBin, (short) userItem,
1396 (Handle) OutlineDefaultButton, &iRect);
1397 #else
1398 OutlineDefaultButtonUPP = NewUserItemProc (OutlineDefaultButton);
1399 SetDItem (dialogP, (short) ODBin, (short) userItem,
1400 (Handle) OutlineDefaultButtonUPP, &iRect);
1401 #endif
1402 /****************************************************************************
1403 * Change the "Quit" button to a "Cancel" button after the first time.
1404 ****************************************************************************/
1405 if (first)
1406 first = FALSE;
1407 else
1408 SetCTitle (controlHs[CANCELin], CtoPstr(cancelTitle));
1409 /****************************************************************************
1410 * Display the dialog and wait for user actions.
1411 ****************************************************************************/
1412 ShowWindow ((WindowPtr) dialogP);
1413 SetCursor (ARROW_CURSOR);
1414 #ifdef __MWERKS__
1415 FilterDialogQOPsoUPP = NewModalFilterProc (FilterDialogQOPso);
1416 #endif
1417
1418 for (;;) {
1419 #ifndef __MWERKS__
1420 ModalDialog (FilterDialogQOPso, &itemN);
1421 #else
1422 ModalDialog (FilterDialogQOPsoUPP, &itemN);
1423 #endif
1424 switch (itemN) {
1425 /************************************************************************
1426 * Ok.
1427 ************************************************************************/
1428 case OKin: {
1429 char *valuesOptions[5] = { "off", "nrv", "rv", "all", NULL };
1430 int n;
1431 char tempS1[1+1];
1432 /**********************************************************************
1433 * Get the value of each control.
1434 **********************************************************************/
1435 GetIText ((Handle) controlHs[CDFTEXTin], CDFtext);
1436 GetIText ((Handle) controlHs[SKTTEXTin], sktText);
1437 GetIText ((Handle) controlHs[CACHEin], cacheText);
1438 GetIText ((Handle) controlHs[VARSin], varsText);
1439 outToScreen = GetCtlValue (controlHs[SCREENin]);
1440 useFormat = GetCtlValue (controlHs[FORMATin]);
1441 negToPos = GetCtlValue (controlHs[NEGZin]);
1442 pageOutput = GetCtlValue (controlHs[PAGEin]);
1443 reportInfos = GetCtlValue (controlHs[INFOin]);
1444 reportWarns = GetCtlValue (controlHs[WARNin]);
1445 reportErrors = GetCtlValue (controlHs[ERRORin]);
1446 dispStats = GetCtlValue (controlHs[STATSin]);
1447 logMsg = GetCtlValue (controlHs[LOGin]);
1448 for (varValues = 0; varValues < 5; varValues++) {
1449 if (GetCtlValue(controlHs[VALUESinBASE+varValues])) break;
1450 }
1451 for (zModeSrc = 0; zModeSrc < 3; zModeSrc++) {
1452 if (GetCtlValue(controlHs[ZMODEinBASE+zModeSrc])) break;
1453 }
1454 /**********************************************************************
1455 * Build argc/argv.
1456 **********************************************************************/
1457 *argC = 13 + BOO(NULpString(CDFtext),0,1) +
1458 BOO(NULpString(sktText),0,2) +
1459 BOO(NULpString(cacheText),0,2);
1460 *argV = (char **) cdf_AllocateMemory (*argC * sizeof(char *),
1461 FatalError);
1462 n = 0;
1463 MAKEstrARGv (argV, n, pgmName)
1464 MAKEbooARGv (argV, n, outToScreen, "-screen", "-noscreen")
1465 MAKEbooARGv (argV, n, useFormat, "-format", "-noformat")
1466 MAKEbooARGv (argV, n, negToPos, "-neg2posfp0", "-noneg2posfp0")
1467 MAKEbooARGv (argV, n, pageOutput, "-page", "-nopage")
1468 MAKEbooARGv (argV, n, dispStats, "-statistics", "-nostatistics")
1469 MAKEbooARGv (argV, n, logMsg, "-log", "-nolog")
1470 MAKEstrARGv (argV, n, "-zmode")
1471 sprintf (tempS1, "%d", zModeSrc);
1472 MAKEstrARGv (argV, n, tempS1)
1473 MAKEstrARGv (argV, n, "-report")
1474 MAKEstrARGv (argV, n, StatusCodeReportOptions(reportErrors,
1475 reportWarns,
1476 reportInfos))
1477 MAKEstrARGv (argV, n, "-values")
1478 switch (varValues) {
1479 case NAMEDvalues:
1480 PtoCstr (varsText);
1481 MAKEstrARGv (argV, n, (char *) varsText)
1482 CtoPstr ((char *) varsText);
1483 break;
1484 default:
1485 MAKEstrARGv (argV, n, valuesOptions[varValues])
1486 break;
1487 }
1488 if (!NULpString(sktText)) {
1489 MAKEstrARGv (argV, n, "-skeleton")
1490 PtoCstr (sktText);
1491 MAKEstrARGv (argV, n, (char *) sktText)
1492 CtoPstr ((char *) sktText);
1493 }
1494 if (!NULpString(cacheText)) {
1495 MAKEstrARGv (argV, n, "-cache")
1496 PtoCstr (cacheText);
1497 MAKEstrARGv (argV, n, (char *) cacheText)
1498 CtoPstr ((char *) cacheText);
1499 }
1500 if (!NULpString(CDFtext)) {
1501 PtoCstr (CDFtext);
1502 MAKEstrARGv (argV, n, (char *) CDFtext)
1503 CtoPstr ((char *) CDFtext);
1504 }
1505 /**********************************************************************
1506 * Close the dialog and return.
1507 **********************************************************************/
1508 CloseDialog (dialogP);
1509 #ifdef __MWERKS__
1510 DisposeRoutineDescriptor (FilterDialogQOPsoUPP);
1511 DisposeRoutineDescriptor (OutlineDefaultButtonUPP);
1512 #endif
1513 return TRUE;
1514 }
1515 /************************************************************************
1516 * Help.
1517 ************************************************************************/
1518 case HELPin: {
1519 int n;
1520 *argC = 1;
1521 *argV = (char **) cdf_AllocateMemory (*argC * sizeof(char *), FatalError);
1522 n = 0;
1523 MAKEstrARGv (argV, n, pgmName)
1524 #ifdef __MWERKS__
1525 DisposeRoutineDescriptor (FilterDialogQOPsoUPP);
1526 DisposeRoutineDescriptor (OutlineDefaultButtonUPP);
1527 #endif
1528 CloseDialog (dialogP);
1529 return TRUE;
1530 }
1531 /************************************************************************
1532 * Cancel.
1533 ************************************************************************/
1534 case CANCELin:
1535 #ifdef __MWERKS__
1536 DisposeRoutineDescriptor (FilterDialogQOPsoUPP);
1537 DisposeRoutineDescriptor (OutlineDefaultButtonUPP);
1538 #endif
1539 CloseDialog (dialogP);
1540 return FALSE;
1541 /************************************************************************
1542 * Select CDF specification.
1543 ************************************************************************/
1544 case CDFSELECTin: {
1545 StandardFileReply CDFreply;
1546 char CDFpath[DU_MAX_PATH_LEN+1];
1547 #ifndef __MWERKS__
1548 StandardGetFile (FilterForCDFs, -1, NULL, &CDFreply);
1549 #else
1550 FilterForCDFsUPP = NewFileFilterProc((ProcPtr) FilterForCDFs);
1551 StandardGetFile (FilterForCDFsUPP, -1, NULL, &CDFreply);
1552 DisposeRoutineDescriptor (FilterForCDFsUPP);
1553 #endif
1554 if (CDFreply.sfGood && !CDFreply.sfIsFolder && !CDFreply.sfIsVolume) {
1555 BuildMacPath (&CDFreply.sfFile, CDFpath, TRUE);
1556 CDFtext[0] = strlen (CDFpath);
1557 strcpyX ((char *) &CDFtext[1], CDFpath, 255);
1558 SetIText ((Handle) controlHs[CDFTEXTin], CDFtext);
1559 }
1560 break;
1561 }
1562 /************************************************************************
1563 * Select skeleton CDF.
1564 * The cursor is set because `StandardPutFile' leaves the cursor as an
1565 * iBeam (instead of returning it to what it was).
1566 ************************************************************************/
1567 case SKTSELECTin: {
1568 StandardFileReply sktReply;
1569 char sktPath[DU_MAX_PATH_LEN+1], prompt[] = "Enter skeleton table:";
1570 StandardPutFile (CtoPstr(prompt), CtoPstr(""), &sktReply);
1571 if (sktReply.sfGood && !sktReply.sfIsFolder && !sktReply.sfIsVolume) {
1572 BuildMacPath (&sktReply.sfFile, sktPath, TRUE);
1573 sktText[0] = strlen (sktPath);
1574 strcpyX ((char *) &sktText[1], sktPath, 255);
1575 SetIText ((Handle) controlHs[SKTTEXTin], sktText);
1576 }
1577 SetCursor (&(qd.arrow));
1578 break;
1579 }
1580 /************************************************************************
1581 * Check boxes.
1582 ************************************************************************/
1583 case SCREENin:
1584 case FORMATin:
1585 case NEGZin:
1586 case PAGEin:
1587 case INFOin:
1588 case WARNin:
1589 case ERRORin:
1590 case STATSin:
1591 case LOGin:
1592 SetCtlValue (controlHs[itemN], BOO(GetCtlValue(controlHs[itemN]),0,1));
1593 break;
1594 /************************************************************************
1595 * Radio buttons.
1596 ************************************************************************/
1597 case VALUESinBASE+0:
1598 case VALUESinBASE+1:
1599 case VALUESinBASE+2:
1600 case VALUESinBASE+3:
1601 case VALUESinBASE+4:
1602 for (i = 0; i < 5; i++) SetCtlValue (controlHs[VALUESinBASE+i], 0);
1603 SetCtlValue (controlHs[itemN], 1);
1604 break;
1605 case ZMODEinBASE+0:
1606 case ZMODEinBASE+1:
1607 case ZMODEinBASE+2:
1608 for (i = 0; i < 3; i++) SetCtlValue (controlHs[ZMODEinBASE+i], 0);
1609 SetCtlValue (controlHs[itemN], 1);
1610 break;
1611 }
1612 }
1613 }
1614 #endif
1615