/*
* Copyright 1996, University Corporation for Atmospheric Research
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
*/
/* $Id: v2i.c,v 1.24 2000/10/13 15:48:08 russ Exp $ */
#include "nc.h"
#ifndef NO_NETCDF_2
#if SIZEOF_LONG == SIZEOF_SIZE_T
/*
* We don't have to copy the arguments to switch from 'long'
* to 'size_t' or 'ptrdiff_t'. Use dummy macros.
*/
# define NDIMS_DECL
# define A_DECL(name, type, ndims, rhs) \
const type *const name = ((const type *)(rhs))
# define A_FREE(name)
# define A_INIT(lhs, type, ndims, rhs)
#else
/*
* We do have to copy the arguments to switch from 'long'
* to 'size_t' or 'ptrdiff_t'. In my tests on an SGI,
* any additional cost was lost in measurement variation.
*/
# include "onstack.h"
static size_t
nvdims(int ncid, int varid)
{
NC *ncp;
if(NC_check_id(ncid, &ncp) != NC_NOERR)
return 0;
{
const NC_var *const varp = NC_lookupvar(ncp, varid);
if(varp == NULL)
return 0;
return varp->ndims;
}
}
#define NDIMS_DECL const size_t ndims = nvdims(ncid, varid);
# define A_DECL(name, type, ndims, rhs) \
ALLOC_ONSTACK(name, type, ndims)
# define A_FREE(name) \
FREE_ONSTACK(name)
# define A_INIT(lhs, type, ndims, rhs) \
{ \
const long *lp = rhs; \
type *tp = lhs; \
type *const end = lhs + ndims; \
while(tp < end) \
{ \
*tp++ = (type) *lp++; \
} \
}
#endif
/* Begin globals */
/*
* Error code
*/
int ncerr = NC_NOERR ;
/*
* The subroutines in error.c emit no messages unless NC_VERBOSE bit is on.
* They call exit() when NC_FATAL bit is on.
*/
int ncopts = (NC_FATAL | NC_VERBOSE) ;
/*
* Backward compatibility for the version 2 fortran jackets
*/
const char *cdf_routine_name;
/* End globals */
/* Begin error handling */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
/*
*/
void
nc_advise(const char *routine_name, int err, const char *fmt,...)
{
va_list args;
if(NC_ISSYSERR(err))
ncerr = NC_SYSERR;
else
ncerr = err;
if( ncopts & NC_VERBOSE )
{
(void) fprintf(stderr,"%s: ", routine_name);
va_start(args ,fmt);
(void) vfprintf(stderr,fmt,args);
va_end(args);
if(err != NC_NOERR)
{
(void) fprintf(stderr,": %s",
nc_strerror(err));
}
(void) fputc('\n',stderr);
(void) fflush(stderr); /* to ensure log files are current */
}
if( (ncopts & NC_FATAL) && err != NC_NOERR )
{
exit(ncopts);
}
}
/*
* Backward compatibility for the version 2 fortran jackets
*/
void
NCadvise(int err, char *fmt,...)
{
va_list args;
va_start(args ,fmt);
nc_advise(cdf_routine_name, err, fmt, args);
va_end(args);
}
/* End error handling */
int
nccreate(const char* path, int cmode)
{
int ncid;
const int status = nc_create(path, cmode, &ncid);
if(status != NC_NOERR)
{
nc_advise("nccreate", status, "filename \"%s\"", path);
return -1;
}
return ncid;
}
int
ncopen(const char *path, int mode)
{
int ncid;
const int status = nc_open(path, mode, &ncid);
if(status != NC_NOERR)
{
nc_advise("ncopen", status, "filename \"%s\"", path);
return -1;
}
return ncid;
}
int
ncredef(int ncid)
{
const int status = nc_redef(ncid);
if(status != NC_NOERR)
{
nc_advise("ncredef", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncendef(int ncid)
{
const int status = nc_enddef(ncid);
if(status != NC_NOERR)
{
nc_advise("ncendef", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncclose(int ncid)
{
const int status = nc_close(ncid);
if(status != NC_NOERR)
{
nc_advise("ncclose", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncinquire(
int ncid,
int* ndims,
int* nvars,
int* natts,
int* recdim
)
{
int nd, nv, na;
const int status = nc_inq(ncid, &nd, &nv, &na, recdim);
if(status != NC_NOERR)
{
nc_advise("ncinquire", status, "ncid %d", ncid);
return -1;
}
/* else */
if(ndims != NULL)
*ndims = (int) nd;
if(nvars != NULL)
*nvars = (int) nv;
if(natts != NULL)
*natts = (int) na;
return ncid;
}
int
ncsync(int ncid)
{
const int status = nc_sync(ncid);
if(status != NC_NOERR)
{
nc_advise("ncsync", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncabort(int ncid)
{
const int status = nc_abort(ncid);
if(status != NC_NOERR)
{
nc_advise("ncabort", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncdimdef(
int ncid,
const char* name,
long length
)
{
int dimid;
const int status = nc_def_dim(ncid, name, (size_t)length, &dimid);
if(status != NC_NOERR)
{
nc_advise("ncdimdef", status, "ncid %d", ncid);
return -1;
}
return dimid;
}
int
ncdimid(int ncid, const char* name)
{
int dimid;
const int status = nc_inq_dimid(ncid, name, &dimid);
if(status != NC_NOERR)
{
nc_advise("ncdimid", status, "ncid %d", ncid);
return -1;
}
return dimid;
}
int
ncdiminq(
int ncid,
int dimid,
char* name,
long* length
)
{
size_t ll;
const int status = nc_inq_dim(ncid, dimid, name, &ll);
if(status != NC_NOERR)
{
nc_advise("ncdiminq", status, "ncid %d", ncid);
return -1;
}
/* else */
if(length != NULL)
*length = (int) ll;
return dimid;
}
int
ncdimrename(
int ncid,
int dimid,
const char* name
)
{
const int status = nc_rename_dim(ncid, dimid, name);
if(status != NC_NOERR)
{
nc_advise("ncdimrename", status, "ncid %d", ncid);
return -1;
}
return dimid;
}
int
ncvardef(
int ncid,
const char* name,
nc_type datatype,
int ndims,
const int* dim
)
{
int varid = -1;
const int status = nc_def_var(ncid, name, datatype, ndims, dim, &varid);
if(status != NC_NOERR)
{
nc_advise("ncvardef", status, "ncid %d", ncid);
return -1;
}
return varid;
}
int
ncvarid(
int ncid,
const char* name
)
{
int varid = -1;
const int status = nc_inq_varid(ncid, name, &varid);
if(status != NC_NOERR)
{
nc_advise("ncvarid", status, "ncid %d", ncid);
return -1;
}
return varid;
}
int
ncvarinq(
int ncid,
int varid,
char* name,
nc_type* datatype,
int* ndims,
int* dim,
int* natts
)
{
int nd, na;
const int status = nc_inq_var(ncid, varid, name, datatype,
&nd, dim, &na);
if(status != NC_NOERR)
{
nc_advise("ncvarinq", status, "ncid %d", ncid);
return -1;
}
/* else */
if(ndims != NULL)
*ndims = (int) nd;
if(natts != NULL)
*natts = (int) na;
return varid;
}
int
ncvarput1(
int ncid,
int varid,
const long* index,
const void* value
)
{
NDIMS_DECL
A_DECL(coordp, size_t, ndims, index);
A_INIT(coordp, size_t, ndims, index);
{
const int status = nc_put_var1(ncid, varid, coordp, value);
A_FREE(coordp);
if(status != NC_NOERR)
{
nc_advise("ncvarput1", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
int
ncvarget1(
int ncid,
int varid,
const long* index,
void* value
)
{
NDIMS_DECL
A_DECL(coordp, size_t, ndims, index);
A_INIT(coordp, size_t, ndims, index);
{
const int status = nc_get_var1(ncid, varid, coordp, value);
A_FREE(coordp);
if(status != NC_NOERR)
{
nc_advise("ncdimid", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
int
ncvarput(
int ncid,
int varid,
const long* start,
const long* count,
const void* value
)
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
{
const int status = nc_put_vara(ncid, varid, stp, cntp, value);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarput", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
int
ncvarget(
int ncid,
int varid,
const long* start,
const long* count,
void* value
)
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
{
const int status = nc_get_vara(ncid, varid, stp, cntp, value);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarget", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
int
ncvarputs(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
const void* value
)
{
if(stride == NULL)
return ncvarput(ncid, varid, start, count, value);
/* else */
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
{
const int status = nc_put_vars(ncid, varid, stp, cntp, strdp, value);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarputs", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
int
ncvargets(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
void* value
)
{
if(stride == NULL)
return ncvarget(ncid, varid, start, count, value);
/* else */
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
{
const int status = nc_get_vars(ncid, varid, stp, cntp, strdp, value);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvargets", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
int
ncvarputg(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
const long* map,
const void* value
)
{
if(map == NULL)
return ncvarputs(ncid, varid, start, count, stride, value);
/* else */
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_DECL(imp, ptrdiff_t, ndims, map);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
A_INIT(imp, ptrdiff_t, ndims, map);
{
const int status = nc_put_varm(ncid, varid,
stp, cntp, strdp, imp, value);
A_FREE(imp);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvarputg", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
int
ncvargetg(
int ncid,
int varid,
const long* start,
const long* count,
const long* stride,
const long* map,
void* value
)
{
if(map == NULL)
return ncvargets(ncid, varid, start, count, stride, value);
/* else */
{
NDIMS_DECL
A_DECL(stp, size_t, ndims, start);
A_DECL(cntp, size_t, ndims, count);
A_DECL(strdp, ptrdiff_t, ndims, stride);
A_DECL(imp, ptrdiff_t, ndims, map);
A_INIT(stp, size_t, ndims, start);
A_INIT(cntp, size_t, ndims, count);
A_INIT(strdp, ptrdiff_t, ndims, stride);
A_INIT(imp, ptrdiff_t, ndims, map);
{
const int status = nc_get_varm(ncid, varid,
stp, cntp, strdp, imp, value);
A_FREE(imp);
A_FREE(strdp);
A_FREE(cntp);
A_FREE(stp);
if(status != NC_NOERR)
{
nc_advise("ncvargetg", status, "ncid %d", ncid);
return -1;
}
}
return 0;
}
}
int
ncvarrename(
int ncid,
int varid,
const char* name
)
{
const int status = nc_rename_var(ncid, varid, name);
if(status != NC_NOERR)
{
nc_advise("ncvarrename", status, "ncid %d", ncid);
return -1;
}
return varid;
}
int
ncattput(
int ncid,
int varid,
const char* name,
nc_type datatype,
int len,
const void* value
)
{
const int status = nc_put_att(ncid, varid, name, datatype, len, value);
if(status != NC_NOERR)
{
nc_advise("ncattput", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncattinq(
int ncid,
int varid,
const char* name,
nc_type* datatype,
int* len
)
{
size_t ll;
const int status = nc_inq_att(ncid, varid, name, datatype, &ll);
if(status != NC_NOERR)
{
nc_advise("ncattinq", status, "ncid %d", ncid);
return -1;
}
if(len != NULL)
*len = (int) ll;
return 1;
}
int
ncattget(
int ncid,
int varid,
const char* name,
void* value
)
{
const int status = nc_get_att(ncid, varid, name, value);
if(status != NC_NOERR)
{
nc_advise("ncattget", status, "ncid %d", ncid);
return -1;
}
return 1;
}
int
ncattcopy(
int ncid_in,
int varid_in,
const char* name,
int ncid_out,
int varid_out
)
{
const int status = nc_copy_att(ncid_in, varid_in, name, ncid_out, varid_out);
if(status != NC_NOERR)
{
nc_advise("ncattcopy", status, "%s", name);
return -1;
}
return 0;
}
int
ncattname(
int ncid,
int varid,
int attnum,
char* name
)
{
const int status = nc_inq_attname(ncid, varid, attnum, name);
if(status != NC_NOERR)
{
nc_advise("ncattname", status, "ncid %d", ncid);
return -1;
}
return attnum;
}
int
ncattrename(
int ncid,
int varid,
const char* name,
const char* newname
)
{
const int status = nc_rename_att(ncid, varid, name, newname);
if(status != NC_NOERR)
{
nc_advise("ncattrename", status, "ncid %d", ncid);
return -1;
}
return 1;
}
int
ncattdel(
int ncid,
int varid,
const char* name
)
{
const int status = nc_del_att(ncid, varid, name);
if(status != NC_NOERR)
{
nc_advise("ncattdel", status, "ncid %d", ncid);
return -1;
}
return 1;
}
#endif /* NO_NETCDF_2 */
/*
* This is how much space is required by the user, as in
*
* vals = malloc(nel * nctypelen(var.type));
* ncvarget(cdfid, varid, cor, edg, vals);
*/
int
nctypelen(nc_type type)
{
switch(type){
case NC_BYTE :
case NC_CHAR :
return((int)sizeof(char));
case NC_SHORT :
return(int)(sizeof(short));
case NC_INT :
return((int)sizeof(int));
case NC_FLOAT :
return((int)sizeof(float));
case NC_DOUBLE :
return((int)sizeof(double));
}
#ifndef NO_NETCDF_2
/* else */
nc_advise("nctypelen", NC_EBADTYPE, "Unknown type %d",
(int)type);
#endif /* NO_NETCDF_2 */
return -1;
}
#ifndef NO_NETCDF_2
int
ncsetfill(
int ncid,
int fillmode
)
{
int oldmode = -1;
const int status = nc_set_fill(ncid, fillmode, &oldmode);
if(status != NC_NOERR)
{
nc_advise("ncsetfill", status, "ncid %d", ncid);
return -1;
}
return oldmode;
}
int
ncrecinq(
int ncid,
int* nrecvars,
int* recvarids,
long* recsizes
)
{
size_t nrv = 0;
size_t rs[NC_MAX_VARS]; /* TODO */
const int status = nc_inq_rec(ncid, &nrv, recvarids, rs);
if(status != NC_NOERR)
{
nc_advise("ncrecinq", status, "ncid %d", ncid);
return -1;
}
if(nrecvars != NULL)
*nrecvars = (int) nrv;
if(recsizes != NULL)
{
size_t ii;
for(ii = 0; ii < nrv; ii++)
{
recsizes[ii] = (long) rs[ii];
}
}
return (int) nrv;
}
int
ncrecget(
int ncid,
long recnum,
void** datap
)
{
const int status = nc_get_rec(ncid, (size_t)recnum, datap);
if(status != NC_NOERR)
{
nc_advise("ncrecget", status, "ncid %d", ncid);
return -1;
}
return 0;
}
int
ncrecput(
int ncid,
long recnum,
void* const* datap
)
{
const int status = nc_put_rec(ncid, (size_t)recnum, datap);
if(status != NC_NOERR)
{
nc_advise("ncrecput", status, "ncid %d", ncid);
return -1;
}
return 0;
}
#endif /* NO_NETCDF_2 */
syntax highlighted by Code2HTML, v. 0.9.1