/* Do not edit this file. It is produced from the corresponding .m4 source */ /* * Copyright 1996, University Corporation for Atmospheric Research * See netcdf/COPYRIGHT file for copying and redistribution conditions. */ /* $Id: putget.m4,v 2.63 2008/06/10 19:26:39 russ Exp $ */ #include "nc.h" #include #include #include #include "ncx.h" #include "fbits.h" #include "onstack.h" #ifdef LOCKNUMREC # include /* for SGI/Cray SHMEM routines */ # ifdef LN_TEST # include # endif #endif #undef MIN /* system may define MIN somewhere and complain */ #define MIN(mm,nn) (((mm) < (nn)) ? (mm) : (nn)) /* #define ODEBUG 1 */ #if ODEBUG #include /* * Print the values of an array of size_t */ void arrayp(const char *label, size_t count, const size_t *array) { (void) fprintf(stderr, "%s", label); (void) fputc('\t',stderr); for(; count > 0; count--, array++) (void) fprintf(stderr," %lu", (unsigned long)*array); (void) fputc('\n',stderr); } #endif /* ODEBUG */ /* * 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)); default: return -1; } } /* Begin fill */ /* * This is tunable parameter. * It essentially controls the tradeoff between the number of times * memcpy() gets called to copy the external data to fill * a large buffer vs the number of times its called to * prepare the external data. */ #if _SX /* NEC SX specific optimization */ #define NFILL 2048 #else #define NFILL 16 #endif /* * Next 6 type specific functions * Fill a some memory with the default special value. * Formerly NC_arrayfill() */ static int NC_fill_schar( void **xpp, size_t nelems) /* how many */ { schar fillp[NFILL * sizeof(double)/X_SIZEOF_CHAR]; assert(nelems <= sizeof(fillp)/sizeof(fillp[0])); { schar *vp = fillp; /* lower bound of area to be filled */ const schar *const end = vp + nelems; while(vp < end) { *vp++ = NC_FILL_BYTE; } } return ncx_putn_schar_schar(xpp, nelems, fillp); } static int NC_fill_char( void **xpp, size_t nelems) /* how many */ { char fillp[NFILL * sizeof(double)/X_SIZEOF_CHAR]; assert(nelems <= sizeof(fillp)/sizeof(fillp[0])); { char *vp = fillp; /* lower bound of area to be filled */ const char *const end = vp + nelems; while(vp < end) { *vp++ = NC_FILL_CHAR; } } return ncx_putn_char_char(xpp, nelems, fillp); } static int NC_fill_short( void **xpp, size_t nelems) /* how many */ { short fillp[NFILL * sizeof(double)/X_SIZEOF_SHORT]; assert(nelems <= sizeof(fillp)/sizeof(fillp[0])); { short *vp = fillp; /* lower bound of area to be filled */ const short *const end = vp + nelems; while(vp < end) { *vp++ = NC_FILL_SHORT; } } return ncx_putn_short_short(xpp, nelems, fillp); } #if (SIZEOF_INT >= X_SIZEOF_INT) static int NC_fill_int( void **xpp, size_t nelems) /* how many */ { int fillp[NFILL * sizeof(double)/X_SIZEOF_INT]; assert(nelems <= sizeof(fillp)/sizeof(fillp[0])); { int *vp = fillp; /* lower bound of area to be filled */ const int *const end = vp + nelems; while(vp < end) { *vp++ = NC_FILL_INT; } } return ncx_putn_int_int(xpp, nelems, fillp); } #elif SIZEOF_LONG == X_SIZEOF_INT static int NC_fill_int( void **xpp, size_t nelems) /* how many */ { long fillp[NFILL * sizeof(double)/X_SIZEOF_INT]; assert(nelems <= sizeof(fillp)/sizeof(fillp[0])); { long *vp = fillp; /* lower bound of area to be filled */ const long *const end = vp + nelems; while(vp < end) { *vp++ = NC_FILL_INT; } } return ncx_putn_int_long(xpp, nelems, fillp); } #else #error "NC_fill_int implementation" #endif static int NC_fill_float( void **xpp, size_t nelems) /* how many */ { float fillp[NFILL * sizeof(double)/X_SIZEOF_FLOAT]; assert(nelems <= sizeof(fillp)/sizeof(fillp[0])); { float *vp = fillp; /* lower bound of area to be filled */ const float *const end = vp + nelems; while(vp < end) { *vp++ = NC_FILL_FLOAT; } } return ncx_putn_float_float(xpp, nelems, fillp); } static int NC_fill_double( void **xpp, size_t nelems) /* how many */ { double fillp[NFILL * sizeof(double)/X_SIZEOF_DOUBLE]; assert(nelems <= sizeof(fillp)/sizeof(fillp[0])); { double *vp = fillp; /* lower bound of area to be filled */ const double *const end = vp + nelems; while(vp < end) { *vp++ = NC_FILL_DOUBLE; } } return ncx_putn_double_double(xpp, nelems, fillp); } /* * Fill the external space for variable 'varp' values at 'recno' with * the appropriate value. If 'varp' is not a record variable, fill the * whole thing. For the special case when 'varp' is the only record * variable and it is of type byte, char, or short, varsize should be * ncp->recsize, otherwise it should be varp->len. * Formerly xdr_NC_fill() */ int fill_NC_var(NC *ncp, const NC_var *varp, size_t varsize, size_t recno) { char xfillp[NFILL * X_SIZEOF_DOUBLE]; const size_t step = varp->xsz; const size_t nelems = sizeof(xfillp)/step; const size_t xsz = varp->xsz * nelems; NC_attr **attrpp = NULL; off_t offset; size_t remaining = varsize; void *xp; int status = NC_NOERR; /* * Set up fill value */ attrpp = NC_findattr(&varp->attrs, _FillValue); if( attrpp != NULL ) { /* User defined fill value */ if( (*attrpp)->type != varp->type || (*attrpp)->nelems != 1 ) { return NC_EBADTYPE; } else { /* Use the user defined value */ char *cp = xfillp; const char *const end = &xfillp[sizeof(xfillp)]; assert(step <= (*attrpp)->xsz); for( /*NADA*/; cp < end; cp += step) { (void) memcpy(cp, (*attrpp)->xvalue, step); } } } else { /* use the default */ assert(xsz % X_ALIGN == 0); assert(xsz <= sizeof(xfillp)); xp = xfillp; switch(varp->type){ case NC_BYTE : status = NC_fill_schar(&xp, nelems); break; case NC_CHAR : status = NC_fill_char(&xp, nelems); break; case NC_SHORT : status = NC_fill_short(&xp, nelems); break; case NC_INT : status = NC_fill_int(&xp, nelems); break; case NC_FLOAT : status = NC_fill_float(&xp, nelems); break; case NC_DOUBLE : status = NC_fill_double(&xp, nelems); break; default : assert("fill_NC_var invalid type" == 0); status = NC_EBADTYPE; break; } if(status != NC_NOERR) return status; assert(xp == xfillp + xsz); } /* * copyout: * xfillp now contains 'nelems' elements of the fill value * in external representation. */ /* * Copy it out. */ offset = varp->begin; if(IS_RECVAR(varp)) { offset += (off_t)ncp->recsize * recno; } assert(remaining > 0); for(;;) { const size_t chunksz = MIN(remaining, ncp->chunk); size_t ii; status = ncp->nciop->get(ncp->nciop, offset, chunksz, RGN_WRITE, &xp); if(status != NC_NOERR) { return status; } /* * fill the chunksz buffer in units of xsz */ for(ii = 0; ii < chunksz/xsz; ii++) { (void) memcpy(xp, xfillp, xsz); xp = (char *)xp + xsz; } /* * Deal with any remainder */ { const size_t rem = chunksz % xsz; if(rem != 0) { (void) memcpy(xp, xfillp, rem); /* xp = (char *)xp + xsz; */ } } status = ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); if(status != NC_NOERR) { break; } remaining -= chunksz; if(remaining == 0) break; /* normal loop exit */ offset += chunksz; } return status; } /* End fill */ /* * Add a record containing the fill values. */ static int NCfillrecord(NC *ncp, const NC_var *const *varpp, size_t recno) { size_t ii = 0; for(; ii < ncp->vars.nelems; ii++, varpp++) { if( !IS_RECVAR(*varpp) ) { continue; /* skip non-record variables */ } { const int status = fill_NC_var(ncp, *varpp, (*varpp)->len, recno); if(status != NC_NOERR) return status; } } return NC_NOERR; } /* * Add a record containing the fill values in the special case when * there is exactly one record variable, where we don't require each * record to be four-byte aligned (no record padding). */ static int NCfillspecialrecord(NC *ncp, const NC_var *varp, size_t recno) { int status; assert(IS_RECVAR(varp)); status = fill_NC_var(ncp, varp, ncp->recsize, recno); if(status != NC_NOERR) return status; return NC_NOERR; } /* * It is advantageous to * #define TOUCH_LAST * when using memory mapped io. */ #if TOUCH_LAST /* * Grow the file to a size which can contain recno */ static int NCtouchlast(NC *ncp, const NC_var *const *varpp, size_t recno) { int status = NC_NOERR; const NC_var *varp = NULL; { size_t ii = 0; for(; ii < ncp->vars.nelems; ii++, varpp++) { if( !IS_RECVAR(*varpp) ) { continue; /* skip non-record variables */ } varp = *varpp; } } assert(varp != NULL); assert( IS_RECVAR(varp) ); { const off_t offset = varp->begin + (off_t)(recno-1) * (off_t)ncp->recsize + (off_t)(varp->len - varp->xsz); void *xp; status = ncp->nciop->get(ncp->nciop, offset, varp->xsz, RGN_WRITE, &xp); if(status != NC_NOERR) return status; (void)memset(xp, 0, varp->xsz); status = ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); } return status; } #endif /* TOUCH_LAST */ /* * Ensure that the netcdf file has 'numrecs' records, * add records and fill as neccessary. */ static int NCvnrecs(NC *ncp, size_t numrecs) { int status = NC_NOERR; #ifdef LOCKNUMREC ushmem_t myticket = 0, nowserving = 0; ushmem_t numpe = (ushmem_t) _num_pes(); /* get ticket and wait */ myticket = shmem_short_finc((shmem_t *) ncp->lock + LOCKNUMREC_LOCK, ncp->lock[LOCKNUMREC_BASEPE]); #ifdef LN_TEST fprintf(stderr,"%d of %d : ticket = %hu\n", _my_pe(), _num_pes(), myticket); #endif do { shmem_short_get((shmem_t *) &nowserving, (shmem_t *) ncp->lock + LOCKNUMREC_SERVING, 1, ncp->lock[LOCKNUMREC_BASEPE]); #ifdef LN_TEST fprintf(stderr,"%d of %d : serving = %hu\n", _my_pe(), _num_pes(), nowserving); #endif /* work-around for non-unique tickets */ if (nowserving > myticket && nowserving < myticket + numpe ) { /* get a new ticket ... you've been bypassed */ /* and handle the unlikely wrap-around effect */ myticket = shmem_short_finc( (shmem_t *) ncp->lock + LOCKNUMREC_LOCK, ncp->lock[LOCKNUMREC_BASEPE]); #ifdef LN_TEST fprintf(stderr,"%d of %d : new ticket = %hu\n", _my_pe(), _num_pes(), myticket); #endif } } while(nowserving != myticket); /* now our turn to check & update value */ #endif if(numrecs > NC_get_numrecs(ncp)) { #if TOUCH_LAST status = NCtouchlast(ncp, (const NC_var *const*)ncp->vars.value, numrecs); if(status != NC_NOERR) goto common_return; #endif /* TOUCH_LAST */ set_NC_ndirty(ncp); if(!NC_dofill(ncp)) { /* Simply set the new numrecs value */ NC_set_numrecs(ncp, numrecs); } else { /* Treat two cases differently: - exactly one record variable (no padding) - multiple record variables (each record padded to 4-byte alignment) */ NC_var **vpp = (NC_var **)ncp->vars.value; NC_var *const *const end = &vpp[ncp->vars.nelems]; NC_var *recvarp = NULL; /* last record var */ int numrecvars = 0; size_t cur_nrecs; /* determine how many record variables */ for( /*NADA*/; vpp < end; vpp++) { if(IS_RECVAR(*vpp)) { recvarp = *vpp; numrecvars++; } } if (numrecvars != 1) { /* usual case */ /* Fill each record out to numrecs */ while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs) { status = NCfillrecord(ncp, (const NC_var *const*)ncp->vars.value, cur_nrecs); if(status != NC_NOERR) { break; } NC_increase_numrecs(ncp, cur_nrecs +1); } if(status != NC_NOERR) goto common_return; } else { /* special case */ /* Fill each record out to numrecs */ while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs) { status = NCfillspecialrecord(ncp, recvarp, cur_nrecs); if(status != NC_NOERR) { break; } NC_increase_numrecs(ncp, cur_nrecs +1); } if(status != NC_NOERR) goto common_return; } } if(NC_doNsync(ncp)) { status = write_numrecs(ncp); } } common_return: #ifdef LOCKNUMREC /* finished with our lock - increment serving number */ (void) shmem_short_finc((shmem_t *) ncp->lock + LOCKNUMREC_SERVING, ncp->lock[LOCKNUMREC_BASEPE]); #endif return status; } /* * Check whether 'coord' values are valid for the variable. */ static int NCcoordck(NC *ncp, const NC_var *varp, const size_t *coord) { const size_t *ip; size_t *up; if(varp->ndims == 0) return NC_NOERR; /* 'scalar' variable */ if(IS_RECVAR(varp)) { if(*coord > X_INT_MAX) return NC_EINVALCOORDS; /* sanity check */ if(NC_readonly(ncp) && *coord >= NC_get_numrecs(ncp)) { if(!NC_doNsync(ncp)) return NC_EINVALCOORDS; /* else */ { /* Update from disk and check again */ const int status = read_numrecs(ncp); if(status != NC_NOERR) return status; if(*coord >= NC_get_numrecs(ncp)) return NC_EINVALCOORDS; } } ip = coord + 1; up = varp->shape + 1; } else { ip = coord; up = varp->shape; } #ifdef CDEBUG fprintf(stderr," NCcoordck: coord %ld, count %d, ip %ld\n", coord, varp->ndims, ip ); #endif /* CDEBUG */ for(; ip < coord + varp->ndims; ip++, up++) { #ifdef CDEBUG fprintf(stderr," NCcoordck: ip %p, *ip %ld, up %p, *up %lu\n", ip, *ip, up, *up ); #endif /* CDEBUG */ /* cast needed for braindead systems with signed size_t */ if((unsigned long) *ip >= (unsigned long) *up ) return NC_EINVALCOORDS; } return NC_NOERR; } /* * Check whether 'edges' are valid for the variable and 'start' */ /*ARGSUSED*/ static int NCedgeck(const NC *ncp, const NC_var *varp, const size_t *start, const size_t *edges) { const size_t *const end = start + varp->ndims; const size_t *shp = varp->shape; if(varp->ndims == 0) return NC_NOERR; /* 'scalar' variable */ if(IS_RECVAR(varp)) { start++; edges++; shp++; } for(; start < end; start++, edges++, shp++) { /* cast needed for braindead systems with signed size_t */ if((unsigned long) *edges > *shp || (unsigned long) *start + (unsigned long) *edges > *shp) { return(NC_EEDGE); } } return NC_NOERR; } /* * Translate the (variable, coord) pair into a seek index */ static off_t NC_varoffset(const NC *ncp, const NC_var *varp, const size_t *coord) { if(varp->ndims == 0) /* 'scalar' variable */ return varp->begin; if(varp->ndims == 1) { if(IS_RECVAR(varp)) return varp->begin + (off_t)(*coord) * (off_t)ncp->recsize; /* else */ return varp->begin + (off_t)(*coord) * (off_t)varp->xsz; } /* else */ { off_t lcoord = (off_t)coord[varp->ndims -1]; size_t *up = varp->dsizes +1; const size_t *ip = coord; const size_t *const end = varp->dsizes + varp->ndims; if(IS_RECVAR(varp)) up++, ip++; for(; up < end; up++, ip++) lcoord += *up * *ip; lcoord *= varp->xsz; if(IS_RECVAR(varp)) lcoord += (off_t)(*coord) * ncp->recsize; lcoord += varp->begin; return lcoord; } } static int putNCvx_char_char(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const char *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_char_char(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_schar_schar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_schar_schar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_schar_uchar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_schar_uchar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_schar_short(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_schar_short(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_schar_int(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_schar_int(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_schar_long(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_schar_long(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_schar_float(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_schar_float(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_schar_double(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_schar_double(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_short_schar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_short_schar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_short_uchar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_short_uchar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_short_short(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_short_short(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_short_int(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_short_int(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_short_long(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_short_long(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_short_float(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_short_float(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_short_double(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_short_double(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_int_schar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_int_schar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_int_uchar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_int_uchar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_int_short(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_int_short(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_int_int(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_int_int(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_int_long(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_int_long(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_int_float(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_int_float(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_int_double(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_int_double(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_float_schar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_float_schar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_float_uchar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_float_uchar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_float_short(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_float_short(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_float_int(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_float_int(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_float_long(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_float_long(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_float_float(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_float_float(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_float_double(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_float_double(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_double_schar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_double_schar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_double_uchar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_double_uchar(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_double_short(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_double_short(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_double_int(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_double_int(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_double_long(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_double_long(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_double_float(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_double_float(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCvx_double_double(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nput = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, RGN_WRITE, &xp); if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_putn_double_double(&xp, nput, value); if(lstatus != NC_NOERR && status == NC_NOERR) { /* not fatal to the loop */ status = lstatus; } (void) ncp->nciop->rel(ncp->nciop, offset, RGN_MODIFIED); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nput; } return status; } static int putNCv_text(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const char *value) { if(varp->type != NC_CHAR) return NC_ECHAR; return putNCvx_char_char(ncp, varp, start, nelems, value); } static int putNCv_schar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const schar *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return putNCvx_schar_schar(ncp, varp, start, nelems, value); case NC_SHORT: return putNCvx_short_schar(ncp, varp, start, nelems, value); case NC_INT: return putNCvx_int_schar(ncp, varp, start, nelems, value); case NC_FLOAT: return putNCvx_float_schar(ncp, varp, start, nelems, value); case NC_DOUBLE: return putNCvx_double_schar(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int putNCv_uchar(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const uchar *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return putNCvx_schar_uchar(ncp, varp, start, nelems, value); case NC_SHORT: return putNCvx_short_uchar(ncp, varp, start, nelems, value); case NC_INT: return putNCvx_int_uchar(ncp, varp, start, nelems, value); case NC_FLOAT: return putNCvx_float_uchar(ncp, varp, start, nelems, value); case NC_DOUBLE: return putNCvx_double_uchar(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int putNCv_short(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const short *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return putNCvx_schar_short(ncp, varp, start, nelems, value); case NC_SHORT: return putNCvx_short_short(ncp, varp, start, nelems, value); case NC_INT: return putNCvx_int_short(ncp, varp, start, nelems, value); case NC_FLOAT: return putNCvx_float_short(ncp, varp, start, nelems, value); case NC_DOUBLE: return putNCvx_double_short(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int putNCv_int(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const int *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return putNCvx_schar_int(ncp, varp, start, nelems, value); case NC_SHORT: return putNCvx_short_int(ncp, varp, start, nelems, value); case NC_INT: return putNCvx_int_int(ncp, varp, start, nelems, value); case NC_FLOAT: return putNCvx_float_int(ncp, varp, start, nelems, value); case NC_DOUBLE: return putNCvx_double_int(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int putNCv_long(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const long *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return putNCvx_schar_long(ncp, varp, start, nelems, value); case NC_SHORT: return putNCvx_short_long(ncp, varp, start, nelems, value); case NC_INT: return putNCvx_int_long(ncp, varp, start, nelems, value); case NC_FLOAT: return putNCvx_float_long(ncp, varp, start, nelems, value); case NC_DOUBLE: return putNCvx_double_long(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int putNCv_float(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const float *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return putNCvx_schar_float(ncp, varp, start, nelems, value); case NC_SHORT: return putNCvx_short_float(ncp, varp, start, nelems, value); case NC_INT: return putNCvx_int_float(ncp, varp, start, nelems, value); case NC_FLOAT: return putNCvx_float_float(ncp, varp, start, nelems, value); case NC_DOUBLE: return putNCvx_double_float(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int putNCv_double(NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, const double *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return putNCvx_schar_double(ncp, varp, start, nelems, value); case NC_SHORT: return putNCvx_short_double(ncp, varp, start, nelems, value); case NC_INT: return putNCvx_int_double(ncp, varp, start, nelems, value); case NC_FLOAT: return putNCvx_float_double(ncp, varp, start, nelems, value); case NC_DOUBLE: return putNCvx_double_double(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCvx_char_char(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, char *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_char_char(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_schar_schar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_schar_schar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_schar_uchar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_schar_uchar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_schar_short(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_schar_short(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_schar_int(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_schar_int(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_schar_long(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_schar_long(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_schar_float(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_schar_float(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_schar_double(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_schar_double(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_short_schar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_short_schar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_short_uchar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_short_uchar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_short_short(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_short_short(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_short_int(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_short_int(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_short_long(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_short_long(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_short_float(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_short_float(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_short_double(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_short_double(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_int_schar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_int_schar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_int_uchar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_int_uchar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_int_short(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_int_short(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_int_int(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_int_int(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_int_long(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_int_long(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_int_float(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_int_float(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_int_double(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_int_double(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_float_schar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_float_schar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_float_uchar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_float_uchar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_float_short(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_float_short(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_float_int(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_float_int(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_float_long(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_float_long(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_float_float(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_float_float(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_float_double(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_float_double(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_double_schar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, schar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_double_schar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_double_uchar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, uchar *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_double_uchar(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_double_short(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, short *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_double_short(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_double_int(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, int *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_double_int(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_double_long(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, long *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_double_long(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_double_float(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, float *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_double_float(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCvx_double_double(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, double *value) { off_t offset = NC_varoffset(ncp, varp, start); size_t remaining = varp->xsz * nelems; int status = NC_NOERR; const void *xp; if(nelems == 0) return NC_NOERR; assert(value != NULL); for(;;) { size_t extent = MIN(remaining, ncp->chunk); size_t nget = ncx_howmany(varp->type, extent); int lstatus = ncp->nciop->get(ncp->nciop, offset, extent, 0, (void **)&xp); /* cast away const */ if(lstatus != NC_NOERR) return lstatus; lstatus = ncx_getn_double_double(&xp, nget, value); if(lstatus != NC_NOERR && status == NC_NOERR) status = lstatus; (void) ncp->nciop->rel(ncp->nciop, offset, 0); remaining -= extent; if(remaining == 0) break; /* normal loop exit */ offset += extent; value += nget; } return status; } static int getNCv_schar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, schar *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return getNCvx_schar_schar(ncp, varp, start, nelems, value); case NC_SHORT: return getNCvx_short_schar(ncp, varp, start, nelems, value); case NC_INT: return getNCvx_int_schar(ncp, varp, start, nelems, value); case NC_FLOAT: return getNCvx_float_schar(ncp, varp, start, nelems, value); case NC_DOUBLE: return getNCvx_double_schar(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCv_uchar(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, uchar *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return getNCvx_schar_uchar(ncp, varp, start, nelems, value); case NC_SHORT: return getNCvx_short_uchar(ncp, varp, start, nelems, value); case NC_INT: return getNCvx_int_uchar(ncp, varp, start, nelems, value); case NC_FLOAT: return getNCvx_float_uchar(ncp, varp, start, nelems, value); case NC_DOUBLE: return getNCvx_double_uchar(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCv_short(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, short *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return getNCvx_schar_short(ncp, varp, start, nelems, value); case NC_SHORT: return getNCvx_short_short(ncp, varp, start, nelems, value); case NC_INT: return getNCvx_int_short(ncp, varp, start, nelems, value); case NC_FLOAT: return getNCvx_float_short(ncp, varp, start, nelems, value); case NC_DOUBLE: return getNCvx_double_short(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCv_int(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, int *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return getNCvx_schar_int(ncp, varp, start, nelems, value); case NC_SHORT: return getNCvx_short_int(ncp, varp, start, nelems, value); case NC_INT: return getNCvx_int_int(ncp, varp, start, nelems, value); case NC_FLOAT: return getNCvx_float_int(ncp, varp, start, nelems, value); case NC_DOUBLE: return getNCvx_double_int(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCv_long(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, long *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return getNCvx_schar_long(ncp, varp, start, nelems, value); case NC_SHORT: return getNCvx_short_long(ncp, varp, start, nelems, value); case NC_INT: return getNCvx_int_long(ncp, varp, start, nelems, value); case NC_FLOAT: return getNCvx_float_long(ncp, varp, start, nelems, value); case NC_DOUBLE: return getNCvx_double_long(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCv_float(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, float *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return getNCvx_schar_float(ncp, varp, start, nelems, value); case NC_SHORT: return getNCvx_short_float(ncp, varp, start, nelems, value); case NC_INT: return getNCvx_int_float(ncp, varp, start, nelems, value); case NC_FLOAT: return getNCvx_float_float(ncp, varp, start, nelems, value); case NC_DOUBLE: return getNCvx_double_float(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCv_double(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, double *value) { switch(varp->type){ case NC_CHAR: return NC_ECHAR; case NC_BYTE: return getNCvx_schar_double(ncp, varp, start, nelems, value); case NC_SHORT: return getNCvx_short_double(ncp, varp, start, nelems, value); case NC_INT: return getNCvx_int_double(ncp, varp, start, nelems, value); case NC_FLOAT: return getNCvx_float_double(ncp, varp, start, nelems, value); case NC_DOUBLE: return getNCvx_double_double(ncp, varp, start, nelems, value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } static int getNCv_text(const NC *ncp, const NC_var *varp, const size_t *start, size_t nelems, char *value) { if(varp->type != NC_CHAR) return NC_ECHAR; return getNCvx_char_char(ncp, varp, start, nelems, value); } /* * Copy 'nbytes' contiguous external values * from ('inncp', invp', inncoord') * to ('outncp', 'outvp', 'outcoord') * 'inncp' shouldn't be the same as 'outncp'. * Used only by ncvarcopy() */ static int NCxvarcpy(NC *inncp, NC_var *invp, size_t *incoord, NC *outncp, NC_var *outvp, size_t *outcoord, size_t nbytes) { int status; off_t inoffset = NC_varoffset(inncp, invp, incoord); off_t outoffset = NC_varoffset(outncp, outvp, outcoord); void *inxp; void *outxp; const size_t chunk = MIN(inncp->chunk, outncp->chunk); do { const size_t extent = MIN(nbytes, chunk); status = inncp->nciop->get(inncp->nciop, inoffset, extent, 0, &inxp); if(status != NC_NOERR) return status; status = outncp->nciop->get(outncp->nciop, outoffset, extent, RGN_WRITE, &outxp); if(status != NC_NOERR) { (void) inncp->nciop->rel(inncp->nciop, inoffset, 0); break; } (void) memcpy(outxp, inxp, extent); status = outncp->nciop->rel(outncp->nciop, outoffset, RGN_MODIFIED); (void) inncp->nciop->rel(inncp->nciop, inoffset, 0); nbytes -= extent; if(nbytes == 0) break; /* normal loop exit */ inoffset += extent; outoffset += extent; } while (status == NC_NOERR); return status; } /* * For ncvar{put,get}, * find the largest contiguous block from within 'edges'. * returns the index to the left of this (which may be -1). * Compute the number of contiguous elements and return * that in *iocountp. * The presence of "record" variables makes this routine * overly subtle. */ static int NCiocount(const NC *const ncp, const NC_var *const varp, const size_t *const edges, size_t *const iocountp) { const size_t *edp0 = edges; const size_t *edp = edges + varp->ndims; const size_t *shp = varp->shape + varp->ndims; if(IS_RECVAR(varp)) { if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only 'record' variable */ *iocountp = *edges; return(0); } /* else */ edp0++; } assert(edges != NULL); /* find max contiguous */ while(edp > edp0) { shp--; edp--; if(*edp < *shp ) { const size_t *zedp = edp; while(zedp >= edp0) { if(*zedp == 0) { *iocountp = 0; goto done; } /* Tip of the hat to segmented architectures */ if(zedp == edp0) break; zedp--; } break; } assert(*edp == *shp); } /* * edp, shp reference rightmost index s.t. *(edp +1) == *(shp +1) * * Or there is only one dimension. * If there is only one dimension and it is 'non record' dimension, * edp is &edges[0] and we will return -1. * If there is only one dimension and and it is a "record dimension", * edp is &edges[1] (out of bounds) and we will return 0; */ assert(shp >= varp->shape + varp->ndims -1 || *(edp +1) == *(shp +1)); /* now accumulate max count for a single io operation */ for(*iocountp = 1, edp0 = edp; edp0 < edges + varp->ndims; edp0++) { *iocountp *= *edp0; } done: return((int)(edp - edges) - 1); } /* * Set the elements of the array 'upp' to * the sum of the corresponding elements of * 'stp' and 'edp'. 'end' should be &stp[nelems]. */ static void set_upper(size_t *upp, /* modified on return */ const size_t *stp, const size_t *edp, const size_t *const end) { while(upp < end) { *upp++ = *stp++ + *edp++; } } /* * The infamous and oft-discussed odometer code. * * 'start[]' is the starting coordinate. * 'upper[]' is the upper bound s.t. start[ii] < upper[ii]. * 'coord[]' is the register, the current coordinate value. * For some ii, * upp == &upper[ii] * cdp == &coord[ii] * * Running this routine increments *cdp. * * If after the increment, *cdp is equal to *upp * (and cdp is not the leftmost dimension), * *cdp is "zeroed" to the starting value and * we need to "carry", eg, increment one place to * the left. * * TODO: Some architectures hate recursion? * Reimplement non-recursively. */ static void odo1(const size_t *const start, const size_t *const upper, size_t *const coord, /* modified on return */ const size_t *upp, size_t *cdp) { assert(coord <= cdp && cdp <= coord + NC_MAX_VAR_DIMS); assert(upper <= upp && upp <= upper + NC_MAX_VAR_DIMS); assert(upp - upper == cdp - coord); assert(*cdp <= *upp); (*cdp)++; if(cdp != coord && *cdp >= *upp) { *cdp = start[cdp - coord]; odo1(start, upper, coord, upp -1, cdp -1); } } #ifdef _CRAYC #pragma _CRI noinline odo1 #endif /* Public */ int nc_put_var1_text(int ncid, int varid, const size_t *coord, const char *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type != NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_text(ncp, varp, coord, 1, value); } int nc_put_var1_uchar(int ncid, int varid, const size_t *coord, const uchar *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_uchar(ncp, varp, coord, 1, value); } int nc_put_var1_schar(int ncid, int varid, const size_t *coord, const schar *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_schar(ncp, varp, coord, 1, value); } int nc_put_var1_short(int ncid, int varid, const size_t *coord, const short *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_short(ncp, varp, coord, 1, value); } int nc_put_var1_int(int ncid, int varid, const size_t *coord, const int *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_int(ncp, varp, coord, 1, value); } int nc_put_var1_long(int ncid, int varid, const size_t *coord, const long *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_long(ncp, varp, coord, 1, value); } int nc_put_var1_float(int ncid, int varid, const size_t *coord, const float *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_float(ncp, varp, coord, 1, value); } int nc_put_var1_double(int ncid, int varid, const size_t *coord, const double *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *coord +1); if(status != NC_NOERR) return status; } return putNCv_double(ncp, varp, coord, 1, value); } int nc_get_var1_text(int ncid, int varid, const size_t *coord, char *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type != NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_text(ncp, varp, coord, 1, value); } int nc_get_var1_uchar(int ncid, int varid, const size_t *coord, uchar *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_uchar(ncp, varp, coord, 1, value); } int nc_get_var1_schar(int ncid, int varid, const size_t *coord, schar *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_schar(ncp, varp, coord, 1, value); } int nc_get_var1_short(int ncid, int varid, const size_t *coord, short *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_short(ncp, varp, coord, 1, value); } int nc_get_var1_int(int ncid, int varid, const size_t *coord, int *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_int(ncp, varp, coord, 1, value); } int nc_get_var1_long(int ncid, int varid, const size_t *coord, long *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_long(ncp, varp, coord, 1, value); } int nc_get_var1_float(int ncid, int varid, const size_t *coord, float *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_float(ncp, varp, coord, 1, value); } int nc_get_var1_double(int ncid, int varid, const size_t *coord, double *value) { int status; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, coord); if(status != NC_NOERR) return status; return getNCv_double(ncp, varp, coord, 1, value); } int nc_put_vara_text(int ncid, int varid, const size_t *start, const size_t *edges, const char *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type != NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_text(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_text(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_text(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_text(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_put_vara_uchar(int ncid, int varid, const size_t *start, const size_t *edges, const uchar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_uchar(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_uchar(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_uchar(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_uchar(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_put_vara_schar(int ncid, int varid, const size_t *start, const size_t *edges, const schar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_schar(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_schar(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_schar(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_schar(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_put_vara_short(int ncid, int varid, const size_t *start, const size_t *edges, const short *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_short(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_short(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_short(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_short(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_put_vara_int(int ncid, int varid, const size_t *start, const size_t *edges, const int *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_int(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_int(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_int(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_int(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_put_vara_long(int ncid, int varid, const size_t *start, const size_t *edges, const long *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_long(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_long(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_long(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_long(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_put_vara_float(int ncid, int varid, const size_t *start, const size_t *edges, const float *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_float(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_float(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_float(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_float(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_put_vara_double(int ncid, int varid, const size_t *start, const size_t *edges, const double *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( putNCv_double(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { status = NCvnrecs(ncp, *start + *edges); if(status != NC_NOERR) return status; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( putNCv_double(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( putNCv_double(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = putNCv_double(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_text(int ncid, int varid, const size_t *start, const size_t *edges, char *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type != NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_text(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_text(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_text(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_text(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_uchar(int ncid, int varid, const size_t *start, const size_t *edges, uchar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_uchar(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_uchar(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_uchar(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_uchar(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_schar(int ncid, int varid, const size_t *start, const size_t *edges, schar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_schar(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_schar(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_schar(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_schar(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_short(int ncid, int varid, const size_t *start, const size_t *edges, short *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_short(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_short(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_short(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_short(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_int(int ncid, int varid, const size_t *start, const size_t *edges, int *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_int(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_int(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_int(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_int(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_long(int ncid, int varid, const size_t *start, const size_t *edges, long *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_long(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_long(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_long(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_long(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_float(int ncid, int varid, const size_t *start, const size_t *edges, float *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_float(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_float(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_float(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_float(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } int nc_get_vara_double(int ncid, int varid, const size_t *start, const size_t *edges, double *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; int ii; size_t iocount; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; status = NCcoordck(ncp, varp, start); if(status != NC_NOERR) return status; status = NCedgeck(ncp, varp, start, edges); if(status != NC_NOERR) return status; if(varp->ndims == 0) /* scalar variable */ { return( getNCv_double(ncp, varp, start, 1, value) ); } if(IS_RECVAR(varp)) { if(*start + *edges > NC_get_numrecs(ncp)) return NC_EEDGE; if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return( getNCv_double(ncp, varp, start, *edges, value) ); } } /* * find max contiguous * and accumulate max count for a single io operation */ ii = NCiocount(ncp, varp, edges, &iocount); if(ii == -1) { return( getNCv_double(ncp, varp, start, iocount, value) ); } assert(ii >= 0); { /* inline */ ALLOC_ONSTACK(coord, size_t, varp->ndims); ALLOC_ONSTACK(upper, size_t, varp->ndims); const size_t index = ii; /* copy in starting indices */ (void) memcpy(coord, start, varp->ndims * sizeof(size_t)); /* set up in maximum indices */ set_upper(upper, start, edges, &upper[varp->ndims]); /* ripple counter */ while(*coord < *upper) { const int lstatus = getNCv_double(ncp, varp, coord, iocount, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += iocount; odo1(start, upper, coord, &upper[index], &coord[index]); } FREE_ONSTACK(upper); FREE_ONSTACK(coord); } /* end inline */ return status; } #if defined(__cplusplus) /* C++ consts default to internal linkage and must be initialized */ const size_t coord_zero[NC_MAX_VAR_DIMS] = {0}; #else static const size_t coord_zero[NC_MAX_VAR_DIMS]; #endif int nc_put_var_text(int ncid, int varid, const char *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type != NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_text(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_text(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_text(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_text(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_put_var_uchar(int ncid, int varid, const uchar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_uchar(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_uchar(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_uchar(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_uchar(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_put_var_schar(int ncid, int varid, const schar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_schar(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_schar(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_schar(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_schar(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_put_var_short(int ncid, int varid, const short *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_short(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_short(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_short(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_short(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_put_var_int(int ncid, int varid, const int *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_int(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_int(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_int(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_int(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_put_var_long(int ncid, int varid, const long *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_long(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_long(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_long(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_long(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_put_var_float(int ncid, int varid, const float *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_float(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_float(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_float(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_float(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_put_var_double(int ncid, int varid, const double *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_readonly(ncp)) return NC_EPERM; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->type == NC_CHAR) return NC_ECHAR; if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( putNCv_double(ncp, varp, &zed, 1, value) ); } if(!IS_RECVAR(varp)) { return(putNCv_double(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(putNCv_double(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = putNCv_double(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_text(int ncid, int varid, char *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_text(ncp, varp, &zed, 1, value) ); } if(varp->type != NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_text(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_text(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_text(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_uchar(int ncid, int varid, uchar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_uchar(ncp, varp, &zed, 1, value) ); } if(varp->type == NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_uchar(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_uchar(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_uchar(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_schar(int ncid, int varid, schar *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_schar(ncp, varp, &zed, 1, value) ); } if(varp->type == NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_schar(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_schar(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_schar(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_short(int ncid, int varid, short *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_short(ncp, varp, &zed, 1, value) ); } if(varp->type == NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_short(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_short(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_short(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_int(int ncid, int varid, int *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_int(ncp, varp, &zed, 1, value) ); } if(varp->type == NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_int(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_int(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_int(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_long(int ncid, int varid, long *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_long(ncp, varp, &zed, 1, value) ); } if(varp->type == NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_long(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_long(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_long(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_float(int ncid, int varid, float *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_float(ncp, varp, &zed, 1, value) ); } if(varp->type == NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_float(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_float(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_float(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } int nc_get_var_double(int ncid, int varid, double *value) { int status = NC_NOERR; NC *ncp; const NC_var *varp; status = NC_check_id(ncid, &ncp); if(status != NC_NOERR) return status; if(NC_indef(ncp)) return NC_EINDEFINE; varp = NC_lookupvar(ncp, varid); if(varp == NULL) return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */ if(varp->ndims == 0) /* scalar variable */ { const size_t zed = 0; return( getNCv_double(ncp, varp, &zed, 1, value) ); } if(varp->type == NC_CHAR) return NC_ECHAR; if(!IS_RECVAR(varp)) { return(getNCv_double(ncp, varp, coord_zero, *varp->dsizes, value)); } /* else */ if(varp->ndims == 1 && ncp->recsize <= varp->len) { /* one dimensional && the only record variable */ return(getNCv_double(ncp, varp, coord_zero, NC_get_numrecs(ncp), value)); } /* else */ { ALLOC_ONSTACK(coord, size_t, varp->ndims); size_t elemsPerRec = 1; const size_t nrecs = NC_get_numrecs(ncp); (void) memset(coord, 0, varp->ndims * sizeof(size_t)); /* TODO: fix dsizes to avoid this nonsense */ if(varp->ndims > 1) elemsPerRec = varp->dsizes[1]; while(*coord < nrecs) { const int lstatus = getNCv_double(ncp, varp, coord, elemsPerRec, value); if(lstatus != NC_NOERR) { if(lstatus != NC_ERANGE) { status = lstatus; /* fatal for the loop */ break; } /* else NC_ERANGE, not fatal for the loop */ if(status == NC_NOERR) status = lstatus; } value += elemsPerRec; (*coord)++; } FREE_ONSTACK(coord); } /* elemsPerRec */ return status; } /* Begin putgetg.c */ int nc_get_vars_text ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, char *value) { return nc_get_varm_text (ncid, varid, start, edges, stride, 0, value); } int nc_get_vars_uchar ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, uchar *value) { return nc_get_varm_uchar (ncid, varid, start, edges, stride, 0, value); } int nc_get_vars_schar ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, schar *value) { return nc_get_varm_schar (ncid, varid, start, edges, stride, 0, value); } int nc_get_vars_short ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, short *value) { return nc_get_varm_short (ncid, varid, start, edges, stride, 0, value); } int nc_get_vars_int ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, int *value) { return nc_get_varm_int (ncid, varid, start, edges, stride, 0, value); } int nc_get_vars_long ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, long *value) { return nc_get_varm_long (ncid, varid, start, edges, stride, 0, value); } int nc_get_vars_float ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, float *value) { return nc_get_varm_float (ncid, varid, start, edges, stride, 0, value); } int nc_get_vars_double ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, double *value) { return nc_get_varm_double (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_text ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const char *value) { return nc_put_varm_text (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_uchar ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const uchar *value) { return nc_put_varm_uchar (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_schar ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const schar *value) { return nc_put_varm_schar (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_short ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const short *value) { return nc_put_varm_short (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_int ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const int *value) { return nc_put_varm_int (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_long ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const long *value) { return nc_put_varm_long (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_float ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const float *value) { return nc_put_varm_float (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars_double ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const double *value) { return nc_put_varm_double (ncid, varid, start, edges, stride, 0, value); } /* * Generalized hyperslab input. */ int nc_get_varm_text(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, char *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type != NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_text (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_text() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_text (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_get_varm_uchar(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, uchar *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_uchar (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_uchar() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_uchar (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_get_varm_schar(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, schar *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_schar (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_schar() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_schar (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_get_varm_short(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, short *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_short (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_short() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_short (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_get_varm_int(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, int *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_int (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_int() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_int (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_get_varm_long(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, long *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_long (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_long() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_long (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_get_varm_float(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, float *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_float (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_float() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_float (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_get_varm_double(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, double *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return getNCv_double (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = maxidim; idim >= 0; --idim) { size_t dimlen = idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) : varp->shape[idim]; if (mystart[idim] >= dimlen) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > dimlen) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_get_vara_double() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_get_vara_double (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } #ifdef NO_NETCDF_2 extern int nctypelen(nc_type datatype); #endif /* * Generalized hyperslab output. */ int nc_put_varm_text(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const char *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type != NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_text (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_text() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_text (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_put_varm_uchar(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const uchar *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_uchar (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_uchar() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_uchar (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_put_varm_schar(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const schar *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_schar (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_schar() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_schar (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_put_varm_short(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const short *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_short (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_short() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_short (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_put_varm_int(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const int *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_int (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_int() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_int (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_put_varm_long(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const long *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_long (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_long() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_long (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_put_varm_float(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const float *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_float (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_float() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_float (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } int nc_put_varm_double(int ncid, int varid, const size_t *start, const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t *map, const double *value) { int status = ENOERR; NC *ncp; NC_var *varp; int maxidim; /* maximum dimensional index */ status = NC_check_id (ncid, &ncp); if (status != NC_NOERR) return status; if (NC_indef (ncp)) { return NC_EINDEFINE; } if (NC_readonly (ncp)) return NC_EPERM; varp = NC_lookupvar (ncp, varid); if (varp == NULL) return NC_ENOTVAR; if(varp->type == NC_CHAR) return NC_ECHAR; maxidim = (int) varp->ndims - 1; if (maxidim < 0) { /* * The variable is a scalar; consequently, * there s only one thing to get and only one place to put it. * (Why was I called?) */ return putNCv_double (ncp, varp, start, 1, value); } /* * else * The variable is an array. */ { int idim; size_t *mystart = NULL; size_t *myedges; size_t *iocount; /* count vector */ size_t *stop; /* stop indexes */ size_t *length; /* edge lengths in bytes */ ptrdiff_t *mystride; ptrdiff_t *mymap; /* * Verify stride argument. */ for (idim = 0; idim <= maxidim; ++idim) { if (stride != NULL && (stride[idim] == 0 /* cast needed for braindead systems with signed size_t */ || (unsigned long) stride[idim] >= X_INT_MAX)) { return NC_ESTRIDE; } } /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t)); if(mystart == NULL) return NC_ENOMEM; myedges = mystart + varp->ndims; iocount = myedges + varp->ndims; stop = iocount + varp->ndims; length = stop + varp->ndims; mystride = (ptrdiff_t *)(length + varp->ndims); mymap = mystride + varp->ndims; /* * Initialize I/O parameters. */ for (idim = maxidim; idim >= 0; --idim) { mystart[idim] = start != NULL ? start[idim] : 0; if (edges[idim] == 0) { status = NC_NOERR; /* read/write no data */ goto done; } myedges[idim] = edges != NULL ? edges[idim] : idim == 0 && IS_RECVAR (varp) ? NC_get_numrecs(ncp) - mystart[idim] : varp->shape[idim] - mystart[idim]; mystride[idim] = stride != NULL ? stride[idim] : 1; mymap[idim] = map != NULL ? map[idim] : idim == maxidim ? 1 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; iocount[idim] = 1; length[idim] = mymap[idim] * myedges[idim]; stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; } /* * Check start, edges */ for (idim = IS_RECVAR (varp); idim < maxidim; ++idim) { if (mystart[idim] > varp->shape[idim]) { status = NC_EINVALCOORDS; goto done; } if (mystart[idim] + myedges[idim] > varp->shape[idim]) { status = NC_EEDGE; goto done; } } /* * As an optimization, adjust I/O parameters when the fastest * dimension has unity stride both externally and internally. * In this case, the user could have called a simpler routine * (i.e. ncvarnc_put_vara_double() */ if (mystride[maxidim] == 1 && mymap[maxidim] == 1) { iocount[maxidim] = myedges[maxidim]; mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; mymap[maxidim] = (ptrdiff_t) length[maxidim]; } /* * Perform I/O. Exit when done. */ for (;;) { /* TODO: */ int lstatus = nc_put_vara_double (ncid, varid, mystart, iocount, value); if (lstatus != NC_NOERR && (status == NC_NOERR || lstatus != NC_ERANGE)) status = lstatus; /* * The following code permutes through the variable s * external start-index space and it s internal address * space. At the UPC, this algorithm is commonly * called "odometer code". */ idim = maxidim; carry: value += mymap[idim]; mystart[idim] += mystride[idim]; if (mystart[idim] == stop[idim]) { mystart[idim] = start[idim]; value -= length[idim]; if (--idim < 0) break; /* normal return */ goto carry; } } /* I/O loop */ done: free(mystart); } /* variable is array */ return status; } /* * Copy the values of a variable from an input netCDF to an output netCDF. * Input and output var assummed to have the same shape. * return -1 on error. */ int nc_copy_var(int ncid_in, int varid, int ncid_out) { int status = NC_NOERR; NC *inncp, *outncp; NC_var *invp, *outvp; status = NC_check_id(ncid_in, &inncp); if(status != NC_NOERR) return status; if(NC_indef(inncp)) { return NC_EINDEFINE; } status = NC_check_id(ncid_out, &outncp); if(status != NC_NOERR) return status; if(NC_readonly(outncp)) { /* output file isn't writable */ return NC_EPERM; } if(NC_indef(outncp)) { return NC_EINDEFINE; } /* find the variable in the input cdf */ invp = NC_lookupvar(inncp, varid); if(invp == NULL) { return NC_ENOTVAR; } /* find the variable in the output cdf */ if(NC_findvar(&outncp->vars, invp->name->cp, &outvp) == -1) { return NC_ENOTVAR; } /* can we even attempt to copy without conversion? */ if(outvp->type != invp->type) { return NC_EINVAL; } if( (invp->ndims == 0 && outvp->ndims != 0) || (invp->ndims != 0 && outvp->ndims == 0) || (IS_RECVAR(invp) && !IS_RECVAR(outvp)) || (!IS_RECVAR(invp) && IS_RECVAR(outvp)) || (invp->len != outvp->len) ) { return NC_EINVAL; } /* * Check coordinates */ { ALLOC_ONSTACK(coord, size_t, invp->ndims); const size_t nrecs = NC_get_numrecs(inncp); (void) memcpy(coord, invp->shape, invp->ndims * sizeof(size_t)); if(IS_RECVAR(invp)) *coord = nrecs; { size_t ii = 0; for(; ii < invp->ndims; ii++) coord[ii] --; } /* at this point, coord is the largest valid coord of invp */ if(NCcoordck(outncp, outvp, coord) != NC_NOERR) { return NC_EINVAL; } /* else */ (void) memset(coord, 0, invp->ndims * sizeof(size_t)); if(!IS_RECVAR(invp)) { status = NCxvarcpy(inncp, invp, coord, outncp, outvp, coord, invp->len); goto done; } /* else */ status = NCvnrecs(outncp, nrecs); if(status != NC_NOERR) goto done; for( /*NADA*/; *coord < nrecs; (*coord)++) { status = NCxvarcpy(inncp, invp, coord, outncp, outvp, coord, invp->len); if(status != NC_NOERR) break; } done: FREE_ONSTACK(coord); } return status; } /* no longer deprecated, used to support the 2.x interface and also the netcdf-4 api. */ int nc_get_att(int ncid, int varid, const char *name, void *value) { int status; nc_type atttype; status = nc_inq_atttype(ncid, varid, name, &atttype); if(status != NC_NOERR) return status; switch (atttype) { case NC_BYTE: return nc_get_att_schar(ncid, varid, name, (schar *)value); case NC_CHAR: return nc_get_att_text(ncid, varid, name, (char *)value); case NC_SHORT: return nc_get_att_short(ncid, varid, name, (short *)value); case NC_INT: #if (SIZEOF_INT >= X_SIZEOF_INT) return nc_get_att_int(ncid, varid, name, (int *)value); #elif SIZEOF_LONG == X_SIZEOF_INT return nc_get_att_long(ncid, varid, name, (long *)value); #endif case NC_FLOAT: return nc_get_att_float(ncid, varid, name, (float *)value); case NC_DOUBLE: return nc_get_att_double(ncid, varid, name, (double *)value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } int nc_put_att( int ncid, int varid, const char *name, nc_type type, size_t nelems, const void *value) { switch (type) { case NC_BYTE: return nc_put_att_schar(ncid, varid, name, type, nelems, (schar *)value); case NC_CHAR: return nc_put_att_text(ncid, varid, name, nelems, (char *)value); case NC_SHORT: return nc_put_att_short(ncid, varid, name, type, nelems, (short *)value); case NC_INT: #if (SIZEOF_INT >= X_SIZEOF_INT) return nc_put_att_int(ncid, varid, name, type, nelems, (int *)value); #elif SIZEOF_LONG == X_SIZEOF_INT return nc_put_att_long(ncid, varid, name, type, nelems, (long *)value); #endif case NC_FLOAT: return nc_put_att_float(ncid, varid, name, type, nelems, (float *)value); case NC_DOUBLE: return nc_put_att_double(ncid, varid, name, type, nelems, (double *)value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } int nc_get_var1(int ncid, int varid, const size_t *coord, void *value) { int status; nc_type vartype; status = nc_inq_vartype(ncid, varid, &vartype); if(status != NC_NOERR) return status; switch(vartype){ case NC_CHAR: return nc_get_var1_text(ncid, varid, coord, (char *) value); case NC_BYTE: return nc_get_var1_schar(ncid, varid, coord, (schar *) value); case NC_SHORT: return nc_get_var1_short(ncid, varid, coord, (short *) value); case NC_INT: return nc_get_var1_int(ncid, varid, coord, (int *) value); case NC_FLOAT: return nc_get_var1_float(ncid, varid, coord, (float *) value); case NC_DOUBLE: return nc_get_var1_double(ncid, varid, coord, (double *) value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } int nc_put_var1(int ncid, int varid, const size_t *coord, const void *value) { int status; nc_type vartype; status = nc_inq_vartype(ncid, varid, &vartype); if(status != NC_NOERR) return status; switch(vartype){ case NC_CHAR: return nc_put_var1_text(ncid, varid, coord, (const char *) value); case NC_BYTE: return nc_put_var1_schar(ncid, varid, coord, (const schar *) value); case NC_SHORT: return nc_put_var1_short(ncid, varid, coord, (const short *) value); case NC_INT: return nc_put_var1_int(ncid, varid, coord, (const int *) value); case NC_FLOAT: return nc_put_var1_float(ncid, varid, coord, (const float *) value); case NC_DOUBLE: return nc_put_var1_double(ncid, varid, coord, (const double *) value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } int nc_get_vara(int ncid, int varid, const size_t *start, const size_t *edges, void *value) { int status; nc_type vartype; status = nc_inq_vartype(ncid, varid, &vartype); if(status != NC_NOERR) return status; switch(vartype){ case NC_CHAR: return nc_get_vara_text(ncid, varid, start, edges, (char *) value); case NC_BYTE: return nc_get_vara_schar(ncid, varid, start, edges, (schar *) value); case NC_SHORT: return nc_get_vara_short(ncid, varid, start, edges, (short *) value); case NC_INT: #if (SIZEOF_INT >= X_SIZEOF_INT) return nc_get_vara_int(ncid, varid, start, edges, (int *) value); #elif SIZEOF_LONG == X_SIZEOF_INT return nc_get_vara_long(ncid, varid, start, edges, (long *) value); #else #error "nc_get_vara implementation" #endif case NC_FLOAT: return nc_get_vara_float(ncid, varid, start, edges, (float *) value); case NC_DOUBLE: return nc_get_vara_double(ncid, varid, start, edges, (double *) value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } int nc_put_vara(int ncid, int varid, const size_t *start, const size_t *edges, const void *value) { int status; nc_type vartype; status = nc_inq_vartype(ncid, varid, &vartype); if(status != NC_NOERR) return status; switch(vartype){ case NC_CHAR: return nc_put_vara_text(ncid, varid, start, edges, (const char *) value); case NC_BYTE: return nc_put_vara_schar(ncid, varid, start, edges, (const schar *) value); case NC_SHORT: return nc_put_vara_short(ncid, varid, start, edges, (const short *) value); case NC_INT: return nc_put_vara_int(ncid, varid, start, edges, (const int *) value); case NC_FLOAT: return nc_put_vara_float(ncid, varid, start, edges, (const float *) value); case NC_DOUBLE: return nc_put_vara_double(ncid, varid, start, edges, (const double *) value); case NC_NAT: return NC_EBADTYPE; } return NC_EBADTYPE; } int nc_get_varm ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const ptrdiff_t * imapp, void *value) { int status; nc_type vartype; int varndims; ptrdiff_t *cvtmap = NULL; status = nc_inq_vartype(ncid, varid, &vartype); if(status != NC_NOERR) return status; status = nc_inq_varndims(ncid, varid, &varndims); if(status != NC_NOERR) return status; if(imapp != NULL && varndims != 0) { /* * convert map units from bytes to units of sizeof(type) */ size_t ii; const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype); cvtmap = (ptrdiff_t *)calloc(varndims, sizeof(ptrdiff_t)); if(cvtmap == NULL) return NC_ENOMEM; for(ii = 0; ii < varndims; ii++) { if(imapp[ii] % szof != 0) { free(cvtmap); return NC_EINVAL; } cvtmap[ii] = imapp[ii] / szof; } imapp = cvtmap; } switch(vartype){ case NC_CHAR: status = nc_get_varm_text(ncid, varid, start, edges, stride, imapp, (char *) value); break; case NC_BYTE: status = nc_get_varm_schar(ncid, varid, start, edges, stride, imapp, (schar *) value); break; case NC_SHORT: status = nc_get_varm_short(ncid, varid, start, edges, stride, imapp, (short *) value); break; case NC_INT: #if (SIZEOF_INT >= X_SIZEOF_INT) status = nc_get_varm_int(ncid, varid, start, edges, stride, imapp, (int *) value); #elif SIZEOF_LONG == X_SIZEOF_INT status = nc_get_varm_long(ncid, varid, start, edges, stride, imapp, (long *) value); #else #error "nc_get_varm implementation" #endif break; case NC_FLOAT: status = nc_get_varm_float(ncid, varid, start, edges, stride, imapp, (float *) value); break; case NC_DOUBLE: status = nc_get_varm_double(ncid, varid, start, edges, stride, imapp, (double *) value); break; default: status = NC_EBADTYPE; break; } if(cvtmap != NULL) { free(cvtmap); } return status; } int nc_put_varm ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const ptrdiff_t * imapp, const void *value) { int status; nc_type vartype; int varndims; ptrdiff_t *cvtmap = NULL; status = nc_inq_vartype(ncid, varid, &vartype); if(status != NC_NOERR) return status; status = nc_inq_varndims(ncid, varid, &varndims); if(status != NC_NOERR) return status; if(imapp != NULL && varndims != 0) { /* * convert map units from bytes to units of sizeof(type) */ size_t ii; const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype); cvtmap = (ptrdiff_t *)calloc(varndims, sizeof(ptrdiff_t)); if(cvtmap == NULL) return NC_ENOMEM; for(ii = 0; ii < varndims; ii++) { if(imapp[ii] % szof != 0) { free(cvtmap); return NC_EINVAL; } cvtmap[ii] = imapp[ii] / szof; } imapp = cvtmap; } switch(vartype){ case NC_CHAR: status = nc_put_varm_text(ncid, varid, start, edges, stride, imapp, (const char *) value); break; case NC_BYTE: status = nc_put_varm_schar(ncid, varid, start, edges, stride, imapp, (const schar *) value); break; case NC_SHORT: status = nc_put_varm_short(ncid, varid, start, edges, stride, imapp, (const short *) value); break; case NC_INT: #if (SIZEOF_INT >= X_SIZEOF_INT) status = nc_put_varm_int(ncid, varid, start, edges, stride, imapp, (const int *) value); #elif SIZEOF_LONG == X_SIZEOF_INT status = nc_put_varm_long(ncid, varid, start, edges, stride, imapp, (const long *) value); #else #error "nc_put_varm implementation" #endif break; case NC_FLOAT: status = nc_put_varm_float(ncid, varid, start, edges, stride, imapp, (const float *) value); break; case NC_DOUBLE: status = nc_put_varm_double(ncid, varid, start, edges, stride, imapp, (const double *) value); break; default: status = NC_EBADTYPE; break; } if(cvtmap != NULL) { free(cvtmap); } return status; } int nc_get_vars ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, void *value) { return nc_get_varm (ncid, varid, start, edges, stride, 0, value); } int nc_put_vars ( int ncid, int varid, const size_t * start, const size_t * edges, const ptrdiff_t * stride, const void *value) { return nc_put_varm (ncid, varid, start, edges, stride, 0, value); }