1/*********************************************************************
2 *   Copyright 1993, UCAR/Unidata
3 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
4 *********************************************************************/
5/* $Id: main.c,v 1.33 2010/05/26 21:43:36 dmh Exp $ */
6/* $Header: /upc/share/CVS/netcdf-3/ncgen/main.c,v 1.33 2010/05/26 21:43:36 dmh Exp $ */
7
8#include "includes.h"
9#include "offsets.h"
10#ifdef HAVE_GETOPT_H
11#include <getopt.h>
12#endif
13
14#ifdef _MSC_VER
15#include "XGetopt.h"
16#define snprintf _snprintf
17int opterr;
18int optind;
19#endif
20
21/* Default is netcdf-3 mode 1 */
22#define DFALTCMODE 0
23
24extern void init_netcdf(void);
25extern void parse_init(void);
26extern int ncgparse(void);
27
28/* For error messages */
29char* progname;
30char* cdlname;
31
32/* option flags */
33int nofill_flag;
34char* mainname; /* name to use for main function; defaults to "main"*/
35Language l_flag;
36int syntax_only;
37int header_only;
38
39/* flags for tracking what output format to use */
40int k_flag;    /* > 0  => -k was specified on command line*/
41int format_attribute; /* 1=>format came from format attribute */
42int enhanced_flag; /* 1 => netcdf-4 */
43int cdf5_flag; /* 1 => cdf5 | maybe netcdf-4 */
44int specials_flag; /* 1=> special attributes are present */
45int usingclassic;
46int cmode_modifier;
47int diskless;
48int ncloglevel;
49
50GlobalSpecialData globalspecials;
51
52char* binary_ext = ".nc";
53
54size_t nciterbuffersize;
55
56struct Vlendatavlendata;
57
58char *netcdf_name; /* command line -o file name */
59char *datasetname; /* name from the netcdf <name> {} */
60
61extern FILE *ncgin;
62
63/* Forward */
64static char* ubasename(char*);
65void usage( void );
66int main( int argc, char** argv );
67
68/* Define tables vs modes for legal -k values*/
69struct Kvalues legalkinds[NKVALUES] = {
70    /* NetCDF-3 classic format (32-bit offsets) */
71    {"classic", NC_FORMAT_CLASSIC}, /* canonical format name */
72    {"nc3", NC_FORMAT_CLASSIC},     /* short format name */
73    {"1", NC_FORMAT_CLASSIC}, /* deprecated, use "-3" or "-k nc3" instead */
74
75    /* NetCDF-3 64-bit offset format */
76    {"64-bit offset", NC_FORMAT_64BIT_OFFSET}, /* canonical format name */
77    {"nc6", NC_FORMAT_64BIT_OFFSET}, /* short format name */
78    {"2", NC_FORMAT_64BIT_OFFSET},     /* deprecated, use "-6" or "-k nc6" instead */
79    {"64-bit-offset", NC_FORMAT_64BIT_OFFSET}, /* aliases */
80
81    /* NetCDF-4 HDF5-based format */
82    {"netCDF-4", NC_FORMAT_NETCDF4}, /* canonical format name */
83    {"nc4", NC_FORMAT_NETCDF4},      /* short format name */
84    {"3", NC_FORMAT_NETCDF4},   /* deprecated, use "-4" or "-k nc4" instead */
85    {"netCDF4", NC_FORMAT_NETCDF4},  /* aliases */
86    {"hdf5", NC_FORMAT_NETCDF4},
87    {"enhanced", NC_FORMAT_NETCDF4},
88    {"netcdf-4", NC_FORMAT_NETCDF4},
89    {"netcdf4", NC_FORMAT_NETCDF4},
90
91    /* NetCDF-4 HDF5-based format, restricted to classic data model */
92    {"netCDF-4 classic model", NC_FORMAT_NETCDF4_CLASSIC}, /* canonical format name */
93    {"nc7", NC_FORMAT_NETCDF4_CLASSIC}, /* short format name */
94    {"4", NC_FORMAT_NETCDF4_CLASSIC}, /* deprecated, use "-7" or -k nc7" instead */
95    {"netCDF-4-classic", NC_FORMAT_NETCDF4_CLASSIC}, /* aliases */
96    {"netCDF-4_classic", NC_FORMAT_NETCDF4_CLASSIC},
97    {"netCDF4_classic", NC_FORMAT_NETCDF4_CLASSIC},
98    {"hdf5-nc3", NC_FORMAT_NETCDF4_CLASSIC},
99    {"enhanced-nc3", NC_FORMAT_NETCDF4_CLASSIC},
100
101    /* CDF-5 format */
102    {"5", NC_FORMAT_64BIT_DATA},
103    {"64-bit-data", NC_FORMAT_64BIT_DATA},
104    {"64-bit data", NC_FORMAT_64BIT_DATA},
105    {"nc5", NC_FORMAT_64BIT_DATA},
106    {"cdf5", NC_FORMAT_64BIT_DATA},
107    {"cdf-5", NC_FORMAT_64BIT_DATA},
108
109    /* null terminate*/
110    {NULL,0}
111};
112
113#ifndef _MSC_VER
114struct Languages {
115    char* name;
116    Language flag;
117legallanguages[] = {
118{"b", L_BINARY},
119{"c", L_C},
120{"C", L_C},
121{"f77", L_F77},
122{"fortran77", L_F77},
123{"Fortran77", L_F77},
124{"j", L_JAVA},
125{"java", L_JAVA},
126{NULL,L_UNDEFINED}
127};
128#else
129typedef struct Languages {
130 char* name;
131 Language flag;
132Languages;
133
134struct Languages legallanguages[] = {
135{"b", L_BINARY},
136{"c", L_C},
137{"C", L_C},
138{"f77", L_F77},
139{"fortran77", L_F77},
140{"Fortran77", L_F77},
141{"j", L_JAVA},
142{"java", L_JAVA},
143{NULL,L_UNDEFINED}
144};
145#endif
146
147#if 0 /*not used*/
148/* BOM Sequences */
149static char* U8   = "\xEF\xBB\xBF";    /* UTF-8 */
150static char* BE32 = "\x00\x00\xFE\xFF"; /* UTF-32; big-endian */
151static char* LE32 = "\xFF\xFE";       /* UTF-32; little-endian */
152static char* BE16 = "\xFE\xFF";       /* UTF-16; big-endian */
153static char* LE16 = "\xFF\xFE";       /* UTF-16; little-endian */
154#endif
155
156/* The default minimum iterator size depends
157   on whether we are doing binary or language
158   based output.
159*/
160#define DFALTBINNCITERBUFFERSIZE  0x40000 /* about 250k bytes */
161#define DFALTLANGNCITERBUFFERSIZE  0x4000 /* about 15k bytes */
162
163/* strip off leading path */
164/* result is malloc'd */
165
166static char *
167ubasename(char *logident)
168{
169    char* sep;
170
171    sep = strrchr(logident,'/');
172#ifdef MSDOS
173    if(sep == NULLsep = strrchr(logident,'\\');
174#endif
175    if(sep == NULL) return logident;
176    sep++; /* skip past the separator */
177    return sep;
178}
179
180void
181usage(void)
182{
183    derror("Usage: %s"
184" [-1]"
185" [-3]"
186" [-4]"
187" [-5]"
188" [-6]"
189" [-7]"
190" [-b]"
191" [-B buffersize]"
192" [-d]"
193" [-D debuglevel]"
194" [-h]"
195" [-k kind ]"
196" [-l language=b|c|f77|java]"
197" [-M <name>]"
198" [-n]"
199" [-o outfile]"
200" [-P]"
201" [-x]"
202" [file ... ]",
203    progname);
204    derror("netcdf library version %s", nc_inq_libvers());
205}
206
207int
208main(
209 int argc,
210 char *argv[])
211{
212    int c;
213    FILE *fp;
214 struct Languageslangs;
215    char* lang_name;
216#ifdef __hpux
217    setlocale(LC_CTYPE,"");
218#endif
219
220    init_netcdf();
221
222    opterr = 1; /* print error message if bad option */
223    progname = ubasename(argv[0]);
224    cdlname = "-";
225    netcdf_name = NULL;
226    datasetname = NULL;
227    l_flag = 0;
228    nofill_flag = 0;
229    syntax_only = 0;
230    header_only = 0;
231    mainname = "main";
232    nciterbuffersize = 0;
233
234    k_flag = 0;
235    format_attribute = 0;
236    enhanced_flag = 0;
237    cdf5_flag = 0;
238    specials_flag = 0;
239    diskless = 0;
240#ifdef LOGGING
241    ncloglevel = NC_TURN_OFF_LOGGING;
242#else
243    ncloglevel = -1;
244#endif
245    memset(&globalspecials,0,sizeof(GlobalSpecialData));
246
247#if _CRAYMPP && 0
248    /* initialize CRAY MPP parallel-I/O library */
249    (void) par_io_init(32, 32);
250#endif
251
252    while ((c = getopt(argcargv, "134567bB:cdD:fhHk:l:M:no:Pv:xL:")) != EOF)
253      switch(c) {
254 case 'd':
255   debug = 1;
256   break;
257 case 'D':
258   debug = atoi(optarg);
259   break;
260 case 'c': /* for c output, old version of "-lc" */
261   if(l_flag != 0) {
262     fprintf(stderr,"Please specify only one language\n");
263     return 1;
264   }
265   l_flag = L_C;
266   fprintf(stderr,"-c is deprecated: please use -lc\n");
267   break;
268 case 'f': /* for f77 output, old version of "-lf" */
269   if(l_flag != 0) {
270     fprintf(stderr,"Please specify only one language\n");
271     return 1;
272   }
273   l_flag = L_F77;
274   fprintf(stderr,"-f is deprecated: please use -lf77\n");
275   break;
276 case 'b': /* for binary netcdf output, ".nc" extension */
277   if(l_flag != 0) {
278     fprintf(stderr,"Please specify only one language\n");
279     return 1;
280   }
281   l_flag = L_BINARY;
282   break;
283 case 'h':
284   header_only = 1;
285   break;
286 case 'H':
287   usage();
288   exit(0);
289        case 'l': /* specify language, instead of using -c or -f or -b */
290 {
291     if(l_flag != 0) {
292              fprintf(stderr,"Please specify only one language\n");
293              return 1;
294     }
295            if(!optarg) {
296              derror("%s: output language is null", progname);
297              return(1);
298            }
299            lang_name = (char*) emalloc(strlen(optarg)+1);
300     (void)strcpy(lang_nameoptarg);
301     for(langs=legallanguages;langs->name != NULL;langs++) {
302              if(strcmp(lang_name,langs->name)==0) {
303    l_flag = langs->flag;
304                break;
305              }
306     }
307     if(langs->name == NULL) {
308              derror("%s: output language %s not implemented",prognamelang_name);
309              return(1);
310     }
311 }; break;
312 case 'L':
313     ncloglevel = atoi(optarg);
314     break;
315 case 'n': /* old version of -b, uses ".cdf" extension */
316   if(l_flag != 0) {
317     fprintf(stderr,"Please specify only one language\n");
318     return 1;
319   }
320   l_flag = L_BINARY;
321          binary_ext = ".cdf";
322   break;
323 case 'o': /* to explicitly specify output name */
324   netcdf_name = nulldup(optarg);
325   break;
326 case 'x': /* set nofill mode to speed up creation of large files */
327   nofill_flag = 1;
328   break;
329        case 'v': /* a deprecated alias for "kind" option */
330     /*FALLTHRU*/
331 case 'k': { /* for specifying variant of netCDF format to be generated
332      Possible values are:
333      Format names:
334        "classic" or "nc3"
335        "64-bit offset" or "nc6"
336        "64-bit data" or "nc5" or "cdf-5"
337        "netCDF-4" or "nc4"
338        "netCDF-4 classic model" or "nc7"
339        "netCDF-5" or "nc5" or "cdf5"
340      Format version numbers (deprecated):
341        1 (=> classic)
342        2 (=> 64-bit offset)
343        3 (=> netCDF-4)
344        4 (=> netCDF-4 classic model)
345                       5 (=> classic 64 bit data aka CDF-5)
346    */
347     struct Kvalueskvalue;
348     char *kind_name = (optarg != NULL
349 ? (char *) emalloc(strlen(optarg)+1)
350emalloc(1));
351     if (! kind_name) {
352 derror ("%s: out of memory", progname);
353 return(1);
354     }
355            if(optarg != NULL)
356              (void)strcpy(kind_nameoptarg);
357            for(kvalue=legalkinds;kvalue->name;kvalue++) {
358              if(strcmp(kind_name,kvalue->name) == 0) {
359                k_flag = kvalue->k_flag;
360                break;
361              }
362            }
363            if(kvalue->name == NULL) {
364                derror("Invalid format: %s",kind_name);
365                return 2;
366            }
367 } break;
368 case '3': /* output format is classic (netCDF-3) */
369     k_flag = NC_FORMAT_CLASSIC;
370     break;
371 case '6': /* output format is 64-bit-offset (netCDF-3 version 2) */
372     k_flag = NC_FORMAT_64BIT_OFFSET;
373     break;
374 case '4': /* output format is netCDF-4 (variant of HDF5) */
375     k_flag = NC_FORMAT_NETCDF4;
376     break;
377 case '5': /* output format is CDF5 */
378     k_flag = NC_FORMAT_CDF5;
379     break;
380 case '7': /* output format is netCDF-4 (restricted to classic model)*/
381     k_flag = NC_FORMAT_NETCDF4_CLASSIC;
382     break;
383 case 'M': /* Determine the name for the main function */
384     mainname = nulldup(optarg);
385     break;
386 case 'B':
387   nciterbuffersize = atoi(optarg);
388   break;
389 case 'P': /* diskless with persistence */
390   diskless = 1;
391   break;
392 case '?':
393   usage();
394   return(8);
395      }
396
397    if(l_flag == 0) {
398 l_flag = L_BINARY; /* default */
399 /* Treat -k or -o as an implicit -lb assuming no other -l flags */
400        if(k_flag == 0 && netcdf_name == NULL)
401     syntax_only = 1;
402    }
403
404    /* Compute/default the iterator buffer size */
405    if(l_flag == L_BINARY) {
406 if(nciterbuffersize == 0 )
407     nciterbuffersize = DFALTBINNCITERBUFFERSIZE;
408    } else {
409 if(nciterbuffersize == 0)
410     nciterbuffersize = DFALTLANGNCITERBUFFERSIZE;
411    }
412
413#ifndef ENABLE_C
414    if(c_flag) {
415   fprintf(stderr,"C not currently supported\n");
416   exit(1);
417    }
418#endif
419#ifndef ENABLE_BINARY
420    if(l_flag == L_BINARY) {
421   fprintf(stderr,"Binary netcdf not currently supported\n");
422   exit(1);
423    }
424#endif
425#ifndef ENABLE_JAVA
426    if(l_flag == L_JAVA) {
427   fprintf(stderr,"Java not currently supported\n");
428   exit(1);
429    }
430#else
431    if(l_flag == L_JAVA && mainname != NULL && strcmp(mainname,"main")==0)
432      mainname = "Main";
433#endif
434#ifndef ENABLE_F77
435    if(l_flag == L_F77) {
436   fprintf(stderr,"F77 not currently supported\n");
437   exit(1);
438    }
439#endif
440
441    if(l_flag != L_BINARY)
442 diskless = 0;
443
444    argc -= optind;
445    argv += optind;
446
447    if (argc > 1) {
448 derror ("%s: only one input file argument permitted",progname);
449 return(6);
450    }
451
452    fp = stdin;
453    if (argc > 0 && strcmp(argv[0], "-") != 0) {
454 char bom[4];
455 size_t count;
456 if ((fp = fopen(argv[0], "r")) == NULL) {
457     derror ("can't open file %s for reading: ", argv[0]);
458     perror("");
459     return(7);
460 }
461    /* Check the leading bytes for an occurrence of a BOM */
462        /* re: http://www.unicode.org/faq/utf_bom.html#BOM */
463 /* Attempt to read the first four bytes */
464 memset(bom,0,sizeof(bom));
465 count = fread(bom,1,2,fp);
466 if(count == 2) {
467     switch (bom[0]) {
468     case '\x00':
469     case '\xFF':
470     case '\xFE':
471         /* Only UTF-* is allowed; complain and exit */
472 fprintf(stderr,"Input file contains a BOM indicating a non-UTF8 encoding\n");
473 return 1;
474     case '\xEF':
475 /* skip the BOM */
476         (void)fread(bom,1,1,fp);
477         break;
478     default: /* legal printable char, presumably; rewind */
479         rewind(fp);
480 break;
481     }
482 }
483
484 cdlname = (char*)emalloc(NC_MAX_NAME);
485 cdlname = nulldup(argv[0]);
486 if(cdlname != NULL) {
487   if(strlen(cdlname) > NC_MAX_NAME)
488     cdlname[NC_MAX_NAME] = '\0';
489 }
490    }
491
492    parse_init();
493    ncgin = fp;
494    if(debug >= 2) {ncgdebug=1;}
495    if(ncgparse() != 0)
496        return 1;
497
498    /* Compute the k_flag (1st pass) using rules in the man page (ncgen.1).*/
499
500#ifndef USE_NETCDF4
501    if(enhanced_flag) {
502 derror("CDL input is enhanced mode, but --disable-netcdf4 was specified during build");
503 return 0;
504    }
505#endif
506
507    if(l_flag == L_JAVA || l_flag == L_F77) {
508        k_flag = 1;
509 if(enhanced_flag) {
510     derror("Java or Fortran requires classic model CDL input");
511     return 0;
512 }
513    }
514
515    if(k_flag == 0)
516      k_flag = globalspecials._Format;
517
518    if(cdf5_flag && !enhanced_flag && k_flag == 0)
519      k_flag = 5;
520    if(enhanced_flag && k_flag == 0)
521      k_flag = 3;
522
523    if(enhanced_flag && k_flag != 3) {
524      if(enhanced_flag && k_flag != 3 && k_flag != 5) {
525        derror("-k or _Format conflicts with enhanced CDL input");
526        return 0;
527      }
528    }
529
530    if(specials_flag > 0 && k_flag == 0)
531#ifdef USE_NETCDF4
532 k_flag = 3;
533#else
534 k_flag = 1;
535#endif
536
537    if(k_flag == 0)
538 k_flag = 1;
539
540    /* Figure out usingclassic */
541    switch (k_flag) {
542    case NC_FORMAT_64BIT_DATA:
543    case NC_FORMAT_CLASSIC:
544    case NC_FORMAT_64BIT_OFFSET:
545    case NC_FORMAT_NETCDF4_CLASSIC:
546 usingclassic = 1;
547 break;
548    case NC_FORMAT_NETCDF4:
549    default:
550 usingclassic = 0;
551 break;
552    }
553
554    /* compute cmode_modifier */
555    switch (k_flag) {
556    case NC_FORMAT_CLASSIC:
557 cmode_modifier = 0; break;
558    case NC_FORMAT_64BIT_OFFSET:
559 cmode_modifier = NC_64BIT_OFFSET; break;
560    case NC_FORMAT_NETCDF4:
561 cmode_modifier = NC_NETCDF4; break;
562    case NC_FORMAT_NETCDF4_CLASSIC:
563 cmode_modifier = NC_NETCDF4 | NC_CLASSIC_MODEL; break;
564    case NC_FORMAT_64BIT_DATA:
565 cmode_modifier = NC_CDF5; break;
566    default: ASSERT(0); /* cannot happen */
567    }
568
569    if(diskless)
570 cmode_modifier |= (NC_DISKLESS|NC_NOCLOBBER);
571
572    processsemantics();
573    if(!syntax_only && error_count == 0)
574        define_netcdf();
575
576    return 0;
577}
578END_OF_MAIN()
579
580void
581init_netcdf(void) /* initialize global counts, flags */
582{
583    compute_alignments();
584    memset((void*)&nullconstant,0,sizeof(NCConstant));
585    fillconstant = nullconstant;
586    fillconstant.nctype = NC_FILLVALUE;
587
588    codebuffer = bbNew();
589    stmt = bbNew();
590    error_count = 0; /* Track # of errors */
591}


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed