ncdf4a13/libsrc/v1hpg.c File Reference

#include "nc.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "rnd.h"
#include "ncx.h"

Include dependency graph for v1hpg.c:

Go to the source code of this file.

Classes
struct	v1hs
Defines
#define	X_SIZEOF_NC_TYPE   X_SIZEOF_INT
#define	X_SIZEOF_NCTYPE   X_SIZEOF_INT
#define	MIN(mm, nn)   (((mm) < (nn)) ? (mm) : (nn))
Typedefs
typedef v1hs	v1hs
Functions
static int	rel_v1hs (v1hs *gsp)
static int	fault_v1hs (v1hs *gsp, size_t extent)
static int	check_v1hs (v1hs *gsp, size_t nextread)
static int	v1h_put_size_t (v1hs *psp, const size_t *sp)
static int	v1h_get_size_t (v1hs *gsp, size_t *sp)
static int	v1h_put_nc_type (v1hs *psp, const nc_type *typep)
static int	v1h_get_nc_type (v1hs *gsp, nc_type *typep)
static int	v1h_put_NCtype (v1hs *psp, NCtype type)
static int	v1h_get_NCtype (v1hs *gsp, NCtype *typep)
static size_t	ncx_len_NC_string (const NC_string *ncstrp)
static int	v1h_put_NC_string (v1hs *psp, const NC_string *ncstrp)
static int	v1h_get_NC_string (v1hs *gsp, NC_string **ncstrpp)
static size_t	ncx_len_NC_dim (const NC_dim *dimp)
static int	v1h_put_NC_dim (v1hs *psp, const NC_dim *dimp)
static int	v1h_get_NC_dim (v1hs *gsp, NC_dim **dimpp)
static size_t	ncx_len_NC_dimarray (const NC_dimarray *ncap)
static int	v1h_put_NC_dimarray (v1hs *psp, const NC_dimarray *ncap)
static int	v1h_get_NC_dimarray (v1hs *gsp, NC_dimarray *ncap)
static size_t	ncx_len_NC_attr (const NC_attr *attrp)
static int	v1h_put_NC_attrV (v1hs *psp, const NC_attr *attrp)
static int	v1h_put_NC_attr (v1hs *psp, const NC_attr *attrp)
static int	v1h_get_NC_attrV (v1hs *gsp, NC_attr *attrp)
static int	v1h_get_NC_attr (v1hs *gsp, NC_attr **attrpp)
static size_t	ncx_len_NC_attrarray (const NC_attrarray *ncap)
static int	v1h_put_NC_attrarray (v1hs *psp, const NC_attrarray *ncap)
static int	v1h_get_NC_attrarray (v1hs *gsp, NC_attrarray *ncap)
static size_t	ncx_len_NC_var (const NC_var *varp, size_t sizeof_off_t)
static int	v1h_put_NC_var (v1hs *psp, const NC_var *varp)
static int	v1h_get_NC_var (v1hs *gsp, NC_var **varpp)
static size_t	ncx_len_NC_vararray (const NC_vararray *ncap, size_t sizeof_off_t)
static int	v1h_put_NC_vararray (v1hs *psp, const NC_vararray *ncap)
static int	v1h_get_NC_vararray (v1hs *gsp, NC_vararray *ncap)
static int	NC_computeshapes (NC *ncp)
static off_t	NC_var_unpadded_len (const NC_var *varp, const NC_dimarray *dims)
size_t	ncx_len_NC (const NC *ncp, size_t sizeof_off_t)
int	ncx_put_NC (const NC *ncp, void **xpp, off_t offset, size_t extent)
int	nc_get_NC (NC *ncp)
Variables
static const schar	ncmagic [] = {'C', 'D', 'F', 0x02}
static const schar	ncmagic1 [] = {'C', 'D', 'F', 0x01}

---

Define Documentation

#define MIN (  mm, nn   )     (((mm) < (nn)) ? (mm) : (nn))

Definition at line 542 of file v1hpg.c.

#define X_SIZEOF_NC_TYPE   X_SIZEOF_INT

Definition at line 153 of file v1hpg.c. Referenced by ncx_len_NC_attr(), and ncx_len_NC_var().

#define X_SIZEOF_NCTYPE   X_SIZEOF_INT

Definition at line 196 of file v1hpg.c. Referenced by ncx_len_NC_attrarray(), ncx_len_NC_dimarray(), and ncx_len_NC_vararray().

---

Typedef Documentation

typedef struct v1hs v1hs

---

Function Documentation

static int check_v1hs (  v1hs *  gsp, size_t  nextread )  [static]

Definition at line 115 of file v1hpg.c. References v1hs::end, ENOERR, fault_v1hs(), and v1hs::pos. Referenced by v1h_get_NC_attrV(), v1h_get_NC_string(), v1h_get_nc_type(), v1h_get_NC_var(), v1h_get_NCtype(), v1h_get_size_t(), v1h_put_NC_attrV(), v1h_put_NC_string(), v1h_put_nc_type(), v1h_put_NC_var(), v1h_put_NCtype(), and v1h_put_size_t(). { #if 0 /* DEBUG */ fprintf(stderr, "nextread %lu, remaining %lu\n", (unsigned long)nextread, (unsigned long)((char *)gsp->end - (char *)gsp->pos)); #endif if((char *)gsp->pos + nextread <= (char *)gsp->end) return ENOERR; return fault_v1hs(gsp, nextread); }

static int fault_v1hs (  v1hs *  gsp, size_t  extent )  [static]

Definition at line 82 of file v1hpg.c. References v1hs::base, v1hs::end, ENOERR, v1hs::extent, v1hs::flags, ncio::get, v1hs::nciop, v1hs::offset, v1hs::pos, and rel_v1hs(). Referenced by check_v1hs(), nc_get_NC(), and ncx_put_NC(). { int status; if(gsp->base != NULL) { const ptrdiff_t incr = (char *)gsp->pos - (char *)gsp->base; status = rel_v1hs(gsp); if(status) return status; gsp->offset += incr; } if(extent > gsp->extent) gsp->extent = extent; status = gsp->nciop->get(gsp->nciop, gsp->offset, gsp->extent, gsp->flags, &gsp->base); if(status) return status; gsp->pos = gsp->base; gsp->end = (char *)gsp->base + gsp->extent; return ENOERR; }

static int NC_computeshapes (  NC *  ncp  )  [static]

Definition at line 1074 of file v1hpg.c. References NC_var::begin, NC::begin_rec, NC::begin_var, NC::dims, NC_var::dsizes, ENOERR, IS_RECVAR, NC_var::len, NC_var_shape(), NC_vararray::nelems, NC::recsize, NC_vararray::value, NC::vars, NC_var::xsz, and NC::xsz. Referenced by nc_get_NC(). { NC_var **vpp = (NC_var **)ncp->vars.value; NC_var *const *const end = &vpp[ncp->vars.nelems]; NC_var *first_var = NULL; /* first "non-record" var */ NC_var *first_rec = NULL; /* first "record" var */ int status; ncp->begin_var = (off_t) ncp->xsz; ncp->begin_rec = (off_t) ncp->xsz; ncp->recsize = 0; if(ncp->vars.nelems == 0) return(0); for( /*NADA*/; vpp < end; vpp++) { status = NC_var_shape(*vpp, &ncp->dims); if(status != ENOERR) return(status); if(IS_RECVAR(*vpp)) { if(first_rec == NULL) first_rec = *vpp; ncp->recsize += (*vpp)->len; } else { if(first_var == NULL) first_var = *vpp; /* * Overwritten each time thru. * Usually overwritten in first_rec != NULL clause below. */ ncp->begin_rec = (*vpp)->begin + (off_t)(*vpp)->len; } } if(first_rec != NULL) { assert(ncp->begin_rec <= first_rec->begin); ncp->begin_rec = first_rec->begin; /* * for special case of exactly one record variable, pack value */ if(ncp->recsize == first_rec->len) ncp->recsize = *first_rec->dsizes * first_rec->xsz; } if(first_var != NULL) { ncp->begin_var = first_var->begin; } else { ncp->begin_var = ncp->begin_rec; } assert(ncp->begin_var > 0); assert(ncp->xsz <= (size_t)ncp->begin_var); assert(ncp->begin_rec > 0); assert(ncp->begin_var <= ncp->begin_rec); return(ENOERR); }

int nc_get_NC (  NC *  ncp  )

Definition at line 1272 of file v1hpg.c. References NC::attrs, v1hs::base, NC::chunk, NC::dims, v1hs::end, ENOERR, v1hs::extent, fault_v1hs(), NC::flags, v1hs::flags, fSet, MIN_NC_XSZ, NC_64BIT_OFFSET, NC_computeshapes(), NC_ENOTNC, NC_set_numrecs, ncio_filesize(), NC::nciop, v1hs::nciop, ncmagic, ncx_get_size_t(), ncx_getn_schar_schar(), ncx_len_NC(), v1hs::offset, v1hs::pos, rel_v1hs(), ncio::sync, v1h_get_NC_attrarray(), v1h_get_NC_dimarray(), v1h_get_NC_vararray(), NC::vars, v1hs::version, and NC::xsz. Referenced by nc__open_mp(), nc_delete_mp(), and read_NC(). { int status; v1hs gs; /* the get stream */ assert(ncp != NULL); /* Initialize stream gs */ gs.nciop = ncp->nciop; gs.offset = 0; /* beginning of file */ gs.extent = 0; gs.flags = 0; gs.version = 0; gs.base = NULL; gs.pos = gs.base; { /* * Come up with a reasonable stream read size. */ off_t filesize; size_t extent = MIN_NC_XSZ; extent = ncp->xsz; if(extent <= MIN_NC_XSZ) { status = ncio_filesize(ncp->nciop, &filesize); if(status) return status; /* first time read */ extent = ncp->chunk; /* Protection for when ncp->chunk is huge; * no need to read hugely. */ if(extent > 4096) extent = 4096; if(extent > filesize) extent = filesize; } else if(extent > ncp->chunk) { extent = ncp->chunk; } /* * Invalidate the I/O buffers to force a read of the header * region. */ status = gs.nciop->sync(gs.nciop); if(status) return status; status = fault_v1hs(&gs, extent); if(status) return status; } /* get the header from the stream gs */ { /* Get & check magic number */ schar magic[sizeof(ncmagic)]; (void) memset(magic, 0, sizeof(magic)); status = ncx_getn_schar_schar( (const void **)(&gs.pos), sizeof(magic), magic); if(status != ENOERR) goto unwind_get; if(memcmp(magic, ncmagic, sizeof(ncmagic)-1) != 0) { status = NC_ENOTNC; goto unwind_get; } /* Check version number in last byte of magic */ if (magic[sizeof(ncmagic)-1] == 0x1) { gs.version = 1; } else if (magic[sizeof(ncmagic)-1] == 0x2) { gs.version = 2; fSet(ncp->flags, NC_64BIT_OFFSET); /* Now we support version 2 file access on non-LFS systems -- rkr */ #if 0 if (sizeof(off_t) != 8) { fprintf(stderr, "NETCDF WARNING: Version 2 file on 32-bit system.\n"); } #endif } else { status = NC_ENOTNC; goto unwind_get; } } { size_t nrecs = 0; status = ncx_get_size_t((const void **)(&gs.pos), &nrecs); if(status != ENOERR) goto unwind_get; NC_set_numrecs(ncp, nrecs); } assert((char *)gs.pos < (char *)gs.end); status = v1h_get_NC_dimarray(&gs, &ncp->dims); if(status != ENOERR) goto unwind_get; status = v1h_get_NC_attrarray(&gs, &ncp->attrs); if(status != ENOERR) goto unwind_get; status = v1h_get_NC_vararray(&gs, &ncp->vars); if(status != ENOERR) goto unwind_get; ncp->xsz = ncx_len_NC(ncp, (gs.version == 1) ? 4 : 8); status = NC_computeshapes(ncp); if(status != ENOERR) goto unwind_get; unwind_get: (void) rel_v1hs(&gs); return status; }

static off_t NC_var_unpadded_len (  const NC_var *  varp, const NC_dimarray *  dims )  [static]

Definition at line 1149 of file v1hpg.c. References IS_RECVAR, NC_var::ndims, product(), NC_var::shape, and NC_var::xsz. { size_t *shp; off_t product = 1; if(varp->ndims != 0) { for(shp = varp->shape + varp->ndims -1; shp >= varp->shape; shp--) { if(!(shp == varp->shape && IS_RECVAR(varp))) product *= *shp; } } product = product * varp->xsz; return product; }

size_t ncx_len_NC (  const NC *  ncp, size_t  sizeof_off_t )

Definition at line 1165 of file v1hpg.c. References NC::attrs, NC::dims, ncmagic, ncx_len_NC_attrarray(), ncx_len_NC_dimarray(), ncx_len_NC_vararray(), NC::vars, and X_SIZEOF_SIZE_T. Referenced by nc__create_mp(), NC_begins(), nc_get_NC(), and new_NC(). { size_t xlen = sizeof(ncmagic); assert(ncp != NULL); xlen += X_SIZEOF_SIZE_T; /* numrecs */ xlen += ncx_len_NC_dimarray(&ncp->dims); xlen += ncx_len_NC_attrarray(&ncp->attrs); xlen += ncx_len_NC_vararray(&ncp->vars, sizeof_off_t); return xlen; }

static size_t ncx_len_NC_attr (  const NC_attr *  attrp  )  [static]

Definition at line 526 of file v1hpg.c. References NC_attr::name, ncx_len_NC_string(), X_SIZEOF_NC_TYPE, X_SIZEOF_SIZE_T, and NC_attr::xsz. Referenced by ncx_len_NC_attrarray(). { size_t sz; assert(attrp != NULL); sz = ncx_len_NC_string(attrp->name); sz += X_SIZEOF_NC_TYPE; /* type */ sz += X_SIZEOF_SIZE_T; /* nelems */ sz += attrp->xsz; return(sz); }

static size_t ncx_len_NC_attrarray (  const NC_attrarray *  ncap  )  [static]

Definition at line 684 of file v1hpg.c. References ncx_len_NC_attr(), NC_attrarray::nelems, NC_attrarray::value, X_SIZEOF_NCTYPE, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC(), and ncx_len_NC_var(). { size_t xlen = X_SIZEOF_NCTYPE; /* type */ xlen += X_SIZEOF_SIZE_T; /* count */ if(ncap == NULL) return xlen; /* else */ { const NC_attr **app = (const NC_attr **)ncap->value; const NC_attr *const *const end = &app[ncap->nelems]; for( /*NADA*/; app < end; app++) { xlen += ncx_len_NC_attr(*app); } } return xlen; }

static size_t ncx_len_NC_dim (  const NC_dim *  dimp  )  [static]

Definition at line 330 of file v1hpg.c. References NC_dim::name, ncx_len_NC_string(), and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC_dimarray(). { size_t sz; assert(dimp != NULL); sz = ncx_len_NC_string(dimp->name); sz += X_SIZEOF_SIZE_T; return(sz); }

static size_t ncx_len_NC_dimarray (  const NC_dimarray *  ncap  )  [static]

Definition at line 395 of file v1hpg.c. References ncx_len_NC_dim(), NC_dimarray::nelems, NC_dimarray::value, X_SIZEOF_NCTYPE, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC(). { size_t xlen = X_SIZEOF_NCTYPE; /* type */ xlen += X_SIZEOF_SIZE_T; /* count */ if(ncap == NULL) return xlen; /* else */ { const NC_dim **dpp = (const NC_dim **)ncap->value; const NC_dim *const *const end = &dpp[ncap->nelems]; for( /*NADA*/; dpp < end; dpp++) { xlen += ncx_len_NC_dim(*dpp); } } return xlen; }

static size_t ncx_len_NC_string (  const NC_string *  ncstrp  )  [static]

Definition at line 235 of file v1hpg.c. References _RNDUP, NC_string::nchars, X_ALIGN, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC_attr(), ncx_len_NC_dim(), and ncx_len_NC_var(). { size_t sz = X_SIZEOF_SIZE_T; /* nchars */ assert(ncstrp != NULL); if(ncstrp->nchars != 0) { #if 0 assert(ncstrp->nchars % X_ALIGN == 0); sz += ncstrp->nchars; #else sz += _RNDUP(ncstrp->nchars, X_ALIGN); #endif } return sz; }

static size_t ncx_len_NC_var (  const NC_var *  varp, size_t  sizeof_off_t )  [static]

Definition at line 812 of file v1hpg.c. References NC_var::attrs, NC_var::name, ncx_len_int, ncx_len_NC_attrarray(), ncx_len_NC_string(), NC_var::ndims, X_SIZEOF_NC_TYPE, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC_vararray(). { size_t sz; assert(varp != NULL); assert(sizeof_off_t != 0); sz = ncx_len_NC_string(varp->name); sz += X_SIZEOF_SIZE_T; /* ndims */ sz += ncx_len_int(varp->ndims); /* dimids */ sz += ncx_len_NC_attrarray(&varp->attrs); sz += X_SIZEOF_NC_TYPE; /* type */ sz += X_SIZEOF_SIZE_T; /* len */ sz += sizeof_off_t; /* begin */ return(sz); }

static size_t ncx_len_NC_vararray (  const NC_vararray *  ncap, size_t  sizeof_off_t )  [static]

Definition at line 940 of file v1hpg.c. References ncx_len_NC_var(), NC_vararray::nelems, NC_vararray::value, X_SIZEOF_NCTYPE, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC(). { size_t xlen = X_SIZEOF_NCTYPE; /* type */ xlen += X_SIZEOF_SIZE_T; /* count */ if(ncap == NULL) return xlen; /* else */ { const NC_var **vpp = (const NC_var **)ncap->value; const NC_var *const *const end = &vpp[ncap->nelems]; for( /*NADA*/; vpp < end; vpp++) { xlen += ncx_len_NC_var(*vpp, sizeof_off_t); } } return xlen; }

int ncx_put_NC (  const NC *  ncp, void **  xpp, off_t  offset, size_t  extent )

Definition at line 1181 of file v1hpg.c. References NC::attrs, v1hs::base, NC::chunk, NC::dims, v1hs::end, ENOERR, v1hs::extent, fault_v1hs(), NC::flags, v1hs::flags, MIN_NC_XSZ, NC_64BIT_OFFSET, NC_get_numrecs, NC::nciop, v1hs::nciop, ncmagic, ncmagic1, ncx_put_size_t(), ncx_putn_schar_schar(), v1hs::offset, v1hs::pos, rel_v1hs(), RGN_WRITE, v1h_put_NC_attrarray(), v1h_put_NC_dimarray(), v1h_put_NC_vararray(), NC::vars, v1hs::version, and NC::xsz. Referenced by nc__create_mp(), and write_NC(). { int status = ENOERR; v1hs ps; /* the get stream */ assert(ncp != NULL); /* Initialize stream ps */ ps.nciop = ncp->nciop; ps.flags = RGN_WRITE; if (ncp->flags & NC_64BIT_OFFSET) ps.version = 2; else ps.version = 1; if(xpp == NULL) { /* * Come up with a reasonable stream read size. */ extent = ncp->xsz; if(extent <= MIN_NC_XSZ) { /* first time read */ extent = ncp->chunk; /* Protection for when ncp->chunk is huge; * no need to read hugely. */ if(extent > 4096) extent = 4096; } else if(extent > ncp->chunk) { extent = ncp->chunk; } ps.offset = 0; ps.extent = extent; ps.base = NULL; ps.pos = ps.base; status = fault_v1hs(&ps, extent); if(status) return status; } else { ps.offset = offset; ps.extent = extent; ps.base = *xpp; ps.pos = ps.base; ps.end = (char *)ps.base + ps.extent; } if (ps.version == 2) status = ncx_putn_schar_schar(&ps.pos, sizeof(ncmagic), ncmagic); else status = ncx_putn_schar_schar(&ps.pos, sizeof(ncmagic1), ncmagic1); if(status != ENOERR) goto release; { const size_t nrecs = NC_get_numrecs(ncp); status = ncx_put_size_t(&ps.pos, &nrecs); if(status != ENOERR) goto release; } assert((char *)ps.pos < (char *)ps.end); status = v1h_put_NC_dimarray(&ps, &ncp->dims); if(status != ENOERR) goto release; status = v1h_put_NC_attrarray(&ps, &ncp->attrs); if(status != ENOERR) goto release; status = v1h_put_NC_vararray(&ps, &ncp->vars); if(status != ENOERR) goto release; release: (void) rel_v1hs(&ps); return status; }

static int rel_v1hs (  v1hs *  gsp  )  [static]

Definition at line 63 of file v1hpg.c. References v1hs::base, v1hs::end, ENOERR, v1hs::flags, v1hs::nciop, OFF_NONE, v1hs::offset, v1hs::pos, ncio::rel, RGN_MODIFIED, and RGN_WRITE. Referenced by fault_v1hs(), nc_get_NC(), and ncx_put_NC(). { int status; if(gsp->offset == OFF_NONE || gsp->base == NULL) return ENOERR; status = gsp->nciop->rel(gsp->nciop, gsp->offset, gsp->flags == RGN_WRITE ? RGN_MODIFIED : 0); gsp->end = NULL; gsp->pos = NULL; gsp->base = NULL; return status; }

static int v1h_get_NC_attr (  v1hs *  gsp, NC_attr **  attrpp )  [static]

Definition at line 639 of file v1hpg.c. References ENOERR, free_NC_attr(), free_NC_string(), NC_ENOMEM, new_x_NC_attr(), type, v1h_get_NC_attrV(), v1h_get_NC_string(), v1h_get_nc_type(), and v1h_get_size_t(). Referenced by v1h_get_NC_attrarray(). { NC_string *strp; int status; nc_type type; size_t nelems; NC_attr *attrp; status = v1h_get_NC_string(gsp, &strp); if(status != ENOERR) return status; status = v1h_get_nc_type(gsp, &type); if(status != ENOERR) goto unwind_name; status = v1h_get_size_t(gsp, &nelems); if(status != ENOERR) goto unwind_name; attrp = new_x_NC_attr(strp, type, nelems); if(attrp == NULL) { status = NC_ENOMEM; goto unwind_name; } status = v1h_get_NC_attrV(gsp, attrp); if(status != ENOERR) { free_NC_attr(attrp); /* frees strp */ return status; } *attrpp = attrp; return ENOERR; unwind_name: free_NC_string(strp); return status; }

static int v1h_get_NC_attrarray (  v1hs *  gsp, NC_attrarray *  ncap )  [static]

Definition at line 758 of file v1hpg.c. References ENOERR, free_NC_attrarrayV(), NC_attrarray::nalloc, NC_ATTRIBUTE, NC_ENOMEM, NC_UNSPECIFIED, NC_attrarray::nelems, v1hs::pos, type, v1h_get_NC_attr(), v1h_get_NCtype(), v1h_get_size_t(), and NC_attrarray::value. Referenced by nc_get_NC(), and v1h_get_NC_var(). { int status; NCtype type = NC_UNSPECIFIED; assert(gsp != NULL && gsp->pos != NULL); assert(ncap != NULL); assert(ncap->value == NULL); status = v1h_get_NCtype(gsp, &type); if(status != ENOERR) return status; status = v1h_get_size_t(gsp, &ncap->nelems); if(status != ENOERR) return status; if(ncap->nelems == 0) return ENOERR; /* else */ if(type != NC_ATTRIBUTE) return EINVAL; ncap->value = (NC_attr **) malloc(ncap->nelems * sizeof(NC_attr *)); if(ncap->value == NULL) return NC_ENOMEM; ncap->nalloc = ncap->nelems; { NC_attr **app = ncap->value; NC_attr *const *const end = &app[ncap->nelems]; for( /*NADA*/; app < end; app++) { status = v1h_get_NC_attr(gsp, app); if(status) { ncap->nelems = (size_t)(app - ncap->value); free_NC_attrarrayV(ncap); return status; } } } return ENOERR; }

static int v1h_get_NC_attrV (  v1hs *  gsp, NC_attr *  attrp )  [static]

Definition at line 609 of file v1hpg.c. References check_v1hs(), ENOERR, v1hs::extent, MIN, v1hs::pos, X_ALIGN, NC_attr::xsz, and NC_attr::xvalue. Referenced by v1h_get_NC_attr(). { int status; const size_t perchunk = gsp->extent; size_t remaining = attrp->xsz; void *value = attrp->xvalue; size_t nget; assert(gsp->extent % X_ALIGN == 0); do { nget = MIN(perchunk, remaining); status = check_v1hs(gsp, nget); if(status != ENOERR) return status; (void) memcpy(value, gsp->pos, nget); gsp->pos = (void *)((char *)gsp->pos + nget); value = (void *)((char *)value + nget); remaining -= nget; } while(remaining != 0); return ENOERR; }

static int v1h_get_NC_dim (  v1hs *  gsp, NC_dim **  dimpp )  [static]

Definition at line 360 of file v1hpg.c. References ENOERR, free_NC_dim(), free_NC_string(), NC_ENOMEM, new_x_NC_dim(), NC_dim::size, v1h_get_NC_string(), and v1h_get_size_t(). Referenced by v1h_get_NC_dimarray(). { int status; NC_string *ncstrp; NC_dim *dimp; status = v1h_get_NC_string(gsp, &ncstrp); if(status != ENOERR) return status; dimp = new_x_NC_dim(ncstrp); if(dimp == NULL) { status = NC_ENOMEM; goto unwind_name; } status = v1h_get_size_t(gsp, &dimp->size); if(status != ENOERR) { free_NC_dim(dimp); /* frees name */ return status; } *dimpp = dimp; return ENOERR; unwind_name: free_NC_string(ncstrp); return status; }

static int v1h_get_NC_dimarray (  v1hs *  gsp, NC_dimarray *  ncap )  [static]

Definition at line 469 of file v1hpg.c. References ENOERR, free_NC_dimarrayV(), NC_dimarray::nalloc, NC_DIMENSION, NC_ENOMEM, NC_UNSPECIFIED, NC_dimarray::nelems, v1hs::pos, type, v1h_get_NC_dim(), v1h_get_NCtype(), v1h_get_size_t(), and NC_dimarray::value. Referenced by nc_get_NC(). { int status; NCtype type = NC_UNSPECIFIED; assert(gsp != NULL && gsp->pos != NULL); assert(ncap != NULL); assert(ncap->value == NULL); status = v1h_get_NCtype(gsp, &type); if(status != ENOERR) return status; status = v1h_get_size_t(gsp, &ncap->nelems); if(status != ENOERR) return status; if(ncap->nelems == 0) return ENOERR; /* else */ if(type != NC_DIMENSION) return EINVAL; ncap->value = (NC_dim **) malloc(ncap->nelems * sizeof(NC_dim *)); if(ncap->value == NULL) return NC_ENOMEM; ncap->nalloc = ncap->nelems; { NC_dim **dpp = ncap->value; NC_dim *const *const end = &dpp[ncap->nelems]; for( /*NADA*/; dpp < end; dpp++) { status = v1h_get_NC_dim(gsp, dpp); if(status) { ncap->nelems = (size_t)(dpp - ncap->value); free_NC_dimarrayV(ncap); return status; } } } return ENOERR; }

static int v1h_get_NC_string (  v1hs *  gsp, NC_string **  ncstrpp )  [static]

Definition at line 278 of file v1hpg.c. References _RNDUP, check_v1hs(), NC_string::cp, ENOERR, free_NC_string(), NC_ENOMEM, NC_string::nchars, ncx_pad_getn_text(), new_NC_string(), v1hs::pos, v1h_get_size_t(), and X_ALIGN. Referenced by v1h_get_NC_attr(), v1h_get_NC_dim(), and v1h_get_NC_var(). { int status; size_t nchars = 0; NC_string *ncstrp; status = v1h_get_size_t(gsp, &nchars); if(status != ENOERR) return status; ncstrp = new_NC_string(nchars, NULL); if(ncstrp == NULL) { return NC_ENOMEM; } #if 0 /* assert(ncstrp->nchars == nchars || ncstrp->nchars - nchars < X_ALIGN); */ assert(ncstrp->nchars % X_ALIGN == 0); status = check_v1hs(gsp, ncstrp->nchars); #else status = check_v1hs(gsp, _RNDUP(ncstrp->nchars, X_ALIGN)); #endif if(status != ENOERR) goto unwind_alloc; status = ncx_pad_getn_text((const void **)(&gsp->pos), nchars, ncstrp->cp); if(status != ENOERR) goto unwind_alloc; *ncstrpp = ncstrp; return ENOERR; unwind_alloc: free_NC_string(ncstrp); return status; }

static int v1h_get_nc_type (  v1hs *  gsp, nc_type *  typep )  [static]

Definition at line 169 of file v1hpg.c. References check_v1hs(), ENOERR, NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, NC_SHORT, ncx_get_int_int(), v1hs::pos, type, and X_SIZEOF_INT. Referenced by v1h_get_NC_attr(), and v1h_get_NC_var(). { int type = 0; int status = check_v1hs(gsp, X_SIZEOF_INT); if(status != ENOERR) return status; status = ncx_get_int_int(gsp->pos, &type); gsp->pos = (void *)((char *)gsp->pos + X_SIZEOF_INT); if(status != ENOERR) return status; assert(type == NC_BYTE || type == NC_CHAR || type == NC_SHORT || type == NC_INT || type == NC_FLOAT || type == NC_DOUBLE); /* else */ *typep = (nc_type) type; return ENOERR; }

static int v1h_get_NC_var (  v1hs *  gsp, NC_var **  varpp )  [static]

Definition at line 876 of file v1hpg.c. References NC_var::attrs, NC_var::begin, check_v1hs(), NC_var::dimids, ENOERR, free_NC_string(), free_NC_var(), NC_var::len, NC_ENOMEM, ncx_get_off_t(), ncx_getn_int_int(), ncx_len_int, ndims, new_x_NC_var(), v1hs::pos, NC_var::type, v1h_get_NC_attrarray(), v1h_get_NC_string(), v1h_get_nc_type(), v1h_get_size_t(), and v1hs::version. Referenced by v1h_get_NC_vararray(). { NC_string *strp; int status; size_t ndims; NC_var *varp; status = v1h_get_NC_string(gsp, &strp); if(status != ENOERR) return status; status = v1h_get_size_t(gsp, &ndims); if(status != ENOERR) goto unwind_name; varp = new_x_NC_var(strp, ndims); if(varp == NULL) { status = NC_ENOMEM; goto unwind_name; } status = check_v1hs(gsp, ncx_len_int(ndims)); if(status != ENOERR) goto unwind_alloc; status = ncx_getn_int_int((const void **)(&gsp->pos), ndims, varp->dimids); if(status != ENOERR) goto unwind_alloc; status = v1h_get_NC_attrarray(gsp, &varp->attrs); if(status != ENOERR) goto unwind_alloc; status = v1h_get_nc_type(gsp, &varp->type); if(status != ENOERR) goto unwind_alloc; status = v1h_get_size_t(gsp, &varp->len); if(status != ENOERR) goto unwind_alloc; status = check_v1hs(gsp, gsp->version == 1 ? 4 : 8); if(status != ENOERR) goto unwind_alloc; status = ncx_get_off_t((const void **)&gsp->pos, &varp->begin, gsp->version == 1 ? 4 : 8); if(status != ENOERR) goto unwind_alloc; *varpp = varp; return ENOERR; unwind_alloc: free_NC_var(varp); /* frees name */ return status; unwind_name: free_NC_string(strp); return status; }

static int v1h_get_NC_vararray (  v1hs *  gsp, NC_vararray *  ncap )  [static]

Definition at line 1014 of file v1hpg.c. References ENOERR, free_NC_vararrayV(), NC_vararray::nalloc, NC_ENOMEM, NC_UNSPECIFIED, NC_VARIABLE, NC_vararray::nelems, v1hs::pos, type, v1h_get_NC_var(), v1h_get_NCtype(), v1h_get_size_t(), and NC_vararray::value. Referenced by nc_get_NC(). { int status; NCtype type = NC_UNSPECIFIED; assert(gsp != NULL && gsp->pos != NULL); assert(ncap != NULL); assert(ncap->value == NULL); status = v1h_get_NCtype(gsp, &type); if(status != ENOERR) return status; status = v1h_get_size_t(gsp, &ncap->nelems); if(status != ENOERR) return status; if(ncap->nelems == 0) return ENOERR; /* else */ if(type != NC_VARIABLE) return EINVAL; ncap->value = (NC_var **) malloc(ncap->nelems * sizeof(NC_var *)); if(ncap->value == NULL) return NC_ENOMEM; ncap->nalloc = ncap->nelems; { NC_var **vpp = ncap->value; NC_var *const *const end = &vpp[ncap->nelems]; for( /*NADA*/; vpp < end; vpp++) { status = v1h_get_NC_var(gsp, vpp); if(status) { ncap->nelems = (size_t)(vpp - ncap->value); free_NC_vararrayV(ncap); return status; } } } return ENOERR; }

static int v1h_get_NCtype (  v1hs *  gsp, NCtype *  typep )  [static]

Definition at line 211 of file v1hpg.c. References check_v1hs(), ENOERR, ncx_get_int_int(), v1hs::pos, type, and X_SIZEOF_INT. Referenced by v1h_get_NC_attrarray(), v1h_get_NC_dimarray(), and v1h_get_NC_vararray(). { int type = 0; int status = check_v1hs(gsp, X_SIZEOF_INT); if(status != ENOERR) return status; status = ncx_get_int_int(gsp->pos, &type); gsp->pos = (void *)((char *)gsp->pos + X_SIZEOF_INT); if(status != ENOERR) return status; /* else */ *typep = (NCtype) type; return ENOERR; }

static int v1h_get_size_t (  v1hs *  gsp, size_t *  sp )  [static]

Definition at line 142 of file v1hpg.c. References check_v1hs(), ENOERR, ncx_get_size_t(), v1hs::pos, and X_SIZEOF_SIZE_T. Referenced by v1h_get_NC_attr(), v1h_get_NC_attrarray(), v1h_get_NC_dim(), v1h_get_NC_dimarray(), v1h_get_NC_string(), v1h_get_NC_var(), and v1h_get_NC_vararray(). { int status = check_v1hs(gsp, X_SIZEOF_SIZE_T); if(status != ENOERR) return status; return ncx_get_size_t((const void **)(&gsp->pos), sp); }

static int v1h_put_NC_attr (  v1hs *  psp, const NC_attr *  attrp )  [static]

Definition at line 579 of file v1hpg.c. References ENOERR, NC_attr::name, NC_attr::nelems, NC_attr::type, v1h_put_NC_attrV(), v1h_put_NC_string(), v1h_put_nc_type(), and v1h_put_size_t(). Referenced by v1h_put_NC_attrarray(). { int status; status = v1h_put_NC_string(psp, attrp->name); if(status != ENOERR) return status; status = v1h_put_nc_type(psp, &attrp->type); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &attrp->nelems); if(status != ENOERR) return status; status = v1h_put_NC_attrV(psp, attrp); if(status != ENOERR) return status; return ENOERR; }

static int v1h_put_NC_attrarray (  v1hs *  psp, const NC_attrarray *  ncap )  [static]

Definition at line 704 of file v1hpg.c. References ENOERR, NC_ATTRIBUTE, NC_UNSPECIFIED, NC_attrarray::nelems, v1h_put_NC_attr(), v1h_put_NCtype(), v1h_put_size_t(), and NC_attrarray::value. Referenced by ncx_put_NC(), and v1h_put_NC_var(). { int status; assert(psp != NULL); if(ncap == NULL #if 1 /* Backward: * This clause is for 'byte for byte' * backward compatibility. * Strickly speaking, it is 'bug for bug'. */ || ncap->nelems == 0 #endif ) { /* * Handle empty netcdf */ const size_t nosz = 0; status = v1h_put_NCtype(psp, NC_UNSPECIFIED); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &nosz); if(status != ENOERR) return status; return ENOERR; } /* else */ status = v1h_put_NCtype(psp, NC_ATTRIBUTE); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &ncap->nelems); if(status != ENOERR) return status; { const NC_attr **app = (const NC_attr **)ncap->value; const NC_attr *const *const end = &app[ncap->nelems]; for( /*NADA*/; app < end; app++) { status = v1h_put_NC_attr(psp, *app); if(status) return status; } } return ENOERR; }

static int v1h_put_NC_attrV (  v1hs *  psp, const NC_attr *  attrp )  [static]

Definition at line 550 of file v1hpg.c. References check_v1hs(), ENOERR, v1hs::extent, MIN, v1hs::pos, X_ALIGN, NC_attr::xsz, and NC_attr::xvalue. Referenced by v1h_put_NC_attr(). { int status; const size_t perchunk = psp->extent; size_t remaining = attrp->xsz; void *value = attrp->xvalue; size_t nbytes; assert(psp->extent % X_ALIGN == 0); do { nbytes = MIN(perchunk, remaining); status = check_v1hs(psp, nbytes); if(status != ENOERR) return status; (void) memcpy(psp->pos, value, nbytes); psp->pos = (void *)((char *)psp->pos + nbytes); value = (void *)((char *)value + nbytes); remaining -= nbytes; } while(remaining != 0); return ENOERR; }

static int v1h_put_NC_dim (  v1hs *  psp, const NC_dim *  dimp )  [static]

Definition at line 344 of file v1hpg.c. References ENOERR, NC_dim::name, NC_dim::size, v1h_put_NC_string(), and v1h_put_size_t(). Referenced by v1h_put_NC_dimarray(). { int status; status = v1h_put_NC_string(psp, dimp->name); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &dimp->size); if(status != ENOERR) return status; return ENOERR; }

static int v1h_put_NC_dimarray (  v1hs *  psp, const NC_dimarray *  ncap )  [static]

Definition at line 415 of file v1hpg.c. References ENOERR, NC_DIMENSION, NC_UNSPECIFIED, NC_dimarray::nelems, v1h_put_NC_dim(), v1h_put_NCtype(), v1h_put_size_t(), and NC_dimarray::value. Referenced by ncx_put_NC(). { int status; assert(psp != NULL); if(ncap == NULL #if 1 /* Backward: * This clause is for 'byte for byte' * backward compatibility. * Strickly speaking, it is 'bug for bug'. */ || ncap->nelems == 0 #endif ) { /* * Handle empty netcdf */ const size_t nosz = 0; status = v1h_put_NCtype(psp, NC_UNSPECIFIED); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &nosz); if(status != ENOERR) return status; return ENOERR; } /* else */ status = v1h_put_NCtype(psp, NC_DIMENSION); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &ncap->nelems); if(status != ENOERR) return status; { const NC_dim **dpp = (const NC_dim **)ncap->value; const NC_dim *const *const end = &dpp[ncap->nelems]; for( /*NADA*/; dpp < end; dpp++) { status = v1h_put_NC_dim(psp, *dpp); if(status) return status; } } return ENOERR; }

static int v1h_put_NC_string (  v1hs *  psp, const NC_string *  ncstrp )  [static]

Definition at line 255 of file v1hpg.c. References _RNDUP, check_v1hs(), NC_string::cp, ENOERR, NC_string::nchars, ncx_pad_putn_text(), v1hs::pos, v1h_put_size_t(), and X_ALIGN. Referenced by v1h_put_NC_attr(), v1h_put_NC_dim(), and v1h_put_NC_var(). { int status; #if 0 assert(ncstrp->nchars % X_ALIGN == 0); #endif status = v1h_put_size_t(psp, &ncstrp->nchars); if(status != ENOERR) return status; status = check_v1hs(psp, _RNDUP(ncstrp->nchars, X_ALIGN)); if(status != ENOERR) return status; status = ncx_pad_putn_text(&psp->pos, ncstrp->nchars, ncstrp->cp); if(status != ENOERR) return status; return ENOERR; }

static int v1h_put_nc_type (  v1hs *  psp, const nc_type *  typep )  [static]

Definition at line 156 of file v1hpg.c. References check_v1hs(), ENOERR, ncx_put_int_int(), v1hs::pos, and X_SIZEOF_INT. Referenced by v1h_put_NC_attr(), and v1h_put_NC_var(). { const int itype = (int) *typep; int status = check_v1hs(psp, X_SIZEOF_INT); if(status != ENOERR) return status; status = ncx_put_int_int(psp->pos, &itype); psp->pos = (void *)((char *)psp->pos + X_SIZEOF_INT); return status; }

static int v1h_put_NC_var (  v1hs *  psp, const NC_var *  varp )  [static]

Definition at line 832 of file v1hpg.c. References NC_var::attrs, NC_var::begin, check_v1hs(), NC_var::dimids, ENOERR, NC_var::len, NC_var::name, ncx_len_int, ncx_put_off_t(), ncx_putn_int_int(), NC_var::ndims, v1hs::pos, NC_var::type, v1h_put_NC_attrarray(), v1h_put_NC_string(), v1h_put_nc_type(), v1h_put_size_t(), and v1hs::version. Referenced by v1h_put_NC_vararray(). { int status; status = v1h_put_NC_string(psp, varp->name); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &varp->ndims); if(status != ENOERR) return status; status = check_v1hs(psp, ncx_len_int(varp->ndims)); if(status != ENOERR) return status; status = ncx_putn_int_int(&psp->pos, varp->ndims, varp->dimids); if(status != ENOERR) return status; status = v1h_put_NC_attrarray(psp, &varp->attrs); if(status != ENOERR) return status; status = v1h_put_nc_type(psp, &varp->type); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &varp->len); if(status != ENOERR) return status; status = check_v1hs(psp, psp->version == 1 ? 4 : 8); if(status != ENOERR) return status; status = ncx_put_off_t(&psp->pos, &varp->begin, psp->version == 1 ? 4 : 8); if(status != ENOERR) return status; return ENOERR; }

static int v1h_put_NC_vararray (  v1hs *  psp, const NC_vararray *  ncap )  [static]

Definition at line 960 of file v1hpg.c. References ENOERR, NC_UNSPECIFIED, NC_VARIABLE, NC_vararray::nelems, v1h_put_NC_var(), v1h_put_NCtype(), v1h_put_size_t(), and NC_vararray::value. Referenced by ncx_put_NC(). { int status; assert(psp != NULL); if(ncap == NULL #if 1 /* Backward: * This clause is for 'byte for byte' * backward compatibility. * Strickly speaking, it is 'bug for bug'. */ || ncap->nelems == 0 #endif ) { /* * Handle empty netcdf */ const size_t nosz = 0; status = v1h_put_NCtype(psp, NC_UNSPECIFIED); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &nosz); if(status != ENOERR) return status; return ENOERR; } /* else */ status = v1h_put_NCtype(psp, NC_VARIABLE); if(status != ENOERR) return status; status = v1h_put_size_t(psp, &ncap->nelems); if(status != ENOERR) return status; { const NC_var **vpp = (const NC_var **)ncap->value; const NC_var *const *const end = &vpp[ncap->nelems]; for( /*NADA*/; vpp < end; vpp++) { status = v1h_put_NC_var(psp, *vpp); if(status) return status; } } return ENOERR; }

static int v1h_put_NCtype (  v1hs *  psp, NCtype  type )  [static]

Definition at line 199 of file v1hpg.c. References check_v1hs(), ENOERR, ncx_put_int_int(), v1hs::pos, and X_SIZEOF_INT. Referenced by v1h_put_NC_attrarray(), v1h_put_NC_dimarray(), and v1h_put_NC_vararray(). { const int itype = (int) type; int status = check_v1hs(psp, X_SIZEOF_INT); if(status != ENOERR) return status; status = ncx_put_int_int(psp->pos, &itype); psp->pos = (void *)((char *)psp->pos + X_SIZEOF_INT); return status; }

static int v1h_put_size_t (  v1hs *  psp, const size_t *  sp )  [static]

Definition at line 132 of file v1hpg.c. References check_v1hs(), ENOERR, ncx_put_size_t(), v1hs::pos, and X_SIZEOF_SIZE_T. Referenced by v1h_put_NC_attr(), v1h_put_NC_attrarray(), v1h_put_NC_dim(), v1h_put_NC_dimarray(), v1h_put_NC_string(), v1h_put_NC_var(), and v1h_put_NC_vararray(). { int status = check_v1hs(psp, X_SIZEOF_SIZE_T); if(status != ENOERR) return status; return ncx_put_size_t(&psp->pos, sp); }

---

Variable Documentation

const schar ncmagic[] = {'C', 'D', 'F', 0x02} [static]

Definition at line 34 of file v1hpg.c. Referenced by nc_get_NC(), ncx_len_NC(), and ncx_put_NC().

const schar ncmagic1[] = {'C', 'D', 'F', 0x01} [static]

Definition at line 35 of file v1hpg.c. Referenced by ncx_put_NC().

---