Doxygen Source Code Documentation
v1hpg.c File Reference
#include "nc.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "rnd.h"
#include "ncx.h"
Go to the source code of this file.
Data Structures | |
struct | v1hs |
Defines | |
#define | X_SIZEOF_NC_TYPE X_SIZEOF_INT |
#define | X_SIZEOF_NCTYPE X_SIZEOF_INT |
#define | MIN(mm, nn) (((mm) < (nn)) ? (mm) : (nn)) |
Typedefs | |
typedef v1hs | v1hs |
Functions | |
int | rel_v1hs (v1hs *gsp) |
int | fault_v1hs (v1hs *gsp, size_t extent) |
int | check_v1hs (v1hs *gsp, size_t nextread) |
int | v1h_put_size_t (v1hs *psp, const size_t *sp) |
int | v1h_get_size_t (v1hs *gsp, size_t *sp) |
int | v1h_put_nc_type (v1hs *psp, const nc_type *typep) |
int | v1h_get_nc_type (v1hs *gsp, nc_type *typep) |
int | v1h_put_NCtype (v1hs *psp, NCtype type) |
int | v1h_get_NCtype (v1hs *gsp, NCtype *typep) |
size_t | ncx_len_NC_string (const NC_string *ncstrp) |
int | v1h_put_NC_string (v1hs *psp, const NC_string *ncstrp) |
int | v1h_get_NC_string (v1hs *gsp, NC_string **ncstrpp) |
size_t | ncx_len_NC_dim (const NC_dim *dimp) |
int | v1h_put_NC_dim (v1hs *psp, const NC_dim *dimp) |
int | v1h_get_NC_dim (v1hs *gsp, NC_dim **dimpp) |
size_t | ncx_len_NC_dimarray (const NC_dimarray *ncap) |
int | v1h_put_NC_dimarray (v1hs *psp, const NC_dimarray *ncap) |
int | v1h_get_NC_dimarray (v1hs *gsp, NC_dimarray *ncap) |
size_t | ncx_len_NC_attr (const NC_attr *attrp) |
int | v1h_put_NC_attrV (v1hs *psp, const NC_attr *attrp) |
int | v1h_put_NC_attr (v1hs *psp, const NC_attr *attrp) |
int | v1h_get_NC_attrV (v1hs *gsp, NC_attr *attrp) |
int | v1h_get_NC_attr (v1hs *gsp, NC_attr **attrpp) |
size_t | ncx_len_NC_attrarray (const NC_attrarray *ncap) |
int | v1h_put_NC_attrarray (v1hs *psp, const NC_attrarray *ncap) |
int | v1h_get_NC_attrarray (v1hs *gsp, NC_attrarray *ncap) |
size_t | ncx_len_NC_var (const NC_var *varp) |
int | v1h_put_NC_var (v1hs *psp, const NC_var *varp) |
int | v1h_get_NC_var (v1hs *gsp, NC_var **varpp) |
size_t | ncx_len_NC_vararray (const NC_vararray *ncap) |
int | v1h_put_NC_vararray (v1hs *psp, const NC_vararray *ncap) |
int | v1h_get_NC_vararray (v1hs *gsp, NC_vararray *ncap) |
int | NC_computeshapes (NC *ncp) |
size_t | ncx_len_NC (const NC *ncp) |
int | ncx_put_NC (const NC *ncp, void **xpp, off_t offset, size_t extent) |
int | nc_get_NC (NC *ncp) |
Variables | |
const schar | ncmagic [] = {'C', 'D', 'F', 0x01} |
Define Documentation
|
|
|
Definition at line 146 of file v1hpg.c. Referenced by ncx_len_NC_attr(), and ncx_len_NC_var(). |
|
Definition at line 189 of file v1hpg.c. Referenced by ncx_len_NC_attrarray(), ncx_len_NC_dimarray(), and ncx_len_NC_vararray(). |
Typedef Documentation
|
|
Function Documentation
|
Definition at line 108 of file v1hpg.c. References v1hs::end, fault_v1hs(), and v1hs::pos. Referenced by v1h_get_NC_attrV(), v1h_get_NC_string(), v1h_get_nc_type(), v1h_get_NC_var(), v1h_get_NCtype(), v1h_get_size_t(), v1h_put_NC_attrV(), v1h_put_NC_string(), v1h_put_nc_type(), v1h_put_NC_var(), v1h_put_NCtype(), and v1h_put_size_t().
00109 { 00110 00111 #if 0 /* DEBUG */ 00112 fprintf(stderr, "nextread %lu, remaining %lu\n", 00113 (unsigned long)nextread, 00114 (unsigned long)((char *)gsp->end - (char *)gsp->pos)); 00115 #endif 00116 00117 if((char *)gsp->pos + nextread <= (char *)gsp->end) 00118 return ENOERR; 00119 return fault_v1hs(gsp, nextread); 00120 } |
|
Definition at line 75 of file v1hpg.c. References v1hs::base, v1hs::end, v1hs::extent, v1hs::flags, ncio::get, v1hs::nciop, v1hs::offset, v1hs::pos, and rel_v1hs(). Referenced by check_v1hs(), nc_get_NC(), and ncx_put_NC().
00076 { 00077 int status; 00078 00079 if(gsp->base != NULL) 00080 { 00081 const size_t incr = (char *)gsp->pos - (char *)gsp->base; 00082 status = rel_v1hs(gsp); 00083 if(status) 00084 return status; 00085 gsp->offset += incr; 00086 } 00087 00088 if(extent > gsp->extent) 00089 gsp->extent = extent; 00090 00091 status = gsp->nciop->get(gsp->nciop, 00092 gsp->offset, gsp->extent, 00093 gsp->flags, &gsp->base); 00094 if(status) 00095 return status; 00096 00097 gsp->pos = gsp->base; 00098 gsp->end = (char *)gsp->base + gsp->extent; 00099 00100 return ENOERR; 00101 } |
|
Definition at line 1066 of file v1hpg.c. References NC_var::begin, NC::begin_rec, NC::begin_var, NC::dims, NC_var::dsizes, IS_RECVAR, NC_var::len, NC_var_shape(), NC_vararray::nelems, NC::recsize, NC_vararray::value, NC::vars, NC_var::xsz, and NC::xsz. Referenced by nc_get_NC().
01067 { 01068 NC_var **vpp = (NC_var **)ncp->vars.value; 01069 NC_var *const *const end = &vpp[ncp->vars.nelems]; 01070 NC_var *first_var = NULL; /* first "non-record" var */ 01071 NC_var *first_rec = NULL; /* first "record" var */ 01072 int status; 01073 01074 ncp->begin_var = (off_t) ncp->xsz; 01075 ncp->begin_rec = (off_t) ncp->xsz; 01076 ncp->recsize = 0; 01077 01078 if(ncp->vars.nelems == 0) 01079 return(0); 01080 01081 for( /*NADA*/; vpp < end; vpp++) 01082 { 01083 status = NC_var_shape(*vpp, &ncp->dims); 01084 if(status != ENOERR) 01085 return(status); 01086 01087 if(IS_RECVAR(*vpp)) 01088 { 01089 if(first_rec == NULL) 01090 first_rec = *vpp; 01091 ncp->recsize += (*vpp)->len; 01092 } 01093 else if(first_var == NULL) 01094 { 01095 first_var = *vpp; 01096 /* 01097 * Overwritten each time thru. 01098 * Usually overwritten in first_rec != NULL clause. 01099 */ 01100 ncp->begin_rec = (*vpp)->begin + (off_t)(*vpp)->len; 01101 } 01102 } 01103 01104 if(first_rec != NULL) 01105 { 01106 assert(ncp->begin_rec <= first_rec->begin); 01107 ncp->begin_rec = first_rec->begin; 01108 /* 01109 * for special case of exactly one record variable, pack value 01110 */ 01111 if(ncp->recsize == first_rec->len) 01112 ncp->recsize = *first_rec->dsizes * first_rec->xsz; 01113 } 01114 01115 if(first_var != NULL) 01116 { 01117 ncp->begin_var = first_var->begin; 01118 } 01119 else 01120 { 01121 ncp->begin_var = ncp->begin_rec; 01122 } 01123 01124 assert(ncp->begin_var > 0); 01125 assert(ncp->xsz <= (size_t)ncp->begin_var); 01126 assert(ncp->begin_rec > 0); 01127 assert(ncp->begin_var <= ncp->begin_rec); 01128 01129 return(ENOERR); 01130 } |
|
Definition at line 1233 of file v1hpg.c. References NC::attrs, v1hs::base, NC::chunk, NC::dims, v1hs::end, v1hs::extent, fault_v1hs(), v1hs::flags, memcmp(), MIN_NC_XSZ, NC_computeshapes(), NC_set_numrecs, NC::nciop, v1hs::nciop, ncmagic, ncx_get_size_t(), ncx_getn_schar_schar(), ncx_len_NC(), v1hs::offset, v1hs::pos, rel_v1hs(), v1h_get_NC_attrarray(), v1h_get_NC_dimarray(), v1h_get_NC_vararray(), NC::vars, and NC::xsz. Referenced by nc__open_mp(), nc_delete_mp(), and read_NC().
01234 { 01235 int status; 01236 v1hs gs; /* the get stream */ 01237 01238 assert(ncp != NULL); 01239 01240 /* Initialize stream gs */ 01241 01242 gs.nciop = ncp->nciop; 01243 gs.offset = 0; /* beginning of file */ 01244 gs.extent = 0; 01245 gs.flags = 0; 01246 gs.base = NULL; 01247 gs.pos = gs.base; 01248 01249 { 01250 /* 01251 * Come up with a reasonable stream read size. 01252 */ 01253 size_t extent = ncp->xsz; 01254 if(extent <= MIN_NC_XSZ) 01255 { 01256 /* first time read */ 01257 extent = ncp->chunk; 01258 /* Protection for when ncp->chunk is huge; 01259 * no need to read hugely. */ 01260 if(extent > 4096) 01261 extent = 4096; 01262 } 01263 else if(extent > ncp->chunk) 01264 { 01265 extent = ncp->chunk; 01266 } 01267 01268 status = fault_v1hs(&gs, extent); 01269 if(status) 01270 return status; 01271 } 01272 01273 /* get the header from the stream gs */ 01274 01275 { 01276 /* Get & check magic number */ 01277 schar magic[sizeof(ncmagic)]; 01278 (void) memset(magic, 0, sizeof(magic)); 01279 01280 status = ncx_getn_schar_schar( 01281 (const void **)(&gs.pos), sizeof(magic), magic); 01282 if(status != ENOERR) 01283 goto unwind_get; 01284 01285 if(memcmp(magic, ncmagic, sizeof(ncmagic)) != 0) 01286 { 01287 status = NC_ENOTNC; 01288 goto unwind_get; 01289 } 01290 } 01291 01292 { 01293 size_t nrecs = 0; 01294 status = ncx_get_size_t((const void **)(&gs.pos), &nrecs); 01295 if(status != ENOERR) 01296 goto unwind_get; 01297 NC_set_numrecs(ncp, nrecs); 01298 } 01299 01300 assert((char *)gs.pos < (char *)gs.end); 01301 01302 status = v1h_get_NC_dimarray(&gs, &ncp->dims); 01303 if(status != ENOERR) 01304 goto unwind_get; 01305 01306 status = v1h_get_NC_attrarray(&gs, &ncp->attrs); 01307 if(status != ENOERR) 01308 goto unwind_get; 01309 01310 status = v1h_get_NC_vararray(&gs, &ncp->vars); 01311 if(status != ENOERR) 01312 goto unwind_get; 01313 01314 ncp->xsz = ncx_len_NC(ncp); 01315 01316 status = NC_computeshapes(ncp); 01317 01318 unwind_get: 01319 (void) rel_v1hs(&gs); 01320 return status; 01321 } |
|
Definition at line 1134 of file v1hpg.c. References NC::attrs, NC::dims, ncx_len_NC_attrarray(), ncx_len_NC_dimarray(), ncx_len_NC_vararray(), NC::vars, and X_SIZEOF_SIZE_T. Referenced by NC_begins(), and nc_get_NC().
01135 { 01136 size_t xlen = sizeof(ncmagic); 01137 01138 assert(ncp != NULL); 01139 01140 xlen += X_SIZEOF_SIZE_T; /* numrecs */ 01141 xlen += ncx_len_NC_dimarray(&ncp->dims); 01142 xlen += ncx_len_NC_attrarray(&ncp->attrs); 01143 xlen += ncx_len_NC_vararray(&ncp->vars); 01144 01145 return xlen; 01146 } |
|
Definition at line 519 of file v1hpg.c. References NC_attr::name, ncx_len_NC_string(), X_SIZEOF_NC_TYPE, X_SIZEOF_SIZE_T, and NC_attr::xsz. Referenced by ncx_len_NC_attrarray().
00520 { 00521 size_t sz; 00522 00523 assert(attrp != NULL); 00524 00525 sz = ncx_len_NC_string(attrp->name); 00526 sz += X_SIZEOF_NC_TYPE; /* type */ 00527 sz += X_SIZEOF_SIZE_T; /* nelems */ 00528 sz += attrp->xsz; 00529 00530 return(sz); 00531 } |
|
Definition at line 677 of file v1hpg.c. References ncx_len_NC_attr(), NC_attrarray::nelems, NC_attrarray::value, X_SIZEOF_NCTYPE, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC(), and ncx_len_NC_var().
00678 { 00679 size_t xlen = X_SIZEOF_NCTYPE; /* type */ 00680 xlen += X_SIZEOF_SIZE_T; /* count */ 00681 if(ncap == NULL) 00682 return xlen; 00683 /* else */ 00684 { 00685 const NC_attr **app = (const NC_attr **)ncap->value; 00686 const NC_attr *const *const end = &app[ncap->nelems]; 00687 for( /*NADA*/; app < end; app++) 00688 { 00689 xlen += ncx_len_NC_attr(*app); 00690 } 00691 } 00692 return xlen; 00693 } |
|
Definition at line 323 of file v1hpg.c. References NC_dim::name, ncx_len_NC_string(), and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC_dimarray().
00324 { 00325 size_t sz; 00326 00327 assert(dimp != NULL); 00328 00329 sz = ncx_len_NC_string(dimp->name); 00330 sz += X_SIZEOF_SIZE_T; 00331 00332 return(sz); 00333 } |
|
Definition at line 388 of file v1hpg.c. References ncx_len_NC_dim(), NC_dimarray::nelems, NC_dimarray::value, X_SIZEOF_NCTYPE, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC().
00389 { 00390 size_t xlen = X_SIZEOF_NCTYPE; /* type */ 00391 xlen += X_SIZEOF_SIZE_T; /* count */ 00392 if(ncap == NULL) 00393 return xlen; 00394 /* else */ 00395 { 00396 const NC_dim **dpp = (const NC_dim **)ncap->value; 00397 const NC_dim *const *const end = &dpp[ncap->nelems]; 00398 for( /*NADA*/; dpp < end; dpp++) 00399 { 00400 xlen += ncx_len_NC_dim(*dpp); 00401 } 00402 } 00403 return xlen; 00404 } |
|
Definition at line 228 of file v1hpg.c. References _RNDUP, NC_string::nchars, X_ALIGN, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC_attr(), ncx_len_NC_dim(), and ncx_len_NC_var().
00229 { 00230 size_t sz = X_SIZEOF_SIZE_T; /* nchars */ 00231 00232 assert(ncstrp != NULL); 00233 00234 if(ncstrp->nchars != 0) 00235 { 00236 #if 0 00237 assert(ncstrp->nchars % X_ALIGN == 0); 00238 sz += ncstrp->nchars; 00239 #else 00240 sz += _RNDUP(ncstrp->nchars, X_ALIGN); 00241 #endif 00242 } 00243 return sz; 00244 } |
|
Definition at line 805 of file v1hpg.c. References NC_var::attrs, NC_var::name, ncx_len_int, ncx_len_NC_attrarray(), ncx_len_NC_string(), NC_var::ndims, X_SIZEOF_NC_TYPE, X_SIZEOF_OFF_T, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC_vararray().
00806 { 00807 size_t sz; 00808 00809 assert(varp != NULL); 00810 00811 sz = ncx_len_NC_string(varp->name); 00812 sz += X_SIZEOF_SIZE_T; /* ndims */ 00813 sz += ncx_len_int(varp->ndims); /* dimids */ 00814 sz += ncx_len_NC_attrarray(&varp->attrs); 00815 sz += X_SIZEOF_NC_TYPE; /* type */ 00816 sz += X_SIZEOF_SIZE_T; /* len */ 00817 sz += X_SIZEOF_OFF_T; /* begin */ 00818 00819 return(sz); 00820 } |
|
Definition at line 932 of file v1hpg.c. References ncx_len_NC_var(), NC_vararray::nelems, NC_vararray::value, X_SIZEOF_NCTYPE, and X_SIZEOF_SIZE_T. Referenced by ncx_len_NC().
00933 { 00934 size_t xlen = X_SIZEOF_NCTYPE; /* type */ 00935 xlen += X_SIZEOF_SIZE_T; /* count */ 00936 if(ncap == NULL) 00937 return xlen; 00938 /* else */ 00939 { 00940 const NC_var **vpp = (const NC_var **)ncap->value; 00941 const NC_var *const *const end = &vpp[ncap->nelems]; 00942 for( /*NADA*/; vpp < end; vpp++) 00943 { 00944 xlen += ncx_len_NC_var(*vpp); 00945 } 00946 } 00947 return xlen; 00948 } |
|
Definition at line 1150 of file v1hpg.c. References NC::attrs, v1hs::base, NC::chunk, NC::dims, v1hs::end, v1hs::extent, fault_v1hs(), v1hs::flags, MIN_NC_XSZ, NC_get_numrecs, NC::nciop, v1hs::nciop, ncmagic, ncx_put_size_t(), ncx_putn_schar_schar(), v1hs::offset, offset, v1hs::pos, rel_v1hs(), RGN_WRITE, v1h_put_NC_attrarray(), v1h_put_NC_dimarray(), v1h_put_NC_vararray(), NC::vars, and NC::xsz. Referenced by nc__create_mp(), and write_NC().
01151 { 01152 int status = ENOERR; 01153 v1hs ps; /* the get stream */ 01154 01155 assert(ncp != NULL); 01156 01157 /* Initialize stream ps */ 01158 01159 ps.nciop = ncp->nciop; 01160 ps.flags = RGN_WRITE; 01161 01162 if(xpp == NULL) 01163 { 01164 /* 01165 * Come up with a reasonable stream read size. 01166 */ 01167 extent = ncp->xsz; 01168 if(extent <= MIN_NC_XSZ) 01169 { 01170 /* first time read */ 01171 extent = ncp->chunk; 01172 /* Protection for when ncp->chunk is huge; 01173 * no need to read hugely. */ 01174 if(extent > 4096) 01175 extent = 4096; 01176 } 01177 else if(extent > ncp->chunk) 01178 { 01179 extent = ncp->chunk; 01180 } 01181 01182 ps.offset = 0; 01183 ps.extent = extent; 01184 ps.base = NULL; 01185 ps.pos = ps.base; 01186 01187 status = fault_v1hs(&ps, extent); 01188 if(status) 01189 return status; 01190 } 01191 else 01192 { 01193 ps.offset = offset; 01194 ps.extent = extent; 01195 ps.base = *xpp; 01196 ps.pos = ps.base; 01197 ps.end = (char *)ps.base + ps.extent; 01198 } 01199 01200 status = ncx_putn_schar_schar(&ps.pos, sizeof(ncmagic), ncmagic); 01201 if(status != ENOERR) 01202 goto release; 01203 01204 { 01205 const size_t nrecs = NC_get_numrecs(ncp); 01206 status = ncx_put_size_t(&ps.pos, &nrecs); 01207 if(status != ENOERR) 01208 goto release; 01209 } 01210 01211 assert((char *)ps.pos < (char *)ps.end); 01212 01213 status = v1h_put_NC_dimarray(&ps, &ncp->dims); 01214 if(status != ENOERR) 01215 goto release; 01216 01217 status = v1h_put_NC_attrarray(&ps, &ncp->attrs); 01218 if(status != ENOERR) 01219 goto release; 01220 01221 status = v1h_put_NC_vararray(&ps, &ncp->vars); 01222 if(status != ENOERR) 01223 goto release; 01224 01225 release: 01226 (void) rel_v1hs(&ps); 01227 01228 return status; 01229 } |
|
Definition at line 56 of file v1hpg.c. References v1hs::base, v1hs::end, v1hs::flags, v1hs::nciop, OFF_NONE, v1hs::offset, v1hs::pos, ncio::rel, RGN_MODIFIED, and RGN_WRITE. Referenced by fault_v1hs(), nc_get_NC(), and ncx_put_NC().
00057 { 00058 int status; 00059 if(gsp->offset == OFF_NONE || gsp->base == NULL) 00060 return ENOERR; 00061 status = gsp->nciop->rel(gsp->nciop, gsp->offset, 00062 gsp->flags == RGN_WRITE ? RGN_MODIFIED : 0); 00063 gsp->end = NULL; 00064 gsp->pos = NULL; 00065 gsp->base = NULL; 00066 return status; 00067 } |
|
Definition at line 632 of file v1hpg.c. References free_NC_attr(), free_NC_string(), new_x_NC_attr(), strp, v1h_get_NC_attrV(), v1h_get_NC_string(), v1h_get_nc_type(), and v1h_get_size_t(). Referenced by v1h_get_NC_attrarray().
00633 { 00634 NC_string *strp; 00635 int status; 00636 nc_type type; 00637 size_t nelems; 00638 NC_attr *attrp; 00639 00640 status = v1h_get_NC_string(gsp, &strp); 00641 if(status != ENOERR) 00642 return status; 00643 00644 status = v1h_get_nc_type(gsp, &type); 00645 if(status != ENOERR) 00646 goto unwind_name; 00647 00648 status = v1h_get_size_t(gsp, &nelems); 00649 if(status != ENOERR) 00650 goto unwind_name; 00651 00652 attrp = new_x_NC_attr(strp, type, nelems); 00653 if(attrp == NULL) 00654 { 00655 status = NC_ENOMEM; 00656 goto unwind_name; 00657 } 00658 00659 status = v1h_get_NC_attrV(gsp, attrp); 00660 if(status != ENOERR) 00661 { 00662 free_NC_attr(attrp); /* frees strp */ 00663 return status; 00664 } 00665 00666 *attrpp = attrp; 00667 00668 return ENOERR; 00669 00670 unwind_name: 00671 free_NC_string(strp); 00672 return status; 00673 } |
|
Definition at line 751 of file v1hpg.c. References free_NC_attrarrayV(), malloc, NC_attrarray::nalloc, NC_ATTRIBUTE, NC_UNSPECIFIED, NCtype, NC_attrarray::nelems, v1hs::pos, v1h_get_NC_attr(), v1h_get_NCtype(), v1h_get_size_t(), and NC_attrarray::value. Referenced by nc_get_NC(), and v1h_get_NC_var().
00752 { 00753 int status; 00754 NCtype type = NC_UNSPECIFIED; 00755 00756 assert(gsp != NULL && gsp->pos != NULL); 00757 assert(ncap != NULL); 00758 assert(ncap->value == NULL); 00759 00760 status = v1h_get_NCtype(gsp, &type); 00761 if(status != ENOERR) 00762 return status; 00763 status = v1h_get_size_t(gsp, &ncap->nelems); 00764 if(status != ENOERR) 00765 return status; 00766 00767 if(ncap->nelems == 0) 00768 return ENOERR; 00769 /* else */ 00770 if(type != NC_ATTRIBUTE) 00771 return EINVAL; 00772 00773 ncap->value = (NC_attr **) malloc(ncap->nelems * sizeof(NC_attr *)); 00774 if(ncap->value == NULL) 00775 return NC_ENOMEM; 00776 ncap->nalloc = ncap->nelems; 00777 00778 { 00779 NC_attr **app = ncap->value; 00780 NC_attr *const *const end = &app[ncap->nelems]; 00781 for( /*NADA*/; app < end; app++) 00782 { 00783 status = v1h_get_NC_attr(gsp, app); 00784 if(status) 00785 { 00786 ncap->nelems = app - ncap->value; 00787 free_NC_attrarrayV(ncap); 00788 return status; 00789 } 00790 } 00791 } 00792 00793 return ENOERR; 00794 } |
|
Definition at line 602 of file v1hpg.c. References check_v1hs(), v1hs::extent, MIN, v1hs::pos, X_ALIGN, NC_attr::xsz, and NC_attr::xvalue. Referenced by v1h_get_NC_attr().
00603 { 00604 int status; 00605 const size_t perchunk = gsp->extent; 00606 size_t remaining = attrp->xsz; 00607 void *value = attrp->xvalue; 00608 size_t nget; 00609 00610 assert(gsp->extent % X_ALIGN == 0); 00611 00612 do { 00613 nget = MIN(perchunk, remaining); 00614 00615 status = check_v1hs(gsp, nget); 00616 if(status != ENOERR) 00617 return status; 00618 00619 (void) memcpy(value, gsp->pos, nget); 00620 00621 gsp->pos = (void *)((char *)gsp->pos + nget); 00622 value = (void *)((char *)value + nget); 00623 remaining -= nget; 00624 00625 } while(remaining != 0); 00626 00627 return ENOERR; 00628 } |
|
Definition at line 353 of file v1hpg.c. References free_NC_dim(), free_NC_string(), new_x_NC_dim(), NC_dim::size, v1h_get_NC_string(), and v1h_get_size_t(). Referenced by v1h_get_NC_dimarray().
00354 { 00355 int status; 00356 NC_string *ncstrp; 00357 NC_dim *dimp; 00358 00359 status = v1h_get_NC_string(gsp, &ncstrp); 00360 if(status != ENOERR) 00361 return status; 00362 00363 dimp = new_x_NC_dim(ncstrp); 00364 if(dimp == NULL) 00365 { 00366 status = NC_ENOMEM; 00367 goto unwind_name; 00368 } 00369 00370 status = v1h_get_size_t(gsp, &dimp->size); 00371 if(status != ENOERR) 00372 { 00373 free_NC_dim(dimp); /* frees name */ 00374 return status; 00375 } 00376 00377 *dimpp = dimp; 00378 00379 return ENOERR; 00380 00381 unwind_name: 00382 free_NC_string(ncstrp); 00383 return status; 00384 } |
|
Definition at line 462 of file v1hpg.c. References free_NC_dimarrayV(), malloc, NC_dimarray::nalloc, NC_DIMENSION, NC_UNSPECIFIED, NCtype, NC_dimarray::nelems, v1hs::pos, v1h_get_NC_dim(), v1h_get_NCtype(), v1h_get_size_t(), and NC_dimarray::value. Referenced by nc_get_NC().
00463 { 00464 int status; 00465 NCtype type = NC_UNSPECIFIED; 00466 00467 assert(gsp != NULL && gsp->pos != NULL); 00468 assert(ncap != NULL); 00469 assert(ncap->value == NULL); 00470 00471 status = v1h_get_NCtype(gsp, &type); 00472 if(status != ENOERR) 00473 return status; 00474 00475 status = v1h_get_size_t(gsp, &ncap->nelems); 00476 if(status != ENOERR) 00477 return status; 00478 00479 if(ncap->nelems == 0) 00480 return ENOERR; 00481 /* else */ 00482 if(type != NC_DIMENSION) 00483 return EINVAL; 00484 00485 ncap->value = (NC_dim **) malloc(ncap->nelems * sizeof(NC_dim *)); 00486 if(ncap->value == NULL) 00487 return NC_ENOMEM; 00488 ncap->nalloc = ncap->nelems; 00489 00490 { 00491 NC_dim **dpp = ncap->value; 00492 NC_dim *const *const end = &dpp[ncap->nelems]; 00493 for( /*NADA*/; dpp < end; dpp++) 00494 { 00495 status = v1h_get_NC_dim(gsp, dpp); 00496 if(status) 00497 { 00498 ncap->nelems = dpp - ncap->value; 00499 free_NC_dimarrayV(ncap); 00500 return status; 00501 } 00502 } 00503 } 00504 00505 return ENOERR; 00506 } |
|
Definition at line 271 of file v1hpg.c. References _RNDUP, check_v1hs(), NC_string::cp, free_NC_string(), NC_string::nchars, ncx_pad_getn_text(), new_NC_string(), v1hs::pos, v1h_get_size_t(), and X_ALIGN. Referenced by v1h_get_NC_attr(), v1h_get_NC_dim(), and v1h_get_NC_var().
00272 { 00273 int status; 00274 size_t nchars = 0; 00275 NC_string *ncstrp; 00276 00277 status = v1h_get_size_t(gsp, &nchars); 00278 if(status != ENOERR) 00279 return status; 00280 00281 ncstrp = new_NC_string(nchars, NULL); 00282 if(ncstrp == NULL) 00283 { 00284 return NC_ENOMEM; 00285 } 00286 00287 00288 #if 0 00289 /* assert(ncstrp->nchars == nchars || ncstrp->nchars - nchars < X_ALIGN); */ 00290 assert(ncstrp->nchars % X_ALIGN == 0); 00291 status = check_v1hs(gsp, ncstrp->nchars); 00292 #else 00293 00294 status = check_v1hs(gsp, _RNDUP(ncstrp->nchars, X_ALIGN)); 00295 #endif 00296 if(status != ENOERR) 00297 goto unwind_alloc; 00298 00299 status = ncx_pad_getn_text((const void **)(&gsp->pos), 00300 nchars, ncstrp->cp); 00301 if(status != ENOERR) 00302 goto unwind_alloc; 00303 00304 *ncstrpp = ncstrp; 00305 00306 return ENOERR; 00307 00308 unwind_alloc: 00309 free_NC_string(ncstrp); 00310 return status; 00311 00312 } |
|
Definition at line 162 of file v1hpg.c. References check_v1hs(), ncx_get_int_int(), v1hs::pos, and X_SIZEOF_INT. Referenced by v1h_get_NC_attr(), and v1h_get_NC_var().
00163 { 00164 int type = 0; 00165 int status = check_v1hs(gsp, X_SIZEOF_INT); 00166 if(status != ENOERR) 00167 return status; 00168 status = ncx_get_int_int(gsp->pos, &type); 00169 gsp->pos = (void *)((char *)gsp->pos + X_SIZEOF_INT); 00170 if(status != ENOERR) 00171 return status; 00172 00173 assert(type == NC_BYTE 00174 || type == NC_CHAR 00175 || type == NC_SHORT 00176 || type == NC_INT 00177 || type == NC_FLOAT 00178 || type == NC_DOUBLE); 00179 00180 /* else */ 00181 *typep = (nc_type) type; 00182 00183 return ENOERR; 00184 } |
|
Definition at line 868 of file v1hpg.c. References NC_var::attrs, NC_var::begin, check_v1hs(), NC_var::dimids, free_NC_string(), free_NC_var(), NC_var::len, ncx_get_off_t(), ncx_getn_int_int(), ncx_len_int, ndims, new_x_NC_var(), v1hs::pos, strp, NC_var::type, v1h_get_NC_attrarray(), v1h_get_NC_string(), v1h_get_nc_type(), v1h_get_size_t(), and X_SIZEOF_OFF_T. Referenced by v1h_get_NC_vararray().
00869 { 00870 NC_string *strp; 00871 int status; 00872 size_t ndims; 00873 NC_var *varp; 00874 00875 status = v1h_get_NC_string(gsp, &strp); 00876 if(status != ENOERR) 00877 return status; 00878 00879 status = v1h_get_size_t(gsp, &ndims); 00880 if(status != ENOERR) 00881 goto unwind_name; 00882 00883 varp = new_x_NC_var(strp, ndims); 00884 if(varp == NULL) 00885 { 00886 status = NC_ENOMEM; 00887 goto unwind_name; 00888 } 00889 00890 status = check_v1hs(gsp, ncx_len_int(ndims)); 00891 if(status != ENOERR) 00892 goto unwind_alloc; 00893 status = ncx_getn_int_int((const void **)(&gsp->pos), 00894 ndims, varp->dimids); 00895 if(status != ENOERR) 00896 goto unwind_alloc; 00897 00898 status = v1h_get_NC_attrarray(gsp, &varp->attrs); 00899 if(status != ENOERR) 00900 goto unwind_alloc; 00901 00902 status = v1h_get_nc_type(gsp, &varp->type); 00903 if(status != ENOERR) 00904 goto unwind_alloc; 00905 00906 status = v1h_get_size_t(gsp, &varp->len); 00907 if(status != ENOERR) 00908 goto unwind_alloc; 00909 00910 status = check_v1hs(gsp, X_SIZEOF_OFF_T); 00911 if(status != ENOERR) 00912 goto unwind_alloc; 00913 status = ncx_get_off_t((const void **)&gsp->pos, 00914 &varp->begin); 00915 if(status != ENOERR) 00916 goto unwind_alloc; 00917 00918 *varpp = varp; 00919 return ENOERR; 00920 00921 unwind_alloc: 00922 free_NC_var(varp); /* frees name */ 00923 return status; 00924 00925 unwind_name: 00926 free_NC_string(strp); 00927 return status; 00928 } |
|
Definition at line 1006 of file v1hpg.c. References free_NC_vararrayV(), malloc, NC_vararray::nalloc, NC_UNSPECIFIED, NC_VARIABLE, NCtype, NC_vararray::nelems, v1hs::pos, v1h_get_NC_var(), v1h_get_NCtype(), v1h_get_size_t(), and NC_vararray::value. Referenced by nc_get_NC().
01007 { 01008 int status; 01009 NCtype type = NC_UNSPECIFIED; 01010 01011 assert(gsp != NULL && gsp->pos != NULL); 01012 assert(ncap != NULL); 01013 assert(ncap->value == NULL); 01014 01015 status = v1h_get_NCtype(gsp, &type); 01016 if(status != ENOERR) 01017 return status; 01018 01019 status = v1h_get_size_t(gsp, &ncap->nelems); 01020 if(status != ENOERR) 01021 return status; 01022 01023 if(ncap->nelems == 0) 01024 return ENOERR; 01025 /* else */ 01026 if(type != NC_VARIABLE) 01027 return EINVAL; 01028 01029 ncap->value = (NC_var **) malloc(ncap->nelems * sizeof(NC_var *)); 01030 if(ncap->value == NULL) 01031 return NC_ENOMEM; 01032 ncap->nalloc = ncap->nelems; 01033 01034 { 01035 NC_var **vpp = ncap->value; 01036 NC_var *const *const end = &vpp[ncap->nelems]; 01037 for( /*NADA*/; vpp < end; vpp++) 01038 { 01039 status = v1h_get_NC_var(gsp, vpp); 01040 if(status) 01041 { 01042 ncap->nelems = vpp - ncap->value; 01043 free_NC_vararrayV(ncap); 01044 return status; 01045 } 01046 } 01047 } 01048 01049 return ENOERR; 01050 } |
|
Definition at line 204 of file v1hpg.c. References check_v1hs(), NCtype, ncx_get_int_int(), v1hs::pos, and X_SIZEOF_INT. Referenced by v1h_get_NC_attrarray(), v1h_get_NC_dimarray(), and v1h_get_NC_vararray().
00205 { 00206 int type = 0; 00207 int status = check_v1hs(gsp, X_SIZEOF_INT); 00208 if(status != ENOERR) 00209 return status; 00210 status = ncx_get_int_int(gsp->pos, &type); 00211 gsp->pos = (void *)((char *)gsp->pos + X_SIZEOF_INT); 00212 if(status != ENOERR) 00213 return status; 00214 /* else */ 00215 *typep = (NCtype) type; 00216 return ENOERR; 00217 } |
|
Definition at line 135 of file v1hpg.c. References check_v1hs(), ncx_get_size_t(), v1hs::pos, and X_SIZEOF_SIZE_T. Referenced by v1h_get_NC_attr(), v1h_get_NC_attrarray(), v1h_get_NC_dim(), v1h_get_NC_dimarray(), v1h_get_NC_string(), v1h_get_NC_var(), and v1h_get_NC_vararray().
00136 { 00137 int status = check_v1hs(gsp, X_SIZEOF_SIZE_T); 00138 if(status != ENOERR) 00139 return status; 00140 return ncx_get_size_t((const void **)(&gsp->pos), sp); 00141 } |
|
Definition at line 572 of file v1hpg.c. References NC_attr::name, NC_attr::nelems, NC_attr::type, v1h_put_NC_attrV(), v1h_put_NC_string(), v1h_put_nc_type(), and v1h_put_size_t(). Referenced by v1h_put_NC_attrarray().
00573 { 00574 int status; 00575 00576 status = v1h_put_NC_string(psp, attrp->name); 00577 if(status != ENOERR) 00578 return status; 00579 00580 status = v1h_put_nc_type(psp, &attrp->type); 00581 if(status != ENOERR) 00582 return status; 00583 00584 status = v1h_put_size_t(psp, &attrp->nelems); 00585 if(status != ENOERR) 00586 return status; 00587 00588 status = v1h_put_NC_attrV(psp, attrp); 00589 if(status != ENOERR) 00590 return status; 00591 00592 return ENOERR; 00593 } |
|
Definition at line 697 of file v1hpg.c. References NC_ATTRIBUTE, NC_UNSPECIFIED, NC_attrarray::nelems, v1h_put_NC_attr(), v1h_put_NCtype(), v1h_put_size_t(), and NC_attrarray::value. Referenced by ncx_put_NC(), and v1h_put_NC_var().
00698 { 00699 int status; 00700 00701 assert(psp != NULL); 00702 00703 if(ncap == NULL 00704 #if 1 00705 /* Backward: 00706 * This clause is for 'byte for byte' 00707 * backward compatibility. 00708 * Strickly speaking, it is 'bug for bug'. 00709 */ 00710 || ncap->nelems == 0 00711 #endif 00712 ) 00713 { 00714 /* 00715 * Handle empty netcdf 00716 */ 00717 const size_t nosz = 0; 00718 00719 status = v1h_put_NCtype(psp, NC_UNSPECIFIED); 00720 if(status != ENOERR) 00721 return status; 00722 status = v1h_put_size_t(psp, &nosz); 00723 if(status != ENOERR) 00724 return status; 00725 return ENOERR; 00726 } 00727 /* else */ 00728 00729 status = v1h_put_NCtype(psp, NC_ATTRIBUTE); 00730 if(status != ENOERR) 00731 return status; 00732 status = v1h_put_size_t(psp, &ncap->nelems); 00733 if(status != ENOERR) 00734 return status; 00735 00736 { 00737 const NC_attr **app = (const NC_attr **)ncap->value; 00738 const NC_attr *const *const end = &app[ncap->nelems]; 00739 for( /*NADA*/; app < end; app++) 00740 { 00741 status = v1h_put_NC_attr(psp, *app); 00742 if(status) 00743 return status; 00744 } 00745 } 00746 return ENOERR; 00747 } |
|
Definition at line 543 of file v1hpg.c. References check_v1hs(), v1hs::extent, MIN, v1hs::pos, X_ALIGN, NC_attr::xsz, and NC_attr::xvalue. Referenced by v1h_put_NC_attr().
00544 { 00545 int status; 00546 const size_t perchunk = psp->extent; 00547 size_t remaining = attrp->xsz; 00548 void *value = attrp->xvalue; 00549 size_t nbytes; 00550 00551 assert(psp->extent % X_ALIGN == 0); 00552 00553 do { 00554 nbytes = MIN(perchunk, remaining); 00555 00556 status = check_v1hs(psp, nbytes); 00557 if(status != ENOERR) 00558 return status; 00559 00560 (void) memcpy(psp->pos, value, nbytes); 00561 00562 psp->pos = (void *)((char *)psp->pos + nbytes); 00563 value = (void *)((char *)value + nbytes); 00564 remaining -= nbytes; 00565 00566 } while(remaining != 0); 00567 00568 return ENOERR; 00569 } |
|
Definition at line 337 of file v1hpg.c. References NC_dim::name, NC_dim::size, v1h_put_NC_string(), and v1h_put_size_t(). Referenced by v1h_put_NC_dimarray().
00338 { 00339 int status; 00340 00341 status = v1h_put_NC_string(psp, dimp->name); 00342 if(status != ENOERR) 00343 return status; 00344 00345 status = v1h_put_size_t(psp, &dimp->size); 00346 if(status != ENOERR) 00347 return status; 00348 00349 return ENOERR; 00350 } |
|
Definition at line 408 of file v1hpg.c. References NC_DIMENSION, NC_UNSPECIFIED, NC_dimarray::nelems, v1h_put_NC_dim(), v1h_put_NCtype(), v1h_put_size_t(), and NC_dimarray::value. Referenced by ncx_put_NC().
00409 { 00410 int status; 00411 00412 assert(psp != NULL); 00413 00414 if(ncap == NULL 00415 #if 1 00416 /* Backward: 00417 * This clause is for 'byte for byte' 00418 * backward compatibility. 00419 * Strickly speaking, it is 'bug for bug'. 00420 */ 00421 || ncap->nelems == 0 00422 #endif 00423 ) 00424 { 00425 /* 00426 * Handle empty netcdf 00427 */ 00428 const size_t nosz = 0; 00429 00430 status = v1h_put_NCtype(psp, NC_UNSPECIFIED); 00431 if(status != ENOERR) 00432 return status; 00433 status = v1h_put_size_t(psp, &nosz); 00434 if(status != ENOERR) 00435 return status; 00436 return ENOERR; 00437 } 00438 /* else */ 00439 00440 status = v1h_put_NCtype(psp, NC_DIMENSION); 00441 if(status != ENOERR) 00442 return status; 00443 status = v1h_put_size_t(psp, &ncap->nelems); 00444 if(status != ENOERR) 00445 return status; 00446 00447 { 00448 const NC_dim **dpp = (const NC_dim **)ncap->value; 00449 const NC_dim *const *const end = &dpp[ncap->nelems]; 00450 for( /*NADA*/; dpp < end; dpp++) 00451 { 00452 status = v1h_put_NC_dim(psp, *dpp); 00453 if(status) 00454 return status; 00455 } 00456 } 00457 return ENOERR; 00458 } |
|
Definition at line 248 of file v1hpg.c. References _RNDUP, check_v1hs(), NC_string::cp, NC_string::nchars, ncx_pad_putn_text(), v1hs::pos, v1h_put_size_t(), and X_ALIGN. Referenced by v1h_put_NC_attr(), v1h_put_NC_dim(), and v1h_put_NC_var().
00249 { 00250 int status; 00251 00252 #if 0 00253 assert(ncstrp->nchars % X_ALIGN == 0); 00254 #endif 00255 00256 status = v1h_put_size_t(psp, &ncstrp->nchars); 00257 if(status != ENOERR) 00258 return status; 00259 status = check_v1hs(psp, _RNDUP(ncstrp->nchars, X_ALIGN)); 00260 if(status != ENOERR) 00261 return status; 00262 status = ncx_pad_putn_text(&psp->pos, ncstrp->nchars, ncstrp->cp); 00263 if(status != ENOERR) 00264 return status; 00265 00266 return ENOERR; 00267 } |
|
Definition at line 149 of file v1hpg.c. References check_v1hs(), ncx_put_int_int(), v1hs::pos, and X_SIZEOF_INT. Referenced by v1h_put_NC_attr(), and v1h_put_NC_var().
00150 { 00151 const int itype = (int) *typep; 00152 int status = check_v1hs(psp, X_SIZEOF_INT); 00153 if(status != ENOERR) 00154 return status; 00155 status = ncx_put_int_int(psp->pos, &itype); 00156 psp->pos = (void *)((char *)psp->pos + X_SIZEOF_INT); 00157 return status; 00158 } |
|
Definition at line 824 of file v1hpg.c. References NC_var::attrs, NC_var::begin, check_v1hs(), NC_var::dimids, NC_var::len, NC_var::name, ncx_len_int, ncx_put_off_t(), ncx_putn_int_int(), NC_var::ndims, v1hs::pos, NC_var::type, v1h_put_NC_attrarray(), v1h_put_NC_string(), v1h_put_nc_type(), v1h_put_size_t(), and X_SIZEOF_OFF_T. Referenced by v1h_put_NC_vararray().
00825 { 00826 int status; 00827 00828 status = v1h_put_NC_string(psp, varp->name); 00829 if(status != ENOERR) 00830 return status; 00831 00832 status = v1h_put_size_t(psp, &varp->ndims); 00833 if(status != ENOERR) 00834 return status; 00835 00836 status = check_v1hs(psp, ncx_len_int(varp->ndims)); 00837 if(status != ENOERR) 00838 return status; 00839 status = ncx_putn_int_int(&psp->pos, 00840 varp->ndims, varp->dimids); 00841 if(status != ENOERR) 00842 return status; 00843 00844 status = v1h_put_NC_attrarray(psp, &varp->attrs); 00845 if(status != ENOERR) 00846 return status; 00847 00848 status = v1h_put_nc_type(psp, &varp->type); 00849 if(status != ENOERR) 00850 return status; 00851 00852 status = v1h_put_size_t(psp, &varp->len); 00853 if(status != ENOERR) 00854 return status; 00855 00856 status = check_v1hs(psp, X_SIZEOF_OFF_T); 00857 if(status != ENOERR) 00858 return status; 00859 status = ncx_put_off_t(&psp->pos, &varp->begin); 00860 if(status != ENOERR) 00861 return status; 00862 00863 return ENOERR; 00864 } |
|
Definition at line 952 of file v1hpg.c. References NC_UNSPECIFIED, NC_VARIABLE, NC_vararray::nelems, v1h_put_NC_var(), v1h_put_NCtype(), v1h_put_size_t(), and NC_vararray::value. Referenced by ncx_put_NC().
00953 { 00954 int status; 00955 00956 assert(psp != NULL); 00957 00958 if(ncap == NULL 00959 #if 1 00960 /* Backward: 00961 * This clause is for 'byte for byte' 00962 * backward compatibility. 00963 * Strickly speaking, it is 'bug for bug'. 00964 */ 00965 || ncap->nelems == 0 00966 #endif 00967 ) 00968 { 00969 /* 00970 * Handle empty netcdf 00971 */ 00972 const size_t nosz = 0; 00973 00974 status = v1h_put_NCtype(psp, NC_UNSPECIFIED); 00975 if(status != ENOERR) 00976 return status; 00977 status = v1h_put_size_t(psp, &nosz); 00978 if(status != ENOERR) 00979 return status; 00980 return ENOERR; 00981 } 00982 /* else */ 00983 00984 status = v1h_put_NCtype(psp, NC_VARIABLE); 00985 if(status != ENOERR) 00986 return status; 00987 status = v1h_put_size_t(psp, &ncap->nelems); 00988 if(status != ENOERR) 00989 return status; 00990 00991 { 00992 const NC_var **vpp = (const NC_var **)ncap->value; 00993 const NC_var *const *const end = &vpp[ncap->nelems]; 00994 for( /*NADA*/; vpp < end; vpp++) 00995 { 00996 status = v1h_put_NC_var(psp, *vpp); 00997 if(status) 00998 return status; 00999 } 01000 } 01001 return ENOERR; 01002 } |
|
Definition at line 192 of file v1hpg.c. References check_v1hs(), NCtype, ncx_put_int_int(), v1hs::pos, and X_SIZEOF_INT. Referenced by v1h_put_NC_attrarray(), v1h_put_NC_dimarray(), and v1h_put_NC_vararray().
00193 { 00194 const int itype = (int) type; 00195 int status = check_v1hs(psp, X_SIZEOF_INT); 00196 if(status != ENOERR) 00197 return status; 00198 status = ncx_put_int_int(psp->pos, &itype); 00199 psp->pos = (void *)((char *)psp->pos + X_SIZEOF_INT); 00200 return status; 00201 } |
|
Definition at line 125 of file v1hpg.c. References check_v1hs(), ncx_put_size_t(), v1hs::pos, and X_SIZEOF_SIZE_T. Referenced by v1h_put_NC_attr(), v1h_put_NC_attrarray(), v1h_put_NC_dim(), v1h_put_NC_dimarray(), v1h_put_NC_string(), v1h_put_NC_var(), and v1h_put_NC_vararray().
00126 { 00127 int status = check_v1hs(psp, X_SIZEOF_SIZE_T); 00128 if(status != ENOERR) 00129 return status; 00130 return ncx_put_size_t(&psp->pos, sp); 00131 } |
Variable Documentation
|
Definition at line 29 of file v1hpg.c. Referenced by nc_get_NC(), and ncx_put_NC(). |