ncdf4a13/ncgen/genlib.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
#include <netcdf.h>
#include "generic.h"
#include "ncgen.h"
#include "genlib.h"

Include dependency graph for genlib.c:

Go to the source code of this file.

Functions
static void	gen_netcdf (char *filename)
static char *	cstring (nc_type type, void *valp, int num)
static void	gen_c (const char *filename)
static const char *	ncftype (nc_type type)
const char *	nfstype (nc_type type)
const char *	nfftype (nc_type type)
static const char *	ftypename (nc_type type)
static void	gen_fortran (const char *filename)
void	cline (const char *stmnt)
void	fline (const char *stmnt)
const char *	nctype (nc_type type)
const char *	ncctype (nc_type type)
const char *	ncstype (nc_type type)
const char *	ncatype (nc_type type)
size_t	nctypesize (nc_type type)
char *	fstring (nc_type type, void *valp, int num)
char *	cstrstr (const char *valp, size_t len)
char *	fstrstr (const char *str, size_t ilen)
static void	cl_netcdf (void)
static void	cl_c (void)
static int	used_in_rec_var (int idim)
static const char *	f_fill_name (nc_type type)
static void	cl_fortran (void)
void	define_netcdf (const char *netcdfname)
void	close_netcdf (void)
void	check_err (int stat)
void	derror (const char *fmt,...)
void *	emalloc (size_t size)
void *	ecalloc (size_t size)
void *	erealloc (void *ptr, size_t size)
void	expe2d (char *cp)
static int	pow2 (int n)
void	grow_iarray (int nar, int **arpp)
void	grow_varray (int nar, struct vars **arpp)
void	grow_darray (int nar, struct dims **arpp)
void	grow_aarray (int nar, struct atts **arpp)
char *	decodify (const char *name)
Variables
char *	netcdf_name
int	netcdf_flag
int	c_flag
int	fortran_flag
int	cmode_modifier
int	nofill_flag
int	lineno = 1
int	derror_count = 0

---

Function Documentation

void check_err (  int  stat  )

Definition at line 1612 of file genlib.c. References derror_count, NC_NOERR, and nc_strerror. { if (stat != NC_NOERR) { fprintf(stderr, "ncgen: %s\n", nc_strerror(stat)); derror_count++; } }

static void cl_c (  void   )  [static]

Definition at line 1264 of file genlib.c. References cline(). Referenced by close_netcdf(). { cline(" stat = nc_close(ncid);"); cline(" check_err(stat,__LINE__,__FILE__);"); #ifndef vms cline(" return 0;"); #else cline(" return 1;"); #endif cline("}"); }

static void cl_fortran (  void   )  [static]

Definition at line 1325 of file genlib.c. References vars::data_stmnt, vars::dims, f_fill_name(), fline(), FORT_MAX_STMNT, vars::has_data, vars::lname, vars::name, NC_CHAR, NC_UNLIMITED, ncftype(), ndims, vars::ndims, nfftype(), vars::nrecs, nvars, rec_dim, rec_len, size, vars::type, and used_in_rec_var(). Referenced by close_netcdf(). { int ivar; int idim; char stmnt[FORT_MAX_STMNT]; char s2[FORT_MAX_STMNT]; char*sp; int have_rec_var = 0; /* do we have any record variables? */ for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim) { have_rec_var = 1; break; } } if (have_rec_var) { fline(" "); fline("* Write record variables"); sprintf(stmnt, "call writerecs(ncid,"); /* generate parameter list for subroutine to write record vars */ for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; /* if a record variable, include id in parameter list */ if (v->ndims > 0 && v->dims[0] == rec_dim) { sprintf(s2, "%s_id,", v->lname); strcat(stmnt, s2); } } sp = strrchr(stmnt, ','); if(sp != NULL) { *sp = '\0'; } strcat(stmnt, ")"); fline(stmnt); } fline(" "); fline("iret = nf_close(ncid)"); fline("call check_err(iret)"); fline("end"); fline(" "); if (have_rec_var) { sprintf(stmnt, "subroutine writerecs(ncid,"); for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim) { sprintf(s2, "%s_id,", v->lname); strcat(stmnt, s2); } } sp = strrchr(stmnt, ','); if(sp != NULL) { *sp = '\0'; } strcat(stmnt, ")"); fline(stmnt); fline(" "); fline("* netCDF id"); fline("integer ncid"); fline("* variable ids"); for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim) { sprintf(stmnt, "integer %s_id", v->lname); fline(stmnt); } } fline(" "); fline("include 'netcdf.inc'"); /* create necessary declarations */ fline("* error status return"); fline("integer iret"); /* generate integer/parameter declarations for all dimensions used in record variables, except record dimension. */ fline(" "); fline("* netCDF dimension sizes for dimensions used with record variables"); for (idim = 0; idim < ndims; idim++) { /* if used in a record variable and not record dimension */ if (used_in_rec_var(idim) && dims[idim].size != NC_UNLIMITED) { sprintf(stmnt, "integer %s_len", dims[idim].lname); fline(stmnt); sprintf(stmnt, "parameter (%s_len = %lu)", dims[idim].lname, (unsigned long) dims[idim].size); fline(stmnt); } } fline(" "); fline("* rank (number of dimensions) for each variable"); for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim) { sprintf(stmnt, "integer %s_rank", v->lname); fline(stmnt); } } for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim) { sprintf(stmnt, "parameter (%s_rank = %d)", v->lname, v->ndims); fline(stmnt); } } fline("* starts and counts for array sections of record variables"); for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim) { sprintf(stmnt, "integer %s_start(%s_rank), %s_count(%s_rank)", v->lname, v->lname, v->lname, v->lname); fline(stmnt); } } fline(" "); fline("* data variables"); for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim) { char *sp; fline(" "); sprintf(stmnt, "integer %s_nr", v->lname); fline(stmnt); if (v->nrecs > 0) { sprintf(stmnt, "parameter (%s_nr = %lu)", v->lname, (unsigned long) v->nrecs); } else { sprintf(stmnt, "parameter (%s_nr = 1)", v->lname); } fline(stmnt); if (v->type != NC_CHAR) { sprintf(stmnt, "%s %s(", ncftype(v->type), v->lname); /* reverse dimensions for FORTRAN */ for (idim = v->ndims-1; idim >= 0; idim--) { if(v->dims[idim] == rec_dim) { sprintf(s2, "%s_nr, ", v->lname); } else { sprintf(s2, "%s_len, ", dims[v->dims[idim]].lname); } strcat(stmnt, s2); } sp = strrchr(stmnt, ','); if(sp != NULL) { *sp = '\0'; } strcat(stmnt, ")"); fline(stmnt); } } } fline(" "); /* Emit DATA statements after declarations, because f2c on Linux can't handle interspersing them */ for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; if (v->ndims > 0 && v->dims[0] == rec_dim && v->type != NC_CHAR) { if (v->has_data) { fline(v->data_stmnt); } else { /* generate data statement for FILL record */ size_t rec_len = 1; for (idim = 1; idim < v->ndims; idim++) { rec_len *= dims[v->dims[idim]].size; } sprintf(stmnt,"data %s /%lu * %s/", v->lname, (unsigned long) rec_len, f_fill_name(v->type)); fline(stmnt); } } } fline(" "); for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; /* if a record variable, declare starts and counts */ if (v->ndims > 0 && v->dims[0] == rec_dim) { if (!v->has_data) continue; sprintf(stmnt, "* store %s", v->name); fline(stmnt); for (idim = 0; idim < v->ndims; idim++) { sprintf(stmnt, "%s_start(%d) = 1", v->lname, idim+1); fline(stmnt); } for (idim = v->ndims-1; idim > 0; idim--) { sprintf(stmnt, "%s_count(%d) = %s_len", v->lname, v->ndims - idim, dims[v->dims[idim]].lname); fline(stmnt); } sprintf(stmnt, "%s_count(%d) = %s_nr", v->lname, v->ndims, v->lname); fline(stmnt); if (v->type != NC_CHAR) { sprintf(stmnt, "iret = nf_put_vara_%s(ncid, %s_id, %s_start, %s_count, %s)", nfftype(v->type), v->lname, v->lname, v->lname, v->lname); } else { sprintf(stmnt, "iret = nf_put_vara_%s(ncid, %s_id, %s_start, %s_count, %s)", nfftype(v->type), v->lname, v->lname, v->lname, v->data_stmnt); } fline(stmnt); fline("call check_err(iret)"); } } fline(" "); fline("end"); fline(" "); } fline("subroutine check_err(iret)"); fline("integer iret"); fline("include 'netcdf.inc'"); fline("if (iret .ne. NF_NOERR) then"); fline("print *, nf_strerror(iret)"); fline("stop"); fline("endif"); fline("end"); }

static void cl_netcdf (  void   )  [static]

Definition at line 1256 of file genlib.c. References check_err(), nc_close, and ncid. Referenced by close_netcdf(). { int stat = nc_close(ncid); check_err(stat); }

void cline (  const char *  stmnt  )

Definition at line 851 of file genlib.c. References FILE. Referenced by cl_c(), gen_c(), and gen_load_c(). { FILE *cout = stdout; fputs(stmnt, cout); fputs("\n", cout); }

void close_netcdf (  void   )

Definition at line 1600 of file genlib.c. References c_flag, cl_c(), cl_fortran(), cl_netcdf(), fortran_flag, and netcdf_flag. Referenced by yyparse(). { if (netcdf_flag) cl_netcdf(); /* close netcdf */ if (c_flag) /* create C code to close netcdf */ cl_c(); if (fortran_flag) /* create Fortran code to close netcdf */ cl_fortran(); }

static char* cstring (  nc_type  type, void *  valp, int  num )  [static]

Definition at line 119 of file genlib.c. References derror(), emalloc(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by gen_c(). { static char *cp, *sp, ch; signed char *bytep; short *shortp; int *intp; float *floatp; double *doublep; switch (type) { case NC_CHAR: sp = cp = (char *) emalloc (7); *cp++ = '\''; ch = *((char *)valp + num); switch (ch) { case '\b': *cp++ = '\\'; *cp++ = 'b'; break; case '\f': *cp++ = '\\'; *cp++ = 'f'; break; case '\n': *cp++ = '\\'; *cp++ = 'n'; break; case '\r': *cp++ = '\\'; *cp++ = 'r'; break; case '\t': *cp++ = '\\'; *cp++ = 't'; break; case '\v': *cp++ = '\\'; *cp++ = 'v'; break; case '\\': *cp++ = '\\'; *cp++ = '\\'; break; case '\'': *cp++ = '\\'; *cp++ = '\''; break; default: if (!isprint((unsigned char)ch)) { static char octs[] = "01234567"; int rem = ((unsigned char)ch)%64; *cp++ = '\\'; *cp++ = octs[((unsigned char)ch)/64]; /* to get, e.g. '\177' */ *cp++ = octs[rem/8]; *cp++ = octs[rem%8]; } else { *cp++ = ch; } break; } *cp++ = '\''; *cp = '\0'; return sp; case NC_BYTE: cp = (char *) emalloc (7); bytep = (signed char *)valp; /* Need to convert '\377' to -1, for example, on all platforms */ (void) sprintf(cp,"%d", (signed char) *(bytep+num)); return cp; case NC_SHORT: cp = (char *) emalloc (10); shortp = (short *)valp; (void) sprintf(cp,"%d",* (shortp + num)); return cp; case NC_INT: cp = (char *) emalloc (20); intp = (int *)valp; (void) sprintf(cp,"%d",* (intp + num)); return cp; case NC_FLOAT: cp = (char *) emalloc (20); floatp = (float *)valp; (void) sprintf(cp,"%.8g",* (floatp + num)); return cp; case NC_DOUBLE: cp = (char *) emalloc (20); doublep = (double *)valp; (void) sprintf(cp,"%.16g",* (doublep + num)); return cp; default: derror("cstring: bad type code"); return 0; } }

char* cstrstr (  const char *  valp, size_t  len )

Definition at line 1092 of file genlib.c. References derror(), and emalloc(). Referenced by gen_c(), and gen_load_c(). { static char *sp; char *cp; char *istr, *istr0; /* for null-terminated copy */ int ii; if(4*len+3 != (unsigned)(4*len+3)) { derror("too much character data!"); exit(9); } sp = cp = (char *) emalloc(4*len+3); if(len == 1 && *valp == 0) { /* empty string */ strcpy(sp,"\"\""); return sp; } istr0 = istr = (char *) emalloc(len + 1); for(ii = 0; ii < len; ii++) { istr[ii] = valp[ii]; } istr[len] = '\0'; *cp++ = '"'; for(ii = 0; ii < len; ii++) { switch (*istr) { case '\0': *cp++ = '\\'; *cp++ = '0'; *cp++ = '0'; *cp++ = '0'; break; case '\b': *cp++ = '\\'; *cp++ = 'b'; break; case '\f': *cp++ = '\\'; *cp++ = 'f'; break; case '\n': *cp++ = '\\'; *cp++ = 'n'; break; case '\r': *cp++ = '\\'; *cp++ = 'r'; break; case '\t': *cp++ = '\\'; *cp++ = 't'; break; case '\v': *cp++ = '\\'; *cp++ = 'v'; break; case '\\': *cp++ = '\\'; *cp++ = '\\'; break; case '\"': *cp++ = '\\'; *cp++ = '\"'; break; default: if (!isprint((unsigned char)*istr)) { static char octs[] = "01234567"; int rem = ((unsigned char)*istr)%64; *cp++ = '\\'; *cp++ = octs[((unsigned char)*istr)/64]; /* to get, e.g. '\177' */ *cp++ = octs[rem/8]; *cp++ = octs[rem%8]; } else { *cp++ = *istr; } break; } istr++; } *cp++ = '"'; *cp = '\0'; free(istr0); return sp; }

char* decodify (  const char *  name  )

Definition at line 1846 of file genlib.c. References ecalloc(). Referenced by yyparse(). { int count=0; /* number of minus signs in name */ char *newname; const char *cp = name; char *sp; while(*cp != '\0') { switch (*cp) { case '-': count += strlen("_dash_") - 1; break; case '.': count += strlen("_dot_") - 1; break; case '@': count += strlen("_at_") - 1; break; case '#': count += strlen("_hash_") - 1; break; case '[': count += strlen("_lbr_") - 1; break; case ']': count += strlen("_rbr_") - 1; break; default: break; } cp++; } newname = (char *) ecalloc(strlen(name) + count + 1); cp = name; sp = newname; while(*cp != '\0') { switch (*cp) { case '-': strcat(sp, "_dash_"); sp += strlen("_dash_"); break; case '.': strcat(sp, "_dot_"); sp += strlen("_dot_"); break; case '@': strcat(sp, "_at_"); sp += strlen("_at_"); break; case '#': strcat(sp, "_hash_"); sp += strlen("_hash_"); break; case '[': strcat(sp, "_lbr_"); sp += strlen("_lbr_"); break; case ']': strcat(sp, "_rbr_"); sp += strlen("_rbr_"); break; default: *sp++ = *cp; break; } cp++; } *sp = '\0'; return newname; }

void define_netcdf (  const char *  netcdfname  )

Definition at line 1574 of file genlib.c. References c_flag, emalloc(), fortran_flag, gen_c(), gen_fortran(), gen_netcdf(), netcdf_flag, and netcdf_name. Referenced by yyparse(). { char *filename; /* output file name */ if (netcdf_name) { /* name given on command line */ filename = netcdf_name; } else { /* construct name from CDL name */ filename = (char *) emalloc(strlen(netcdfname) + 5); (void) strcpy(filename,netcdfname); if (netcdf_flag == -1) (void) strcat(filename,".cdf"); /* old, deprecated extension */ else (void) strcat(filename,".nc"); /* new, favored extension */ } if (netcdf_flag) gen_netcdf(filename); /* create netcdf */ if (c_flag) /* create C code to create netcdf */ gen_c(filename); if (fortran_flag) /* create Fortran code to create netcdf */ gen_fortran(filename); free(filename); }

void derror (  const char *  fmt,   ... )

Definition at line 1624 of file genlib.c. References cdlname, derror_count, lineno, and progname. Referenced by cstring(), cstrstr(), ecalloc(), emalloc(), erealloc(), f_fill_name(), f_var_init(), fline(), fstrcat(), fstring(), fstrstr(), ftypename(), gen_c(), gen_fortran(), main(), nc_getfill(), nc_putfill(), ncatype(), ncctype(), ncftype(), ncstype(), nctype(), nctypesize(), nfftype(), nfstype(), usage(), yyerror(), and yyparse(). { va_list args ; if (lineno == 1) (void) fprintf(stderr,"%s: %s: ", progname, cdlname); else (void) fprintf(stderr,"%s: %s line %d: ", progname, cdlname, lineno); #ifndef NO_STDARG va_start(args ,fmt) ; #else va_start(args) ; #endif /* !NO_STDARG */ (void) vfprintf(stderr,fmt,args) ; va_end(args) ; (void) fputc('\n',stderr) ; (void) fflush(stderr); /* to ensure log files are current */ derror_count++; }

void* ecalloc (  size_t  size  )

Definition at line 1671 of file genlib.c. References derror(). Referenced by decodify(). { void *p; p = (void *) calloc (size, 1); if (p == 0) { derror ("out of memory\n"); exit(3); } return p; }

void* emalloc (  size_t  size  )

Definition at line 1657 of file genlib.c. References derror(). { void *p; p = (void *) malloc (size); if (p == 0) { derror ("out of memory\n"); exit(3); } return p; }

void* erealloc (  void *  ptr, size_t  size )

Definition at line 1685 of file genlib.c. Referenced by grow_aarray(), grow_darray(), grow_iarray(), grow_varray(), test_ncdimrename(), and yyparse(). { void *p; p = (void *) realloc (ptr, size); if (p == 0 && size != 0) { derror ("out of memory"); exit(3); } return p; }

void expe2d (  char *  cp  )

Definition at line 1706 of file genlib.c. Referenced by f_var_init(), and fstring(). { char *expchar = strrchr(cp,'e'); if (expchar) { *expchar = 'd'; } }

static const char* f_fill_name (  nc_type  type  )  [static]

Definition at line 1300 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by cl_fortran(). { switch(type) { case NC_BYTE: return "NF_FILL_BYTE"; case NC_CHAR: return "NF_FILL_CHAR"; case NC_SHORT: return "NF_FILL_SHORT"; case NC_INT: return "NF_FILL_INT"; case NC_FLOAT: return "NF_FILL_FLOAT"; case NC_DOUBLE: return "NF_FILL_DOUBLE"; } derror("f_fill_name: bad type code"); return 0; }

void fline (  const char *  stmnt  )

Definition at line 867 of file genlib.c. References derror(), FILE, FORT_MAX_LINES, and len. Referenced by cl_fortran(), f_var_init(), fstrcat(), gen_fortran(), and gen_load_fortran(). { FILE *fout = stdout; int len = (int) strlen(stmnt); int line = 0; static char cont[] = { /* continuation characters */ ' ', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '1', '2', '3', '4', '5', '6', '7', '8', '9'}; if(stmnt[0] == '*') { fputs(stmnt, fout); fputs("\n", fout); return; } while (len > 0) { if (line >= FORT_MAX_LINES) derror("FORTRAN statement too long: %s",stmnt); (void) fprintf(fout, " %c", cont[line++]); (void) fprintf(fout, "%.66s\n", stmnt); len -= 66; if (len > 0) stmnt += 66; } }

char* fstring (  nc_type  type, void *  valp, int  num )

Definition at line 1036 of file genlib.c. References derror(), emalloc(), expe2d(), NC_BYTE, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by f_var_init(), and gen_fortran(). { static char *cp; signed char *schp; short *shortp; int *intp; float *floatp; double *doublep; switch (type) { case NC_BYTE: cp = (char *) emalloc (10); schp = (signed char *)valp; sprintf(cp,"%d", schp[num]); return cp; case NC_SHORT: cp = (char *) emalloc (10); shortp = (short *)valp; (void) sprintf(cp,"%d",* (shortp + num)); return cp; case NC_INT: cp = (char *) emalloc (20); intp = (int *)valp; (void) sprintf(cp,"%d",* (intp + num)); return cp; case NC_FLOAT: cp = (char *) emalloc (20); floatp = (float *)valp; (void) sprintf(cp,"%.8g",* (floatp + num)); return cp; case NC_DOUBLE: cp = (char *) emalloc (25); doublep = (double *)valp; (void) sprintf(cp,"%.16g",* (doublep + num)); expe2d(cp); /* change 'e' to 'd' in exponent */ return cp; default: derror("fstring: bad type code"); return 0; } }

char* fstrstr (  const char *  str, size_t  ilen )

Definition at line 1161 of file genlib.c. References derror(), and emalloc(). Referenced by gen_fortran(), and gen_load_fortran(). { static char *ostr; char *cp, tstr[12]; int was_print = 0; /* true if last character was printable */ char *istr, *istr0; /* for null-terminated copy */ int ii; if(12*ilen != (size_t)(12*ilen)) { derror("too much character data!"); exit(9); } istr0 = istr = (char *) emalloc(ilen + 1); for(ii = 0; ii < ilen; ii++) { istr[ii] = str[ii]; } istr[ilen] = '\0'; if (*istr == '\0') { /* empty string input, not legal in FORTRAN */ ostr = (char*) emalloc(strlen("char(0)") + 1); strcpy(ostr, "char(0)"); free(istr0); return ostr; } ostr = cp = (char *) emalloc(12*ilen); *ostr = '\0'; if (isprint((unsigned char)*istr)) { /* handle first character in input */ *cp++ = '\''; switch (*istr) { case '\'': *cp++ = '\''; *cp++ = '\''; break; case '\\': *cp++ = '\\'; *cp++ = '\\'; break; default: *cp++ = *istr; break; } *cp = '\0'; was_print = 1; } else { sprintf(tstr, "char(%d)", (unsigned char)*istr); strcat(cp, tstr); cp += strlen(tstr); was_print = 0; } istr++; for(ii = 1; ii < ilen; ii++) { /* handle subsequent characters in input */ if (isprint((unsigned char)*istr)) { if (! was_print) { strcat(cp, "//'"); cp += 3; } switch (*istr) { case '\'': *cp++ = '\''; *cp++ = '\''; break; case '\\': *cp++ = '\\'; *cp++ = '\\'; break; default: *cp++ = *istr; break; } *cp = '\0'; was_print = 1; } else { if (was_print) { *cp++ = '\''; *cp = '\0'; } sprintf(tstr, "//char(%d)", (unsigned char)*istr); strcat(cp, tstr); cp += strlen(tstr); was_print = 0; } istr++; } if (was_print) *cp++ = '\''; *cp = '\0'; free(istr0); return ostr; }

static const char* ftypename (  nc_type  type  )  [static]

Definition at line 545 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by gen_fortran(). { switch (type) { case NC_BYTE: return "NF_INT1"; case NC_CHAR: return "NF_CHAR"; case NC_SHORT: return "NF_INT2"; case NC_INT: return "NF_INT"; case NC_FLOAT: return "NF_REAL"; case NC_DOUBLE: return "NF_DOUBLE"; default: derror("ftypename: bad type code"); return 0; } }

static void gen_c (  const char *  filename  )  [static]

Definition at line 204 of file genlib.c. References C_MAX_STMNT, cline(), cmode_modifier, cstring(), cstrstr(), derror(), len, natts, NC_64BIT_OFFSET, NC_CHAR, NC_CLASSIC_MODEL, NC_NETCDF4, NC_UNLIMITED, ncatype(), nctype(), ndims, nofill_flag, nvars, size, and type. Referenced by define_netcdf(). { int idim, ivar, iatt, jatt, maxdims; int vector_atts; char *val_string; char stmnt[C_MAX_STMNT]; /* wrap in main program */ cline("#include <stdio.h>"); cline("#include <stdlib.h>"); cline("#include <netcdf.h>"); cline(""); cline("void"); cline("check_err(const int stat, const int line, const char *file) {"); cline(" if (stat != NC_NOERR) {"); cline(" (void) fprintf(stderr, \"line %d of %s: %s\\n\", line, file, nc_strerror(stat));"); cline(" exit(1);"); cline(" }"); cline("}"); cline(""); cline("int"); sprintf(stmnt, "main() {\t\t\t/* create %s */", filename); cline(stmnt); /* create necessary declarations */ cline(""); cline(" int stat;\t\t\t/* return status */"); cline(" int ncid;\t\t\t/* netCDF id */"); if (ndims > 0) { cline(""); cline(" /* dimension ids */"); for (idim = 0; idim < ndims; idim++) { sprintf(stmnt, " int %s_dim;", dims[idim].lname); cline(stmnt); } cline(""); cline(" /* dimension lengths */"); for (idim = 0; idim < ndims; idim++) { if (dims[idim].size == NC_UNLIMITED) { sprintf(stmnt, " size_t %s_len = NC_UNLIMITED;", dims[idim].lname); } else { sprintf(stmnt, " size_t %s_len = %lu;", dims[idim].lname, (unsigned long) dims[idim].size); } cline(stmnt); } } maxdims = 0; /* most dimensions of any variable */ for (ivar = 0; ivar < nvars; ivar++) if (vars[ivar].ndims > maxdims) maxdims = vars[ivar].ndims; if (nvars > 0) { cline(""); cline(" /* variable ids */"); for (ivar = 0; ivar < nvars; ivar++) { sprintf(stmnt, " int %s_id;", vars[ivar].lname); cline(stmnt); } cline(""); cline(" /* rank (number of dimensions) for each variable */"); for (ivar = 0; ivar < nvars; ivar++) { sprintf(stmnt, "# define RANK_%s %d", vars[ivar].lname, vars[ivar].ndims); cline(stmnt); } if (maxdims > 0) { /* we have dimensioned variables */ cline(""); cline(" /* variable shapes */"); for (ivar = 0; ivar < nvars; ivar++) { if (vars[ivar].ndims > 0) { sprintf(stmnt, " int %s_dims[RANK_%s];", vars[ivar].lname, vars[ivar].lname); cline(stmnt); } } } } /* determine if we need any attribute vectors */ vector_atts = 0; for (iatt = 0; iatt < natts; iatt++) { if (atts[iatt].type != NC_CHAR) { vector_atts = 1; break; } } if (vector_atts) { cline(""); cline(" /* attribute vectors */"); for (iatt = 0; iatt < natts; iatt++) { if (atts[iatt].type != NC_CHAR) { sprintf(stmnt, " %s %s_%s[%lu];", ncatype(atts[iatt].type), atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname, atts[iatt].lname, (unsigned long) atts[iatt].len); cline(stmnt); } } } /* create netCDF file, uses NC_CLOBBER mode */ cline(""); cline(" /* enter define mode */"); if (!cmode_modifier) { sprintf(stmnt, " stat = nc_create(\"%s\", NC_CLOBBER, &ncid);", filename); } else if (cmode_modifier & NC_64BIT_OFFSET) { sprintf(stmnt, " stat = nc_create(\"%s\", NC_CLOBBER|NC_64BIT_OFFSET, &ncid);", filename); #ifdef USE_NETCDF4 } else if (cmode_modifier & NC_CLASSIC_MODEL) { sprintf(stmnt, " stat = nc_create(\"%s\", NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL, &ncid);", filename); } else if (cmode_modifier & NC_NETCDF4) { sprintf(stmnt, " stat = nc_create(\"%s\", NC_CLOBBER|NC_NETCDF4, &ncid);", filename); #endif } else { derror("unknown cmode modifier"); } cline(stmnt); cline(" check_err(stat,__LINE__,__FILE__);"); /* define dimensions from info in dims array */ if (ndims > 0) { cline(""); cline(" /* define dimensions */"); } for (idim = 0; idim < ndims; idim++) { sprintf(stmnt, " stat = nc_def_dim(ncid, \"%s\", %s_len, &%s_dim);", dims[idim].name, dims[idim].lname, dims[idim].lname); cline(stmnt); cline(" check_err(stat,__LINE__,__FILE__);"); } /* define variables from info in vars array */ if (nvars > 0) { cline(""); cline(" /* define variables */"); for (ivar = 0; ivar < nvars; ivar++) { cline(""); for (idim = 0; idim < vars[ivar].ndims; idim++) { sprintf(stmnt, " %s_dims[%d] = %s_dim;", vars[ivar].lname, idim, dims[vars[ivar].dims[idim]].lname); cline(stmnt); } if (vars[ivar].ndims > 0) { /* a dimensioned variable */ sprintf(stmnt, " stat = nc_def_var(ncid, \"%s\", %s, RANK_%s, %s_dims, &%s_id);", vars[ivar].name, nctype(vars[ivar].type), vars[ivar].lname, vars[ivar].lname, vars[ivar].lname); } else { /* a scalar */ sprintf(stmnt, " stat = nc_def_var(ncid, \"%s\", %s, RANK_%s, 0, &%s_id);", vars[ivar].name, nctype(vars[ivar].type), vars[ivar].lname, vars[ivar].lname); } cline(stmnt); cline(" check_err(stat,__LINE__,__FILE__);"); } } /* define attributes from info in atts array */ if (natts > 0) { cline(""); cline(" /* assign attributes */"); for (iatt = 0; iatt < natts; iatt++) { if (atts[iatt].type == NC_CHAR) { /* string */ val_string = cstrstr((char *) atts[iatt].val, atts[iatt].len); sprintf(stmnt, " stat = nc_put_att_text(ncid, %s%s, \"%s\", %lu, %s);", atts[iatt].var == -1 ? "NC_GLOBAL" : vars[atts[iatt].var].lname, atts[iatt].var == -1 ? "" : "_id", atts[iatt].name, (unsigned long) atts[iatt].len, val_string); cline(stmnt); free (val_string); } else { /* vector attribute */ for (jatt = 0; jatt < atts[iatt].len ; jatt++) { val_string = cstring(atts[iatt].type,atts[iatt].val,jatt); sprintf(stmnt, " %s_%s[%d] = %s;", atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname, atts[iatt].lname, jatt, val_string); cline(stmnt); free (val_string); } sprintf(stmnt, " stat = nc_put_att_%s(ncid, %s%s, \"%s\", %s, %lu, %s_%s);", ncatype(atts[iatt].type), atts[iatt].var == -1 ? "NC_GLOBAL" : vars[atts[iatt].var].lname, atts[iatt].var == -1 ? "" : "_id", atts[iatt].name, nctype(atts[iatt].type), (unsigned long) atts[iatt].len, atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname, atts[iatt].lname); cline(stmnt); } cline(" check_err(stat,__LINE__,__FILE__);"); } } if (nofill_flag) { cline(" /* don't initialize variables with fill values */"); cline(" stat = nc_set_fill(ncid, NC_NOFILL, 0);"); cline(" check_err(stat,__LINE__,__FILE__);"); } cline(""); cline(" /* leave define mode */"); cline(" stat = nc_enddef (ncid);"); cline(" check_err(stat,__LINE__,__FILE__);"); }

static void gen_fortran (  const char *  filename  )  [static]

Definition at line 572 of file genlib.c. References cmode_modifier, derror(), vars::dims, fline(), FORT_MAX_STMNT, fstring(), fstrstr(), ftypename(), len, vars::lname, vars::name, natts, NC_64BIT_OFFSET, NC_BYTE, NC_CHAR, NC_CLASSIC_MODEL, NC_DOUBLE, NC_FLOAT, NC_INT, NC_MAX_NAME, NC_NETCDF4, NC_SHORT, NC_UNLIMITED, ncftype(), vars::ndims, ndims, nfftype(), nfstype(), nofill_flag, nvars, rec_dim, size, type, and vars::type. Referenced by define_netcdf(). { int idim, ivar, iatt, jatt, itype, maxdims; int vector_atts; char *val_string; char stmnt[FORT_MAX_STMNT]; char s2[NC_MAX_NAME + 10]; char *sp; /* Need how many netCDF types there are, because we create an array * for each type of attribute. */ int ntypes = 6; /* number of netCDF types, NC_BYTE, ... */ nc_type types[6]; /* at least ntypes */ size_t max_atts[NC_DOUBLE + 1]; types[0] = NC_BYTE; types[1] = NC_CHAR; types[2] = NC_SHORT; types[3] = NC_INT; types[4] = NC_FLOAT; types[5] = NC_DOUBLE; fline("program fgennc"); fline("include 'netcdf.inc'"); /* create necessary declarations */ fline("* error status return"); fline("integer iret"); fline("* netCDF id"); fline("integer ncid"); if (nofill_flag) { fline("* to save old fill mode before changing it temporarily"); fline("integer oldmode"); } if (ndims > 0) { fline("* dimension ids"); for (idim = 0; idim < ndims; idim++) { sprintf(stmnt, "integer %s_dim", dims[idim].lname); fline(stmnt); } fline("* dimension lengths"); for (idim = 0; idim < ndims; idim++) { sprintf(stmnt, "integer %s_len", dims[idim].lname); fline(stmnt); } for (idim = 0; idim < ndims; idim++) { if (dims[idim].size == NC_UNLIMITED) { sprintf(stmnt, "parameter (%s_len = NF_UNLIMITED)", dims[idim].lname); } else { sprintf(stmnt, "parameter (%s_len = %lu)", dims[idim].lname, (unsigned long) dims[idim].size); } fline(stmnt); } } maxdims = 0; /* most dimensions of any variable */ for (ivar = 0; ivar < nvars; ivar++) if (vars[ivar].ndims > maxdims) maxdims = vars[ivar].ndims; if (nvars > 0) { fline("* variable ids"); for (ivar = 0; ivar < nvars; ivar++) { sprintf(stmnt, "integer %s_id", vars[ivar].lname); fline(stmnt); } fline("* rank (number of dimensions) for each variable"); for (ivar = 0; ivar < nvars; ivar++) { sprintf(stmnt, "integer %s_rank", vars[ivar].lname); fline(stmnt); } for (ivar = 0; ivar < nvars; ivar++) { sprintf(stmnt, "parameter (%s_rank = %d)", vars[ivar].lname, vars[ivar].ndims); fline(stmnt); } fline("* variable shapes"); for (ivar = 0; ivar < nvars; ivar++) { if (vars[ivar].ndims > 0) { sprintf(stmnt, "integer %s_dims(%s_rank)", vars[ivar].lname, vars[ivar].lname); fline(stmnt); } } } /* declarations for variables to be initialized */ if (nvars > 0) { /* we have variables */ fline("* data variables"); for (ivar = 0; ivar < nvars; ivar++) { struct vars *v = &vars[ivar]; /* Generate declarations here for non-record data variables only. Record variables are declared in separate subroutine later, when we know how big they are. */ if (v->ndims > 0 && v->dims[0] == rec_dim) { continue; } /* Make declarations for non-text variables only; for text variables, just include string in nf_put_var call */ if (v->type == NC_CHAR) { continue; } if (v->ndims == 0) { /* scalar */ sprintf(stmnt, "%s %s", ncftype(v->type), v->lname); } else { sprintf(stmnt, "%s %s(", ncftype(v->type), v->lname); /* reverse dimensions for FORTRAN */ for (idim = v->ndims-1; idim >= 0; idim--) { sprintf(s2, "%s_len, ", dims[v->dims[idim]].lname); strcat(stmnt, s2); } sp = strrchr(stmnt, ','); if(sp != NULL) { *sp = '\0'; } strcat(stmnt, ")"); } fline(stmnt); } } /* determine what attribute vectors needed */ for (itype = 0; itype < ntypes; itype++) max_atts[(int)types[itype]] = 0; vector_atts = 0; for (iatt = 0; iatt < natts; iatt++) { if (atts[iatt].len > max_atts[(int) atts[iatt].type]) { max_atts[(int)atts[iatt].type] = atts[iatt].len; vector_atts = 1; } } if (vector_atts) { fline("* attribute vectors"); for (itype = 0; itype < ntypes; itype++) { if (types[itype] != NC_CHAR && max_atts[(int)types[itype]] > 0) { sprintf(stmnt, "%s %sval(%lu)", ncftype(types[itype]), nfstype(types[itype]), (unsigned long) max_atts[(int)types[itype]]); fline(stmnt); } } } /* create netCDF file, uses NC_CLOBBER mode */ fline("* enter define mode"); if (!cmode_modifier) { sprintf(stmnt, "iret = nf_create(\'%s\', NF_CLOBBER, ncid)", filename); } else if (cmode_modifier & NC_64BIT_OFFSET) { sprintf(stmnt, "iret = nf_create(\'%s\', OR(NF_CLOBBER,NF_64BIT_OFFSET), ncid)", filename); #ifdef USE_NETCDF4 } else if (cmode_modifier & NC_CLASSIC_MODEL) { sprintf(stmnt, "iret = nf_create(\'%s\', OR(NF_CLOBBER,NC_NETCDF4,NC_CLASSIC_MODEL), ncid)", filename); } else if (cmode_modifier & NC_NETCDF4) { sprintf(stmnt, "iret = nf_create(\'%s\', OR(NF_CLOBBER,NF_NETCDF4), ncid)", filename); #endif } else { derror("unknown cmode modifier"); } fline(stmnt); fline("call check_err(iret)"); /* define dimensions from info in dims array */ if (ndims > 0) fline("* define dimensions"); for (idim = 0; idim < ndims; idim++) { if (dims[idim].size == NC_UNLIMITED) sprintf(stmnt, "iret = nf_def_dim(ncid, \'%s\', NF_UNLIMITED, %s_dim)", dims[idim].name, dims[idim].lname); else sprintf(stmnt, "iret = nf_def_dim(ncid, \'%s\', %lu, %s_dim)", dims[idim].name, (unsigned long) dims[idim].size, dims[idim].lname); fline(stmnt); fline("call check_err(iret)"); } /* define variables from info in vars array */ if (nvars > 0) { fline("* define variables"); for (ivar = 0; ivar < nvars; ivar++) { for (idim = 0; idim < vars[ivar].ndims; idim++) { sprintf(stmnt, "%s_dims(%d) = %s_dim", vars[ivar].lname, vars[ivar].ndims - idim, /* reverse dimensions */ dims[vars[ivar].dims[idim]].lname); fline(stmnt); } if (vars[ivar].ndims > 0) { /* a dimensioned variable */ sprintf(stmnt, "iret = nf_def_var(ncid, \'%s\', %s, %s_rank, %s_dims, %s_id)", vars[ivar].name, ftypename(vars[ivar].type), vars[ivar].lname, vars[ivar].lname, vars[ivar].lname); } else { /* a scalar */ sprintf(stmnt, "iret = nf_def_var(ncid, \'%s\', %s, %s_rank, 0, %s_id)", vars[ivar].name, ftypename(vars[ivar].type), vars[ivar].lname, vars[ivar].lname); } fline(stmnt); fline("call check_err(iret)"); } } /* define attributes from info in atts array */ if (natts > 0) { fline("* assign attributes"); for (iatt = 0; iatt < natts; iatt++) { if (atts[iatt].type == NC_CHAR) { /* string */ val_string = fstrstr((char *) atts[iatt].val, atts[iatt].len); sprintf(stmnt, "iret = nf_put_att_text(ncid, %s%s, \'%s\', %lu, %s)", atts[iatt].var == -1 ? "NF_GLOBAL" : vars[atts[iatt].var].lname, atts[iatt].var == -1 ? "" : "_id", atts[iatt].name, (unsigned long) atts[iatt].len, val_string); fline(stmnt); fline("call check_err(iret)"); free(val_string); } else { for (jatt = 0; jatt < atts[iatt].len ; jatt++) { val_string = fstring(atts[iatt].type,atts[iatt].val,jatt); sprintf(stmnt, "%sval(%d) = %s", nfstype(atts[iatt].type), jatt+1, val_string); fline(stmnt); free (val_string); } sprintf(stmnt, "iret = nf_put_att_%s(ncid, %s%s, \'%s\', %s, %lu, %sval)", nfftype(atts[iatt].type), atts[iatt].var == -1 ? "NCGLOBAL" : vars[atts[iatt].var].lname, atts[iatt].var == -1 ? "" : "_id", atts[iatt].name, ftypename(atts[iatt].type), (unsigned long) atts[iatt].len, nfstype(atts[iatt].type)); fline(stmnt); fline("call check_err(iret)"); } } } if (nofill_flag) { fline("* don't initialize variables with fill values"); fline("iret = nf_set_fill(ncid, NF_NOFILL, oldmode)"); fline("call check_err(iret)"); } fline("* leave define mode"); fline("iret = nf_enddef(ncid)"); fline("call check_err(iret)"); }

static void gen_netcdf (  char *  filename  )  [static]

Definition at line 35 of file genlib.c. References check_err(), cmode_modifier, len, natts, NC_BYTE, NC_CHAR, nc_create, nc_def_dim, nc_def_var, NC_DOUBLE, NC_EBADTYPE, nc_enddef, NC_FLOAT, NC_GLOBAL, NC_INT, NC_NOFILL, nc_put_att_double, nc_put_att_float, nc_put_att_int, nc_put_att_schar, nc_put_att_short, nc_put_att_text, nc_set_fill, NC_SHORT, ncid, ndims, nofill_flag, nvars, size, and type. Referenced by define_netcdf(). { int idim, ivar, iatt; int dimid; int varid; int stat; stat = nc_create(filename, cmode_modifier, &ncid); check_err(stat); /* define dimensions from info in dims array */ for (idim = 0; idim < ndims; idim++) { stat = nc_def_dim(ncid, dims[idim].name, dims[idim].size, &dimid); check_err(stat); } /* define variables from info in vars array */ for (ivar = 0; ivar < nvars; ivar++) { stat = nc_def_var(ncid, vars[ivar].name, vars[ivar].type, vars[ivar].ndims, vars[ivar].dims, &varid); check_err(stat); } /* define attributes from info in atts array */ for (iatt = 0; iatt < natts; iatt++) { varid = (atts[iatt].var == -1) ? NC_GLOBAL : atts[iatt].var; switch(atts[iatt].type) { case NC_BYTE: stat = nc_put_att_schar(ncid, varid, atts[iatt].name, atts[iatt].type, atts[iatt].len, (signed char *) atts[iatt].val); break; case NC_CHAR: stat = nc_put_att_text(ncid, varid, atts[iatt].name, atts[iatt].len, (char *) atts[iatt].val); break; case NC_SHORT: stat = nc_put_att_short(ncid, varid, atts[iatt].name, atts[iatt].type, atts[iatt].len, (short *) atts[iatt].val); break; case NC_INT: stat = nc_put_att_int(ncid, varid, atts[iatt].name, atts[iatt].type, atts[iatt].len, (int *) atts[iatt].val); break; case NC_FLOAT: stat = nc_put_att_float(ncid, varid, atts[iatt].name, atts[iatt].type, atts[iatt].len, (float *) atts[iatt].val); break; case NC_DOUBLE: stat = nc_put_att_double(ncid, varid, atts[iatt].name, atts[iatt].type, atts[iatt].len, (double *) atts[iatt].val); break; default: stat = NC_EBADTYPE; } check_err(stat); } if (nofill_flag) { stat = nc_set_fill(ncid, NC_NOFILL, 0); /* don't initialize with fill values */ check_err(stat); } stat = nc_enddef(ncid); check_err(stat); }

void grow_aarray (  int  nar, struct atts **  arpp )

Definition at line 1824 of file genlib.c. References emalloc(), erealloc(), and pow2(). Referenced by yyparse(). { if (nar == 0) { *arpp = (struct atts *) emalloc(1 * sizeof(struct atts)); return; } if (! pow2(nar)) /* return unless nar is a power of two */ return; *arpp = (struct atts *) erealloc(*arpp, 2 * nar * sizeof(struct atts)); }

void grow_darray (  int  nar, struct dims **  arpp )

Definition at line 1798 of file genlib.c. References emalloc(), erealloc(), and pow2(). Referenced by yyparse(). { if (nar == 0) { *arpp = (struct dims *) emalloc(1 * sizeof(struct dims)); return; } if (! pow2(nar)) /* return unless nar is a power of two */ return; *arpp = (struct dims *) erealloc(*arpp, 2 * nar * sizeof(struct dims)); }

void grow_iarray (  int  nar, int **  arpp )

Definition at line 1746 of file genlib.c. References emalloc(), erealloc(), and pow2(). Referenced by yyparse(). { if (nar == 0) { *arpp = (int *) emalloc(1 * sizeof(int)); return; } if (! pow2(nar)) /* return unless nar is a power of two */ return; *arpp = (int *) erealloc(*arpp, 2 * nar * sizeof(int)); }

void grow_varray (  int  nar, struct vars **  arpp )

Definition at line 1772 of file genlib.c. References emalloc(), erealloc(), and pow2(). Referenced by yyparse(). { if (nar == 0) { *arpp = (struct vars *) emalloc(1 * sizeof(struct vars)); return; } if (! pow2(nar)) /* return unless nar is a power of two */ return; *arpp = (struct vars *) erealloc(*arpp, 2 * nar * sizeof(struct vars)); }

const char* ncatype (  nc_type  type  )

Definition at line 980 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by gen_c(). { switch (type) { case NC_BYTE: return "int"; /* avoids choosing between uchar and schar */ case NC_CHAR: return "text"; case NC_SHORT: return "short"; case NC_INT: return "int"; case NC_FLOAT: return "float"; case NC_DOUBLE: return "double"; default: derror("ncatype: bad type code"); return 0; } }

const char* ncctype (  nc_type  type  )

Definition at line 925 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by gen_load_c(). { switch (type) { case NC_BYTE: return "signed char"; case NC_CHAR: return "char"; case NC_SHORT: return "short"; case NC_INT: return "int"; case NC_FLOAT: return "float"; case NC_DOUBLE: return "double"; default: derror("ncctype: bad type code"); return 0; } }

static const char* ncftype (  nc_type  type  )  [static]

Definition at line 450 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by cl_fortran(), and gen_fortran(). { switch (type) { case NC_BYTE: return "integer"; case NC_CHAR: return "character"; case NC_SHORT: return "integer"; case NC_INT: #ifdef MSDOS return "integer*4"; #else return "integer"; #endif case NC_FLOAT: return "real"; #ifdef _CRAY case NC_DOUBLE: return "real"; /* we don't support CRAY 128-bit doubles */ #else case NC_DOUBLE: return "double precision"; #endif default: derror("ncftype: bad type code"); return 0; } }

const char* ncstype (  nc_type  type  )

Definition at line 953 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by gen_load_c(). { switch (type) { case NC_BYTE: return "schar"; case NC_CHAR: return "text"; case NC_SHORT: return "short"; case NC_INT: return "int"; case NC_FLOAT: return "float"; case NC_DOUBLE: return "double"; default: derror("ncstype: bad type code"); return 0; } }

const char* nctype (  nc_type  type  )

Definition at line 898 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by gen_c(), and yyparse(). { switch (type) { case NC_BYTE: return "NC_BYTE"; case NC_CHAR: return "NC_CHAR"; case NC_SHORT: return "NC_SHORT"; case NC_INT: return "NC_INT"; case NC_FLOAT: return "NC_FLOAT"; case NC_DOUBLE: return "NC_DOUBLE"; default: derror("nctype: bad type code"); return 0; } }

size_t nctypesize (  nc_type  type  )

Definition at line 1005 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by yyparse(). { switch (type) { case NC_BYTE: return sizeof(char); case NC_CHAR: return sizeof(char); case NC_SHORT: return sizeof(short); case NC_INT: return sizeof(int); case NC_FLOAT: return sizeof(float); case NC_DOUBLE: return sizeof(double); default: derror("nctypesize: bad type code"); return 0; } }

const char* nfftype (  nc_type  type  )

Definition at line 514 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by cl_fortran(), gen_fortran(), and gen_load_fortran(). { switch (type) { case NC_BYTE: return "int"; case NC_CHAR: return "text"; case NC_SHORT: return "int"; case NC_INT: return "int"; case NC_FLOAT: return "real"; #ifdef _CRAY case NC_DOUBLE: return "real"; /* we don't support CRAY 128-bit doubles */ #else case NC_DOUBLE: return "double"; #endif default: derror("nfstype: bad type code"); return 0; } }

const char* nfstype (  nc_type  type  )

Definition at line 486 of file genlib.c. References derror(), NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, and NC_SHORT. Referenced by gen_fortran(). { switch (type) { case NC_BYTE: return "int1"; case NC_CHAR: return "text"; case NC_SHORT: return "int2"; case NC_INT: return "int"; case NC_FLOAT: return "real"; case NC_DOUBLE: return "double"; default: derror("nfstype: bad type code"); return 0; } }

static int pow2 (  int  n  )  [static]

Definition at line 1720 of file genlib.c. Referenced by grow_aarray(), grow_darray(), grow_iarray(), and grow_varray(). { int m = n; int p = 1; while (m > 0) { m /= 2; p *= 2; } return p == 2*n; }

static int used_in_rec_var (  int  idim  )  [static]

Definition at line 1280 of file genlib.c. References ndims, nvars, and rec_dim. Referenced by cl_fortran(). { int ivar; for (ivar = 0; ivar < nvars; ivar++) { if (vars[ivar].ndims > 0 && vars[ivar].dims[0] == rec_dim) { int jdim; for (jdim = 0; jdim < vars[ivar].ndims; jdim++) { if (vars[ivar].dims[jdim] == idim) return 1; } } } return 0; }

---

Variable Documentation

int c_flag

Definition at line 26 of file main.c. Referenced by close_netcdf(), define_netcdf(), main(), and put_variable().

int cmode_modifier

Definition at line 29 of file main.c. Referenced by gen_c(), gen_fortran(), gen_netcdf(), and main().

int derror_count = 0

Definition at line 30 of file genlib.c. Referenced by check_err(), derror(), and yyparse().

int fortran_flag

Definition at line 27 of file main.c. Referenced by close_netcdf(), define_netcdf(), main(), and put_variable().

int lineno = 1

Definition at line 29 of file genlib.c. Referenced by derror().

int netcdf_flag

Definition at line 28 of file main.c. Referenced by close_netcdf(), define_netcdf(), main(), and put_variable().

char* netcdf_name

Definition at line 31 of file main.c. Referenced by define_netcdf(), and main().

int nofill_flag

Definition at line 30 of file main.c. Referenced by gen_c(), gen_fortran(), gen_netcdf(), and main().

---