add.c#170errvar(cdfp, varp)


#172     struct cdfvar *varp;


#177    switch (varp->type) {


#202		   varp->name, types);


#203    for (id = 0; id < varp->ndims; id++)


#205		     (long)cdfp->dims[varp->dims[id]].size,


#206		     id < varp->ndims - 1 ? ", " : "");


dumplib.c#1199ncbyte_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1202    res = snprintf(sout, PRIM_LEN, varp->fmt, *(signed char *)valp);


#1209ncchar_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1212    res = snprintf(sout, PRIM_LEN, varp->fmt, *(char *)valp);


#1219ncshort_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1222    res = snprintf(sout, PRIM_LEN, varp->fmt, *(short *)valp);


#1229ncint_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1232    res = snprintf(sout, PRIM_LEN, varp->fmt, *(int *)valp);


#1239ncfloat_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1244	res = snprintf(sout, PRIM_LEN, varp->fmt, vv);


#1254ncdouble_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1259	res = snprintf(sout, PRIM_LEN, varp->fmt, vv);


#1271double to_double(const ncvar_t *varp, const void *valp) {


#1273    switch (varp->type) {


#1311nctime_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1313    double vv = to_double(varp, valp);


#1318	cdRel2Iso(varp->timeinfo->calendar, varp->timeinfo->units, separator, vv, &sout[1]);


#1331ncubyte_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1334    res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned char *)valp);


#1341ncushort_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1344    res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned short *)valp);


#1351ncuint_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1354    res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned int *)valp);


#1361ncint64_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1364    res = snprintf(sout, PRIM_LEN, varp->fmt, *(long long *)valp);


#1371ncuint64_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1374    res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned long long *)valp);


#1381ncstring_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1382    return ncstring_typ_tostring(varp->tinfo, sfbf, valp);


#1387ncenum_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1388    return ncenum_typ_tostring(varp->tinfo, sfbf, valp);


#1394ncopaque_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1395    return ncopaque_typ_tostring(varp->tinfo, sfbf, valp);


#1400ncvlen_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1401    return ncvlen_typ_tostring(varp->tinfo, sfbf, valp);


#1405nccomp_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {


#1406    return nccomp_typ_tostring(varp->tinfo, sfbf, valp);


#1444set_tostring_func(ncvar_t *varp) {


#1459    if(varp->has_timeval && formatting_specs.string_times) {


#1460	varp->val_tostring = (val_tostring_func) nctime_val_tostring;


#1463    if( !is_user_defined_type(varp->type) ) {


#1464	varp->val_tostring = tostring_funcs[varp->type - 1];


#1468    switch(varp->tinfo->class) {


#1470	varp->val_tostring = (val_tostring_func) ncvlen_val_tostring;


#1473	varp->val_tostring = (val_tostring_func) ncopaque_val_tostring;


#1476	varp->val_tostring = (val_tostring_func) ncenum_val_tostring;


#1479	varp->val_tostring = (val_tostring_func) nccomp_val_tostring;


#1483	      varp->tinfo->class);


dumplib.h#74extern void set_tostring_func ( ncvar_t *varp);


#119int nctime_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp);


nc3internal.h#207free_NC_var(NC_var *varp);


#226NC_var_shape(NC_var *varp, const NC_dimarray *dims);


#232NC_check_vlen(NC_var *varp, size_t vlen_max);


#235NC_lookupvar(NC3_INFO* ncp, int varid, NC_var **varp);


#408fill_NC_var(NC3_INFO* ncp, const NC_var *varp, size_t varsize, size_t recno);


ncdump.c#980    const ncvar_t *varp


#987    if (varp->ndims > 0) {	/* no chunking for scalar variables */


#991	    pr_att_name(ncid, varp->name, NC_ATT_STORAGE);


#996	    pr_att_name(ncid, varp->name, NC_ATT_STORAGE);


#998	    chunkp = (size_t *) emalloc(sizeof(size_t) * (varp->ndims + 1) );


#1001	    pr_att_name(ncid, varp->name, NC_ATT_CHUNKING);


#1003	    for(i = 0; i < varp->ndims; i++) {


#1004		printf("%lu%s", (unsigned long)chunkp[i], i+1 < varp->ndims ? ", " : " ;\n");


#1016	    pr_att_name(ncid, varp->name, NC_ATT_DEFLATE);


#1020	    pr_att_name(ncid, varp->name, NC_ATT_SHUFFLE);


#1029	    pr_att_name(ncid, varp->name, NC_ATT_CHECKSUM);


#1034    if(varp->tinfo->size > 1) /* Endianness is meaningless for 1-byte types */


#1039	    pr_att_name(ncid, varp->name, NC_ATT_ENDIANNESS);


#1064	    pr_att_name(ncid, varp->name, NC_ATT_NOFILL);


#1222pr_shape(ncvar_t* varp, ncdim_t *dims)


#1228    if (varp->ndims == 0)


#1230    for (id = 0; id < varp->ndims; id++) {


#1231	shapelen += strlen(dims[varp->dims[id]].name) + 1;


#1235    for (id = 0; id < varp->ndims; id++) {


#1237	strlcat(shape, dims[varp->dims[id]].name, shapelen);


#1238	strlcat(shape, id < varp->ndims-1 ? " " : "", shapelen);


putget.c#31readNCv(const NC3_INFO* ncp, const NC_var* varp, const size_t* start,


#34writeNCv(NC3_INFO* ncp, const NC_var* varp, const size_t* start,


#341fill_NC_var(NC3_INFO* ncp, const NC_var *varp, size_t varsize, size_t recno)


#344	const size_t step = varp->xsz;


#346	const size_t xsz = varp->xsz * nelems;


#357	attrpp = NC_findattr(&varp->attrs, _FillValue);


#361		if( (*attrpp)->type != varp->type || (*attrpp)->nelems != 1 )


#388		switch(varp->type){


#443	offset = varp->begin;


#444	if(IS_RECVAR(varp))


#531NCfillspecialrecord(NC3_INFO* ncp, const NC_var *varp, size_t recno)


#534    assert(IS_RECVAR(varp));


#535    status = fill_NC_var(ncp, varp, ncp->recsize, recno);


#555	const NC_var *varp = NULL;


#565		varp = *varpp;


#568	assert(varp != NULL);


#569	assert( IS_RECVAR(varp) );


#571		const off_t offset = varp->begin


#573				+ (off_t)(varp->len - varp->xsz);


#577		status = ncio_get(ncp->nciop, offset, varp->xsz,


#581		(void)memset(xp, 0, varp->xsz);


#726NCcoordck(NC3_INFO* ncp, const NC_var *varp, const size_t *coord)


#731	if(varp->ndims == 0)


#734	if(IS_RECVAR(varp))


#753		up = varp->shape + 1;


#758		up = varp->shape;


#763		coord, varp->ndims, ip );


#766	for(; ip < coord + varp->ndims; ip++, up++)


#788NCedgeck(const NC3_INFO* ncp, const NC_var *varp,


#791	const size_t *const end = start + varp->ndims;


#792	const size_t *shp = varp->shape;


#794	if(varp->ndims == 0)


#797	if(IS_RECVAR(varp))


#821NC_varoffset(const NC3_INFO* ncp, const NC_var *varp, const size_t *coord)


#823	if(varp->ndims == 0) /* 'scalar' variable */


#824		return varp->begin;


#826	if(varp->ndims == 1)


#828		if(IS_RECVAR(varp))


#829			return varp->begin +


#832		return varp->begin + (off_t)(*coord) * (off_t)varp->xsz;


#836		off_t lcoord = (off_t)coord[varp->ndims -1];


#838		off_t *up = varp->dsizes +1;


#840		const off_t *const end = varp->dsizes + varp->ndims;


#842		if(IS_RECVAR(varp))


#848		lcoord *= varp->xsz;


#850		if(IS_RECVAR(varp))


#853		lcoord += varp->begin;


#861putNCvx_char_char(NC3_INFO* ncp, const NC_var *varp,


#864	off_t offset = NC_varoffset(ncp, varp, start);


#865	size_t remaining = varp->xsz * nelems;


#877		size_t nput = ncx_howmany(varp->type, extent);


#907putNCvx_schar_schar(NC3_INFO* ncp, const NC_var *varp,


#910	off_t offset = NC_varoffset(ncp, varp, start);


#911	size_t remaining = varp->xsz * nelems;


#923		size_t nput = ncx_howmany(varp->type, extent);


#952putNCvx_schar_uchar(NC3_INFO* ncp, const NC_var *varp,


#955	off_t offset = NC_varoffset(ncp, varp, start);


#956	size_t remaining = varp->xsz * nelems;


#968		size_t nput = ncx_howmany(varp->type, extent);


#997putNCvx_schar_short(NC3_INFO* ncp, const NC_var *varp,


#1000	off_t offset = NC_varoffset(ncp, varp, start);


#1001	size_t remaining = varp->xsz * nelems;


#1013		size_t nput = ncx_howmany(varp->type, extent);


#1042putNCvx_schar_int(NC3_INFO* ncp, const NC_var *varp,


#1045	off_t offset = NC_varoffset(ncp, varp, start);


#1046	size_t remaining = varp->xsz * nelems;


#1058		size_t nput = ncx_howmany(varp->type, extent);


#1087putNCvx_schar_float(NC3_INFO* ncp, const NC_var *varp,


#1090	off_t offset = NC_varoffset(ncp, varp, start);


#1091	size_t remaining = varp->xsz * nelems;


#1103		size_t nput = ncx_howmany(varp->type, extent);


#1132putNCvx_schar_double(NC3_INFO* ncp, const NC_var *varp,


#1135	off_t offset = NC_varoffset(ncp, varp, start);


#1136	size_t remaining = varp->xsz * nelems;


#1148		size_t nput = ncx_howmany(varp->type, extent);


#1177putNCvx_schar_longlong(NC3_INFO* ncp, const NC_var *varp,


#1180	off_t offset = NC_varoffset(ncp, varp, start);


#1181	size_t remaining = varp->xsz * nelems;


#1193		size_t nput = ncx_howmany(varp->type, extent);


#1222putNCvx_schar_ushort(NC3_INFO* ncp, const NC_var *varp,


#1225	off_t offset = NC_varoffset(ncp, varp, start);


#1226	size_t remaining = varp->xsz * nelems;


#1238		size_t nput = ncx_howmany(varp->type, extent);


#1267putNCvx_schar_uint(NC3_INFO* ncp, const NC_var *varp,


#1270	off_t offset = NC_varoffset(ncp, varp, start);


#1271	size_t remaining = varp->xsz * nelems;


#1283		size_t nput = ncx_howmany(varp->type, extent);


#1312putNCvx_schar_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#1315	off_t offset = NC_varoffset(ncp, varp, start);


#1316	size_t remaining = varp->xsz * nelems;


#1328		size_t nput = ncx_howmany(varp->type, extent);


#1358putNCvx_short_schar(NC3_INFO* ncp, const NC_var *varp,


#1361	off_t offset = NC_varoffset(ncp, varp, start);


#1362	size_t remaining = varp->xsz * nelems;


#1374		size_t nput = ncx_howmany(varp->type, extent);


#1403putNCvx_short_uchar(NC3_INFO* ncp, const NC_var *varp,


#1406	off_t offset = NC_varoffset(ncp, varp, start);


#1407	size_t remaining = varp->xsz * nelems;


#1419		size_t nput = ncx_howmany(varp->type, extent);


#1448putNCvx_short_short(NC3_INFO* ncp, const NC_var *varp,


#1451	off_t offset = NC_varoffset(ncp, varp, start);


#1452	size_t remaining = varp->xsz * nelems;


#1464		size_t nput = ncx_howmany(varp->type, extent);


#1493putNCvx_short_int(NC3_INFO* ncp, const NC_var *varp,


#1496	off_t offset = NC_varoffset(ncp, varp, start);


#1497	size_t remaining = varp->xsz * nelems;


#1509		size_t nput = ncx_howmany(varp->type, extent);


#1538putNCvx_short_float(NC3_INFO* ncp, const NC_var *varp,


#1541	off_t offset = NC_varoffset(ncp, varp, start);


#1542	size_t remaining = varp->xsz * nelems;


#1554		size_t nput = ncx_howmany(varp->type, extent);


#1583putNCvx_short_double(NC3_INFO* ncp, const NC_var *varp,


#1586	off_t offset = NC_varoffset(ncp, varp, start);


#1587	size_t remaining = varp->xsz * nelems;


#1599		size_t nput = ncx_howmany(varp->type, extent);


#1628putNCvx_short_longlong(NC3_INFO* ncp, const NC_var *varp,


#1631	off_t offset = NC_varoffset(ncp, varp, start);


#1632	size_t remaining = varp->xsz * nelems;


#1644		size_t nput = ncx_howmany(varp->type, extent);


#1673putNCvx_short_ushort(NC3_INFO* ncp, const NC_var *varp,


#1676	off_t offset = NC_varoffset(ncp, varp, start);


#1677	size_t remaining = varp->xsz * nelems;


#1689		size_t nput = ncx_howmany(varp->type, extent);


#1718putNCvx_short_uint(NC3_INFO* ncp, const NC_var *varp,


#1721	off_t offset = NC_varoffset(ncp, varp, start);


#1722	size_t remaining = varp->xsz * nelems;


#1734		size_t nput = ncx_howmany(varp->type, extent);


#1763putNCvx_short_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#1766	off_t offset = NC_varoffset(ncp, varp, start);


#1767	size_t remaining = varp->xsz * nelems;


#1779		size_t nput = ncx_howmany(varp->type, extent);


#1809putNCvx_int_schar(NC3_INFO* ncp, const NC_var *varp,


#1812	off_t offset = NC_varoffset(ncp, varp, start);


#1813	size_t remaining = varp->xsz * nelems;


#1825		size_t nput = ncx_howmany(varp->type, extent);


#1854putNCvx_int_uchar(NC3_INFO* ncp, const NC_var *varp,


#1857	off_t offset = NC_varoffset(ncp, varp, start);


#1858	size_t remaining = varp->xsz * nelems;


#1870		size_t nput = ncx_howmany(varp->type, extent);


#1899putNCvx_int_short(NC3_INFO* ncp, const NC_var *varp,


#1902	off_t offset = NC_varoffset(ncp, varp, start);


#1903	size_t remaining = varp->xsz * nelems;


#1915		size_t nput = ncx_howmany(varp->type, extent);


#1944putNCvx_int_int(NC3_INFO* ncp, const NC_var *varp,


#1947	off_t offset = NC_varoffset(ncp, varp, start);


#1948	size_t remaining = varp->xsz * nelems;


#1960		size_t nput = ncx_howmany(varp->type, extent);


#1989putNCvx_int_float(NC3_INFO* ncp, const NC_var *varp,


#1992	off_t offset = NC_varoffset(ncp, varp, start);


#1993	size_t remaining = varp->xsz * nelems;


#2005		size_t nput = ncx_howmany(varp->type, extent);


#2034putNCvx_int_double(NC3_INFO* ncp, const NC_var *varp,


#2037	off_t offset = NC_varoffset(ncp, varp, start);


#2038	size_t remaining = varp->xsz * nelems;


#2050		size_t nput = ncx_howmany(varp->type, extent);


#2079putNCvx_int_longlong(NC3_INFO* ncp, const NC_var *varp,


#2082	off_t offset = NC_varoffset(ncp, varp, start);


#2083	size_t remaining = varp->xsz * nelems;


#2095		size_t nput = ncx_howmany(varp->type, extent);


#2124putNCvx_int_ushort(NC3_INFO* ncp, const NC_var *varp,


#2127	off_t offset = NC_varoffset(ncp, varp, start);


#2128	size_t remaining = varp->xsz * nelems;


#2140		size_t nput = ncx_howmany(varp->type, extent);


#2169putNCvx_int_uint(NC3_INFO* ncp, const NC_var *varp,


#2172	off_t offset = NC_varoffset(ncp, varp, start);


#2173	size_t remaining = varp->xsz * nelems;


#2185		size_t nput = ncx_howmany(varp->type, extent);


#2214putNCvx_int_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#2217	off_t offset = NC_varoffset(ncp, varp, start);


#2218	size_t remaining = varp->xsz * nelems;


#2230		size_t nput = ncx_howmany(varp->type, extent);


#2260putNCvx_float_schar(NC3_INFO* ncp, const NC_var *varp,


#2263	off_t offset = NC_varoffset(ncp, varp, start);


#2264	size_t remaining = varp->xsz * nelems;


#2276		size_t nput = ncx_howmany(varp->type, extent);


#2305putNCvx_float_uchar(NC3_INFO* ncp, const NC_var *varp,


#2308	off_t offset = NC_varoffset(ncp, varp, start);


#2309	size_t remaining = varp->xsz * nelems;


#2321		size_t nput = ncx_howmany(varp->type, extent);


#2350putNCvx_float_short(NC3_INFO* ncp, const NC_var *varp,


#2353	off_t offset = NC_varoffset(ncp, varp, start);


#2354	size_t remaining = varp->xsz * nelems;


#2366		size_t nput = ncx_howmany(varp->type, extent);


#2395putNCvx_float_int(NC3_INFO* ncp, const NC_var *varp,


#2398	off_t offset = NC_varoffset(ncp, varp, start);


#2399	size_t remaining = varp->xsz * nelems;


#2411		size_t nput = ncx_howmany(varp->type, extent);


#2440putNCvx_float_float(NC3_INFO* ncp, const NC_var *varp,


#2443	off_t offset = NC_varoffset(ncp, varp, start);


#2444	size_t remaining = varp->xsz * nelems;


#2456		size_t nput = ncx_howmany(varp->type, extent);


#2485putNCvx_float_double(NC3_INFO* ncp, const NC_var *varp,


#2488	off_t offset = NC_varoffset(ncp, varp, start);


#2489	size_t remaining = varp->xsz * nelems;


#2501		size_t nput = ncx_howmany(varp->type, extent);


#2530putNCvx_float_longlong(NC3_INFO* ncp, const NC_var *varp,


#2533	off_t offset = NC_varoffset(ncp, varp, start);


#2534	size_t remaining = varp->xsz * nelems;


#2546		size_t nput = ncx_howmany(varp->type, extent);


#2575putNCvx_float_ushort(NC3_INFO* ncp, const NC_var *varp,


#2578	off_t offset = NC_varoffset(ncp, varp, start);


#2579	size_t remaining = varp->xsz * nelems;


#2591		size_t nput = ncx_howmany(varp->type, extent);


#2620putNCvx_float_uint(NC3_INFO* ncp, const NC_var *varp,


#2623	off_t offset = NC_varoffset(ncp, varp, start);


#2624	size_t remaining = varp->xsz * nelems;


#2636		size_t nput = ncx_howmany(varp->type, extent);


#2665putNCvx_float_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#2668	off_t offset = NC_varoffset(ncp, varp, start);


#2669	size_t remaining = varp->xsz * nelems;


#2681		size_t nput = ncx_howmany(varp->type, extent);


#2711putNCvx_double_schar(NC3_INFO* ncp, const NC_var *varp,


#2714	off_t offset = NC_varoffset(ncp, varp, start);


#2715	size_t remaining = varp->xsz * nelems;


#2727		size_t nput = ncx_howmany(varp->type, extent);


#2756putNCvx_double_uchar(NC3_INFO* ncp, const NC_var *varp,


#2759	off_t offset = NC_varoffset(ncp, varp, start);


#2760	size_t remaining = varp->xsz * nelems;


#2772		size_t nput = ncx_howmany(varp->type, extent);


#2801putNCvx_double_short(NC3_INFO* ncp, const NC_var *varp,


#2804	off_t offset = NC_varoffset(ncp, varp, start);


#2805	size_t remaining = varp->xsz * nelems;


#2817		size_t nput = ncx_howmany(varp->type, extent);


#2846putNCvx_double_int(NC3_INFO* ncp, const NC_var *varp,


#2849	off_t offset = NC_varoffset(ncp, varp, start);


#2850	size_t remaining = varp->xsz * nelems;


#2862		size_t nput = ncx_howmany(varp->type, extent);


#2891putNCvx_double_float(NC3_INFO* ncp, const NC_var *varp,


#2894	off_t offset = NC_varoffset(ncp, varp, start);


#2895	size_t remaining = varp->xsz * nelems;


#2907		size_t nput = ncx_howmany(varp->type, extent);


#2936putNCvx_double_double(NC3_INFO* ncp, const NC_var *varp,


#2939	off_t offset = NC_varoffset(ncp, varp, start);


#2940	size_t remaining = varp->xsz * nelems;


#2952		size_t nput = ncx_howmany(varp->type, extent);


#2981putNCvx_double_longlong(NC3_INFO* ncp, const NC_var *varp,


#2984	off_t offset = NC_varoffset(ncp, varp, start);


#2985	size_t remaining = varp->xsz * nelems;


#2997		size_t nput = ncx_howmany(varp->type, extent);


#3026putNCvx_double_ushort(NC3_INFO* ncp, const NC_var *varp,


#3029	off_t offset = NC_varoffset(ncp, varp, start);


#3030	size_t remaining = varp->xsz * nelems;


#3042		size_t nput = ncx_howmany(varp->type, extent);


#3071putNCvx_double_uint(NC3_INFO* ncp, const NC_var *varp,


#3074	off_t offset = NC_varoffset(ncp, varp, start);


#3075	size_t remaining = varp->xsz * nelems;


#3087		size_t nput = ncx_howmany(varp->type, extent);


#3116putNCvx_double_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#3119	off_t offset = NC_varoffset(ncp, varp, start);


#3120	size_t remaining = varp->xsz * nelems;


#3132		size_t nput = ncx_howmany(varp->type, extent);


#3162putNCvx_uchar_schar(NC3_INFO* ncp, const NC_var *varp,


#3165	off_t offset = NC_varoffset(ncp, varp, start);


#3166	size_t remaining = varp->xsz * nelems;


#3178		size_t nput = ncx_howmany(varp->type, extent);


#3207putNCvx_uchar_uchar(NC3_INFO* ncp, const NC_var *varp,


#3210	off_t offset = NC_varoffset(ncp, varp, start);


#3211	size_t remaining = varp->xsz * nelems;


#3223		size_t nput = ncx_howmany(varp->type, extent);


#3252putNCvx_uchar_short(NC3_INFO* ncp, const NC_var *varp,


#3255	off_t offset = NC_varoffset(ncp, varp, start);


#3256	size_t remaining = varp->xsz * nelems;


#3268		size_t nput = ncx_howmany(varp->type, extent);


#3297putNCvx_uchar_int(NC3_INFO* ncp, const NC_var *varp,


#3300	off_t offset = NC_varoffset(ncp, varp, start);


#3301	size_t remaining = varp->xsz * nelems;


#3313		size_t nput = ncx_howmany(varp->type, extent);


#3342putNCvx_uchar_float(NC3_INFO* ncp, const NC_var *varp,


#3345	off_t offset = NC_varoffset(ncp, varp, start);


#3346	size_t remaining = varp->xsz * nelems;


#3358		size_t nput = ncx_howmany(varp->type, extent);


#3387putNCvx_uchar_double(NC3_INFO* ncp, const NC_var *varp,


#3390	off_t offset = NC_varoffset(ncp, varp, start);


#3391	size_t remaining = varp->xsz * nelems;


#3403		size_t nput = ncx_howmany(varp->type, extent);


#3432putNCvx_uchar_longlong(NC3_INFO* ncp, const NC_var *varp,


#3435	off_t offset = NC_varoffset(ncp, varp, start);


#3436	size_t remaining = varp->xsz * nelems;


#3448		size_t nput = ncx_howmany(varp->type, extent);


#3477putNCvx_uchar_ushort(NC3_INFO* ncp, const NC_var *varp,


#3480	off_t offset = NC_varoffset(ncp, varp, start);


#3481	size_t remaining = varp->xsz * nelems;


#3493		size_t nput = ncx_howmany(varp->type, extent);


#3522putNCvx_uchar_uint(NC3_INFO* ncp, const NC_var *varp,


#3525	off_t offset = NC_varoffset(ncp, varp, start);


#3526	size_t remaining = varp->xsz * nelems;


#3538		size_t nput = ncx_howmany(varp->type, extent);


#3567putNCvx_uchar_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#3570	off_t offset = NC_varoffset(ncp, varp, start);


#3571	size_t remaining = varp->xsz * nelems;


#3583		size_t nput = ncx_howmany(varp->type, extent);


#3613putNCvx_ushort_schar(NC3_INFO* ncp, const NC_var *varp,


#3616	off_t offset = NC_varoffset(ncp, varp, start);


#3617	size_t remaining = varp->xsz * nelems;


#3629		size_t nput = ncx_howmany(varp->type, extent);


#3658putNCvx_ushort_uchar(NC3_INFO* ncp, const NC_var *varp,


#3661	off_t offset = NC_varoffset(ncp, varp, start);


#3662	size_t remaining = varp->xsz * nelems;


#3674		size_t nput = ncx_howmany(varp->type, extent);


#3703putNCvx_ushort_short(NC3_INFO* ncp, const NC_var *varp,


#3706	off_t offset = NC_varoffset(ncp, varp, start);


#3707	size_t remaining = varp->xsz * nelems;


#3719		size_t nput = ncx_howmany(varp->type, extent);


#3748putNCvx_ushort_int(NC3_INFO* ncp, const NC_var *varp,


#3751	off_t offset = NC_varoffset(ncp, varp, start);


#3752	size_t remaining = varp->xsz * nelems;


#3764		size_t nput = ncx_howmany(varp->type, extent);


#3793putNCvx_ushort_float(NC3_INFO* ncp, const NC_var *varp,


#3796	off_t offset = NC_varoffset(ncp, varp, start);


#3797	size_t remaining = varp->xsz * nelems;


#3809		size_t nput = ncx_howmany(varp->type, extent);


#3838putNCvx_ushort_double(NC3_INFO* ncp, const NC_var *varp,


#3841	off_t offset = NC_varoffset(ncp, varp, start);


#3842	size_t remaining = varp->xsz * nelems;


#3854		size_t nput = ncx_howmany(varp->type, extent);


#3883putNCvx_ushort_longlong(NC3_INFO* ncp, const NC_var *varp,


#3886	off_t offset = NC_varoffset(ncp, varp, start);


#3887	size_t remaining = varp->xsz * nelems;


#3899		size_t nput = ncx_howmany(varp->type, extent);


#3928putNCvx_ushort_ushort(NC3_INFO* ncp, const NC_var *varp,


#3931	off_t offset = NC_varoffset(ncp, varp, start);


#3932	size_t remaining = varp->xsz * nelems;


#3944		size_t nput = ncx_howmany(varp->type, extent);


#3973putNCvx_ushort_uint(NC3_INFO* ncp, const NC_var *varp,


#3976	off_t offset = NC_varoffset(ncp, varp, start);


#3977	size_t remaining = varp->xsz * nelems;


#3989		size_t nput = ncx_howmany(varp->type, extent);


#4018putNCvx_ushort_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#4021	off_t offset = NC_varoffset(ncp, varp, start);


#4022	size_t remaining = varp->xsz * nelems;


#4034		size_t nput = ncx_howmany(varp->type, extent);


#4064putNCvx_uint_schar(NC3_INFO* ncp, const NC_var *varp,


#4067	off_t offset = NC_varoffset(ncp, varp, start);


#4068	size_t remaining = varp->xsz * nelems;


#4080		size_t nput = ncx_howmany(varp->type, extent);


#4109putNCvx_uint_uchar(NC3_INFO* ncp, const NC_var *varp,


#4112	off_t offset = NC_varoffset(ncp, varp, start);


#4113	size_t remaining = varp->xsz * nelems;


#4125		size_t nput = ncx_howmany(varp->type, extent);


#4154putNCvx_uint_short(NC3_INFO* ncp, const NC_var *varp,


#4157	off_t offset = NC_varoffset(ncp, varp, start);


#4158	size_t remaining = varp->xsz * nelems;


#4170		size_t nput = ncx_howmany(varp->type, extent);


#4199putNCvx_uint_int(NC3_INFO* ncp, const NC_var *varp,


#4202	off_t offset = NC_varoffset(ncp, varp, start);


#4203	size_t remaining = varp->xsz * nelems;


#4215		size_t nput = ncx_howmany(varp->type, extent);


#4244putNCvx_uint_float(NC3_INFO* ncp, const NC_var *varp,


#4247	off_t offset = NC_varoffset(ncp, varp, start);


#4248	size_t remaining = varp->xsz * nelems;


#4260		size_t nput = ncx_howmany(varp->type, extent);


#4289putNCvx_uint_double(NC3_INFO* ncp, const NC_var *varp,


#4292	off_t offset = NC_varoffset(ncp, varp, start);


#4293	size_t remaining = varp->xsz * nelems;


#4305		size_t nput = ncx_howmany(varp->type, extent);


#4334putNCvx_uint_longlong(NC3_INFO* ncp, const NC_var *varp,


#4337	off_t offset = NC_varoffset(ncp, varp, start);


#4338	size_t remaining = varp->xsz * nelems;


#4350		size_t nput = ncx_howmany(varp->type, extent);


#4379putNCvx_uint_ushort(NC3_INFO* ncp, const NC_var *varp,


#4382	off_t offset = NC_varoffset(ncp, varp, start);


#4383	size_t remaining = varp->xsz * nelems;


#4395		size_t nput = ncx_howmany(varp->type, extent);


#4424putNCvx_uint_uint(NC3_INFO* ncp, const NC_var *varp,


#4427	off_t offset = NC_varoffset(ncp, varp, start);


#4428	size_t remaining = varp->xsz * nelems;


#4440		size_t nput = ncx_howmany(varp->type, extent);


#4469putNCvx_uint_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#4472	off_t offset = NC_varoffset(ncp, varp, start);


#4473	size_t remaining = varp->xsz * nelems;


#4485		size_t nput = ncx_howmany(varp->type, extent);


#4515putNCvx_longlong_schar(NC3_INFO* ncp, const NC_var *varp,


#4518	off_t offset = NC_varoffset(ncp, varp, start);


#4519	size_t remaining = varp->xsz * nelems;


#4531		size_t nput = ncx_howmany(varp->type, extent);


#4560putNCvx_longlong_uchar(NC3_INFO* ncp, const NC_var *varp,


#4563	off_t offset = NC_varoffset(ncp, varp, start);


#4564	size_t remaining = varp->xsz * nelems;


#4576		size_t nput = ncx_howmany(varp->type, extent);


#4605putNCvx_longlong_short(NC3_INFO* ncp, const NC_var *varp,


#4608	off_t offset = NC_varoffset(ncp, varp, start);


#4609	size_t remaining = varp->xsz * nelems;


#4621		size_t nput = ncx_howmany(varp->type, extent);


#4650putNCvx_longlong_int(NC3_INFO* ncp, const NC_var *varp,


#4653	off_t offset = NC_varoffset(ncp, varp, start);


#4654	size_t remaining = varp->xsz * nelems;


#4666		size_t nput = ncx_howmany(varp->type, extent);


#4695putNCvx_longlong_float(NC3_INFO* ncp, const NC_var *varp,


#4698	off_t offset = NC_varoffset(ncp, varp, start);


#4699	size_t remaining = varp->xsz * nelems;


#4711		size_t nput = ncx_howmany(varp->type, extent);


#4740putNCvx_longlong_double(NC3_INFO* ncp, const NC_var *varp,


#4743	off_t offset = NC_varoffset(ncp, varp, start);


#4744	size_t remaining = varp->xsz * nelems;


#4756		size_t nput = ncx_howmany(varp->type, extent);


#4785putNCvx_longlong_longlong(NC3_INFO* ncp, const NC_var *varp,


#4788	off_t offset = NC_varoffset(ncp, varp, start);


#4789	size_t remaining = varp->xsz * nelems;


#4801		size_t nput = ncx_howmany(varp->type, extent);


#4830putNCvx_longlong_ushort(NC3_INFO* ncp, const NC_var *varp,


#4833	off_t offset = NC_varoffset(ncp, varp, start);


#4834	size_t remaining = varp->xsz * nelems;


#4846		size_t nput = ncx_howmany(varp->type, extent);


#4875putNCvx_longlong_uint(NC3_INFO* ncp, const NC_var *varp,


#4878	off_t offset = NC_varoffset(ncp, varp, start);


#4879	size_t remaining = varp->xsz * nelems;


#4891		size_t nput = ncx_howmany(varp->type, extent);


#4920putNCvx_longlong_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#4923	off_t offset = NC_varoffset(ncp, varp, start);


#4924	size_t remaining = varp->xsz * nelems;


#4936		size_t nput = ncx_howmany(varp->type, extent);


#4966putNCvx_ulonglong_schar(NC3_INFO* ncp, const NC_var *varp,


#4969	off_t offset = NC_varoffset(ncp, varp, start);


#4970	size_t remaining = varp->xsz * nelems;


#4982		size_t nput = ncx_howmany(varp->type, extent);


#5011putNCvx_ulonglong_uchar(NC3_INFO* ncp, const NC_var *varp,


#5014	off_t offset = NC_varoffset(ncp, varp, start);


#5015	size_t remaining = varp->xsz * nelems;


#5027		size_t nput = ncx_howmany(varp->type, extent);


#5056putNCvx_ulonglong_short(NC3_INFO* ncp, const NC_var *varp,


#5059	off_t offset = NC_varoffset(ncp, varp, start);


#5060	size_t remaining = varp->xsz * nelems;


#5072		size_t nput = ncx_howmany(varp->type, extent);


#5101putNCvx_ulonglong_int(NC3_INFO* ncp, const NC_var *varp,


#5104	off_t offset = NC_varoffset(ncp, varp, start);


#5105	size_t remaining = varp->xsz * nelems;


#5117		size_t nput = ncx_howmany(varp->type, extent);


#5146putNCvx_ulonglong_float(NC3_INFO* ncp, const NC_var *varp,


#5149	off_t offset = NC_varoffset(ncp, varp, start);


#5150	size_t remaining = varp->xsz * nelems;


#5162		size_t nput = ncx_howmany(varp->type, extent);


#5191putNCvx_ulonglong_double(NC3_INFO* ncp, const NC_var *varp,


#5194	off_t offset = NC_varoffset(ncp, varp, start);


#5195	size_t remaining = varp->xsz * nelems;


#5207		size_t nput = ncx_howmany(varp->type, extent);


#5236putNCvx_ulonglong_longlong(NC3_INFO* ncp, const NC_var *varp,


#5239	off_t offset = NC_varoffset(ncp, varp, start);


#5240	size_t remaining = varp->xsz * nelems;


#5252		size_t nput = ncx_howmany(varp->type, extent);


#5281putNCvx_ulonglong_ushort(NC3_INFO* ncp, const NC_var *varp,


#5284	off_t offset = NC_varoffset(ncp, varp, start);


#5285	size_t remaining = varp->xsz * nelems;


#5297		size_t nput = ncx_howmany(varp->type, extent);


#5326putNCvx_ulonglong_uint(NC3_INFO* ncp, const NC_var *varp,


#5329	off_t offset = NC_varoffset(ncp, varp, start);


#5330	size_t remaining = varp->xsz * nelems;


#5342		size_t nput = ncx_howmany(varp->type, extent);


#5371putNCvx_ulonglong_ulonglong(NC3_INFO* ncp, const NC_var *varp,


#5374	off_t offset = NC_varoffset(ncp, varp, start);


#5375	size_t remaining = varp->xsz * nelems;


#5387		size_t nput = ncx_howmany(varp->type, extent);


#5418getNCvx_char_char(const NC3_INFO* ncp, const NC_var *varp,


#5421	off_t offset = NC_varoffset(ncp, varp, start);


#5422	size_t remaining = varp->xsz * nelems;


#5434		size_t nget = ncx_howmany(varp->type, extent);


#5459getNCvx_schar_schar(const NC3_INFO* ncp, const NC_var *varp,


#5462	off_t offset = NC_varoffset(ncp, varp, start);


#5463	size_t remaining = varp->xsz * nelems;


#5475		size_t nget = ncx_howmany(varp->type, extent);


#5499getNCvx_schar_short(const NC3_INFO* ncp, const NC_var *varp,


#5502	off_t offset = NC_varoffset(ncp, varp, start);


#5503	size_t remaining = varp->xsz * nelems;


#5515		size_t nget = ncx_howmany(varp->type, extent);


#5539getNCvx_schar_int(const NC3_INFO* ncp, const NC_var *varp,


#5542	off_t offset = NC_varoffset(ncp, varp, start);


#5543	size_t remaining = varp->xsz * nelems;


#5555		size_t nget = ncx_howmany(varp->type, extent);


#5579getNCvx_schar_float(const NC3_INFO* ncp, const NC_var *varp,


#5582	off_t offset = NC_varoffset(ncp, varp, start);


#5583	size_t remaining = varp->xsz * nelems;


#5595		size_t nget = ncx_howmany(varp->type, extent);


#5619getNCvx_schar_double(const NC3_INFO* ncp, const NC_var *varp,


#5622	off_t offset = NC_varoffset(ncp, varp, start);


#5623	size_t remaining = varp->xsz * nelems;


#5635		size_t nget = ncx_howmany(varp->type, extent);


#5659getNCvx_schar_longlong(const NC3_INFO* ncp, const NC_var *varp,


#5662	off_t offset = NC_varoffset(ncp, varp, start);


#5663	size_t remaining = varp->xsz * nelems;


#5675		size_t nget = ncx_howmany(varp->type, extent);


#5699getNCvx_schar_uint(const NC3_INFO* ncp, const NC_var *varp,


#5702	off_t offset = NC_varoffset(ncp, varp, start);


#5703	size_t remaining = varp->xsz * nelems;


#5715		size_t nget = ncx_howmany(varp->type, extent);


#5739getNCvx_schar_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#5742	off_t offset = NC_varoffset(ncp, varp, start);


#5743	size_t remaining = varp->xsz * nelems;


#5755		size_t nget = ncx_howmany(varp->type, extent);


#5779getNCvx_schar_uchar(const NC3_INFO* ncp, const NC_var *varp,


#5782	off_t offset = NC_varoffset(ncp, varp, start);


#5783	size_t remaining = varp->xsz * nelems;


#5795		size_t nget = ncx_howmany(varp->type, extent);


#5819getNCvx_schar_ushort(const NC3_INFO* ncp, const NC_var *varp,


#5822	off_t offset = NC_varoffset(ncp, varp, start);


#5823	size_t remaining = varp->xsz * nelems;


#5835		size_t nget = ncx_howmany(varp->type, extent);


#5860getNCvx_short_schar(const NC3_INFO* ncp, const NC_var *varp,


#5863	off_t offset = NC_varoffset(ncp, varp, start);


#5864	size_t remaining = varp->xsz * nelems;


#5876		size_t nget = ncx_howmany(varp->type, extent);


#5900getNCvx_short_uchar(const NC3_INFO* ncp, const NC_var *varp,


#5903	off_t offset = NC_varoffset(ncp, varp, start);


#5904	size_t remaining = varp->xsz * nelems;


#5916		size_t nget = ncx_howmany(varp->type, extent);


#5940getNCvx_short_short(const NC3_INFO* ncp, const NC_var *varp,


#5943	off_t offset = NC_varoffset(ncp, varp, start);


#5944	size_t remaining = varp->xsz * nelems;


#5956		size_t nget = ncx_howmany(varp->type, extent);


#5980getNCvx_short_int(const NC3_INFO* ncp, const NC_var *varp,


#5983	off_t offset = NC_varoffset(ncp, varp, start);


#5984	size_t remaining = varp->xsz * nelems;


#5996		size_t nget = ncx_howmany(varp->type, extent);


#6020getNCvx_short_float(const NC3_INFO* ncp, const NC_var *varp,


#6023	off_t offset = NC_varoffset(ncp, varp, start);


#6024	size_t remaining = varp->xsz * nelems;


#6036		size_t nget = ncx_howmany(varp->type, extent);


#6060getNCvx_short_double(const NC3_INFO* ncp, const NC_var *varp,


#6063	off_t offset = NC_varoffset(ncp, varp, start);


#6064	size_t remaining = varp->xsz * nelems;


#6076		size_t nget = ncx_howmany(varp->type, extent);


#6100getNCvx_short_longlong(const NC3_INFO* ncp, const NC_var *varp,


#6103	off_t offset = NC_varoffset(ncp, varp, start);


#6104	size_t remaining = varp->xsz * nelems;


#6116		size_t nget = ncx_howmany(varp->type, extent);


#6140getNCvx_short_uint(const NC3_INFO* ncp, const NC_var *varp,


#6143	off_t offset = NC_varoffset(ncp, varp, start);


#6144	size_t remaining = varp->xsz * nelems;


#6156		size_t nget = ncx_howmany(varp->type, extent);


#6180getNCvx_short_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#6183	off_t offset = NC_varoffset(ncp, varp, start);


#6184	size_t remaining = varp->xsz * nelems;


#6196		size_t nget = ncx_howmany(varp->type, extent);


#6220getNCvx_short_ushort(const NC3_INFO* ncp, const NC_var *varp,


#6223	off_t offset = NC_varoffset(ncp, varp, start);


#6224	size_t remaining = varp->xsz * nelems;


#6236		size_t nget = ncx_howmany(varp->type, extent);


#6261getNCvx_int_schar(const NC3_INFO* ncp, const NC_var *varp,


#6264	off_t offset = NC_varoffset(ncp, varp, start);


#6265	size_t remaining = varp->xsz * nelems;


#6277		size_t nget = ncx_howmany(varp->type, extent);


#6301getNCvx_int_uchar(const NC3_INFO* ncp, const NC_var *varp,


#6304	off_t offset = NC_varoffset(ncp, varp, start);


#6305	size_t remaining = varp->xsz * nelems;


#6317		size_t nget = ncx_howmany(varp->type, extent);


#6341getNCvx_int_short(const NC3_INFO* ncp, const NC_var *varp,


#6344	off_t offset = NC_varoffset(ncp, varp, start);


#6345	size_t remaining = varp->xsz * nelems;


#6357		size_t nget = ncx_howmany(varp->type, extent);


#6381getNCvx_int_int(const NC3_INFO* ncp, const NC_var *varp,


#6384	off_t offset = NC_varoffset(ncp, varp, start);


#6385	size_t remaining = varp->xsz * nelems;


#6397		size_t nget = ncx_howmany(varp->type, extent);


#6421getNCvx_int_float(const NC3_INFO* ncp, const NC_var *varp,


#6424	off_t offset = NC_varoffset(ncp, varp, start);


#6425	size_t remaining = varp->xsz * nelems;


#6437		size_t nget = ncx_howmany(varp->type, extent);


#6461getNCvx_int_double(const NC3_INFO* ncp, const NC_var *varp,


#6464	off_t offset = NC_varoffset(ncp, varp, start);


#6465	size_t remaining = varp->xsz * nelems;


#6477		size_t nget = ncx_howmany(varp->type, extent);


#6501getNCvx_int_longlong(const NC3_INFO* ncp, const NC_var *varp,


#6504	off_t offset = NC_varoffset(ncp, varp, start);


#6505	size_t remaining = varp->xsz * nelems;


#6517		size_t nget = ncx_howmany(varp->type, extent);


#6541getNCvx_int_uint(const NC3_INFO* ncp, const NC_var *varp,


#6544	off_t offset = NC_varoffset(ncp, varp, start);


#6545	size_t remaining = varp->xsz * nelems;


#6557		size_t nget = ncx_howmany(varp->type, extent);


#6581getNCvx_int_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#6584	off_t offset = NC_varoffset(ncp, varp, start);


#6585	size_t remaining = varp->xsz * nelems;


#6597		size_t nget = ncx_howmany(varp->type, extent);


#6621getNCvx_int_ushort(const NC3_INFO* ncp, const NC_var *varp,


#6624	off_t offset = NC_varoffset(ncp, varp, start);


#6625	size_t remaining = varp->xsz * nelems;


#6637		size_t nget = ncx_howmany(varp->type, extent);


#6662getNCvx_float_schar(const NC3_INFO* ncp, const NC_var *varp,


#6665	off_t offset = NC_varoffset(ncp, varp, start);


#6666	size_t remaining = varp->xsz * nelems;


#6678		size_t nget = ncx_howmany(varp->type, extent);


#6702getNCvx_float_uchar(const NC3_INFO* ncp, const NC_var *varp,


#6705	off_t offset = NC_varoffset(ncp, varp, start);


#6706	size_t remaining = varp->xsz * nelems;


#6718		size_t nget = ncx_howmany(varp->type, extent);


#6742getNCvx_float_short(const NC3_INFO* ncp, const NC_var *varp,


#6745	off_t offset = NC_varoffset(ncp, varp, start);


#6746	size_t remaining = varp->xsz * nelems;


#6758		size_t nget = ncx_howmany(varp->type, extent);


#6782getNCvx_float_int(const NC3_INFO* ncp, const NC_var *varp,


#6785	off_t offset = NC_varoffset(ncp, varp, start);


#6786	size_t remaining = varp->xsz * nelems;


#6798		size_t nget = ncx_howmany(varp->type, extent);


#6822getNCvx_float_float(const NC3_INFO* ncp, const NC_var *varp,


#6825	off_t offset = NC_varoffset(ncp, varp, start);


#6826	size_t remaining = varp->xsz * nelems;


#6838		size_t nget = ncx_howmany(varp->type, extent);


#6862getNCvx_float_double(const NC3_INFO* ncp, const NC_var *varp,


#6865	off_t offset = NC_varoffset(ncp, varp, start);


#6866	size_t remaining = varp->xsz * nelems;


#6878		size_t nget = ncx_howmany(varp->type, extent);


#6902getNCvx_float_longlong(const NC3_INFO* ncp, const NC_var *varp,


#6905	off_t offset = NC_varoffset(ncp, varp, start);


#6906	size_t remaining = varp->xsz * nelems;


#6918		size_t nget = ncx_howmany(varp->type, extent);


#6942getNCvx_float_uint(const NC3_INFO* ncp, const NC_var *varp,


#6945	off_t offset = NC_varoffset(ncp, varp, start);


#6946	size_t remaining = varp->xsz * nelems;


#6958		size_t nget = ncx_howmany(varp->type, extent);


#6982getNCvx_float_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#6985	off_t offset = NC_varoffset(ncp, varp, start);


#6986	size_t remaining = varp->xsz * nelems;


#6998		size_t nget = ncx_howmany(varp->type, extent);


#7022getNCvx_float_ushort(const NC3_INFO* ncp, const NC_var *varp,


#7025	off_t offset = NC_varoffset(ncp, varp, start);


#7026	size_t remaining = varp->xsz * nelems;


#7038		size_t nget = ncx_howmany(varp->type, extent);


#7063getNCvx_double_schar(const NC3_INFO* ncp, const NC_var *varp,


#7066	off_t offset = NC_varoffset(ncp, varp, start);


#7067	size_t remaining = varp->xsz * nelems;


#7079		size_t nget = ncx_howmany(varp->type, extent);


#7103getNCvx_double_uchar(const NC3_INFO* ncp, const NC_var *varp,


#7106	off_t offset = NC_varoffset(ncp, varp, start);


#7107	size_t remaining = varp->xsz * nelems;


#7119		size_t nget = ncx_howmany(varp->type, extent);


#7143getNCvx_double_short(const NC3_INFO* ncp, const NC_var *varp,


#7146	off_t offset = NC_varoffset(ncp, varp, start);


#7147	size_t remaining = varp->xsz * nelems;


#7159		size_t nget = ncx_howmany(varp->type, extent);


#7183getNCvx_double_int(const NC3_INFO* ncp, const NC_var *varp,


#7186	off_t offset = NC_varoffset(ncp, varp, start);


#7187	size_t remaining = varp->xsz * nelems;


#7199		size_t nget = ncx_howmany(varp->type, extent);


#7223getNCvx_double_float(const NC3_INFO* ncp, const NC_var *varp,


#7226	off_t offset = NC_varoffset(ncp, varp, start);


#7227	size_t remaining = varp->xsz * nelems;


#7239		size_t nget = ncx_howmany(varp->type, extent);


#7263getNCvx_double_double(const NC3_INFO* ncp, const NC_var *varp,


#7266	off_t offset = NC_varoffset(ncp, varp, start);


#7267	size_t remaining = varp->xsz * nelems;


#7279		size_t nget = ncx_howmany(varp->type, extent);


#7303getNCvx_double_longlong(const NC3_INFO* ncp, const NC_var *varp,


#7306	off_t offset = NC_varoffset(ncp, varp, start);


#7307	size_t remaining = varp->xsz * nelems;


#7319		size_t nget = ncx_howmany(varp->type, extent);


#7343getNCvx_double_uint(const NC3_INFO* ncp, const NC_var *varp,


#7346	off_t offset = NC_varoffset(ncp, varp, start);


#7347	size_t remaining = varp->xsz * nelems;


#7359		size_t nget = ncx_howmany(varp->type, extent);


#7383getNCvx_double_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#7386	off_t offset = NC_varoffset(ncp, varp, start);


#7387	size_t remaining = varp->xsz * nelems;


#7399		size_t nget = ncx_howmany(varp->type, extent);


#7423getNCvx_double_ushort(const NC3_INFO* ncp, const NC_var *varp,


#7426	off_t offset = NC_varoffset(ncp, varp, start);


#7427	size_t remaining = varp->xsz * nelems;


#7439		size_t nget = ncx_howmany(varp->type, extent);


#7464getNCvx_uchar_schar(const NC3_INFO* ncp, const NC_var *varp,


#7467	off_t offset = NC_varoffset(ncp, varp, start);


#7468	size_t remaining = varp->xsz * nelems;


#7480		size_t nget = ncx_howmany(varp->type, extent);


#7504getNCvx_uchar_uchar(const NC3_INFO* ncp, const NC_var *varp,


#7507	off_t offset = NC_varoffset(ncp, varp, start);


#7508	size_t remaining = varp->xsz * nelems;


#7520		size_t nget = ncx_howmany(varp->type, extent);


#7544getNCvx_uchar_short(const NC3_INFO* ncp, const NC_var *varp,


#7547	off_t offset = NC_varoffset(ncp, varp, start);


#7548	size_t remaining = varp->xsz * nelems;


#7560		size_t nget = ncx_howmany(varp->type, extent);


#7584getNCvx_uchar_int(const NC3_INFO* ncp, const NC_var *varp,


#7587	off_t offset = NC_varoffset(ncp, varp, start);


#7588	size_t remaining = varp->xsz * nelems;


#7600		size_t nget = ncx_howmany(varp->type, extent);


#7624getNCvx_uchar_float(const NC3_INFO* ncp, const NC_var *varp,


#7627	off_t offset = NC_varoffset(ncp, varp, start);


#7628	size_t remaining = varp->xsz * nelems;


#7640		size_t nget = ncx_howmany(varp->type, extent);


#7664getNCvx_uchar_double(const NC3_INFO* ncp, const NC_var *varp,


#7667	off_t offset = NC_varoffset(ncp, varp, start);


#7668	size_t remaining = varp->xsz * nelems;


#7680		size_t nget = ncx_howmany(varp->type, extent);


#7704getNCvx_uchar_longlong(const NC3_INFO* ncp, const NC_var *varp,


#7707	off_t offset = NC_varoffset(ncp, varp, start);


#7708	size_t remaining = varp->xsz * nelems;


#7720		size_t nget = ncx_howmany(varp->type, extent);


#7744getNCvx_uchar_uint(const NC3_INFO* ncp, const NC_var *varp,


#7747	off_t offset = NC_varoffset(ncp, varp, start);


#7748	size_t remaining = varp->xsz * nelems;


#7760		size_t nget = ncx_howmany(varp->type, extent);


#7784getNCvx_uchar_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#7787	off_t offset = NC_varoffset(ncp, varp, start);


#7788	size_t remaining = varp->xsz * nelems;


#7800		size_t nget = ncx_howmany(varp->type, extent);


#7824getNCvx_uchar_ushort(const NC3_INFO* ncp, const NC_var *varp,


#7827	off_t offset = NC_varoffset(ncp, varp, start);


#7828	size_t remaining = varp->xsz * nelems;


#7840		size_t nget = ncx_howmany(varp->type, extent);


#7865getNCvx_ushort_schar(const NC3_INFO* ncp, const NC_var *varp,


#7868	off_t offset = NC_varoffset(ncp, varp, start);


#7869	size_t remaining = varp->xsz * nelems;


#7881		size_t nget = ncx_howmany(varp->type, extent);


#7905getNCvx_ushort_uchar(const NC3_INFO* ncp, const NC_var *varp,


#7908	off_t offset = NC_varoffset(ncp, varp, start);


#7909	size_t remaining = varp->xsz * nelems;


#7921		size_t nget = ncx_howmany(varp->type, extent);


#7945getNCvx_ushort_short(const NC3_INFO* ncp, const NC_var *varp,


#7948	off_t offset = NC_varoffset(ncp, varp, start);


#7949	size_t remaining = varp->xsz * nelems;


#7961		size_t nget = ncx_howmany(varp->type, extent);


#7985getNCvx_ushort_int(const NC3_INFO* ncp, const NC_var *varp,


#7988	off_t offset = NC_varoffset(ncp, varp, start);


#7989	size_t remaining = varp->xsz * nelems;


#8001		size_t nget = ncx_howmany(varp->type, extent);


#8025getNCvx_ushort_float(const NC3_INFO* ncp, const NC_var *varp,


#8028	off_t offset = NC_varoffset(ncp, varp, start);


#8029	size_t remaining = varp->xsz * nelems;


#8041		size_t nget = ncx_howmany(varp->type, extent);


#8065getNCvx_ushort_double(const NC3_INFO* ncp, const NC_var *varp,


#8068	off_t offset = NC_varoffset(ncp, varp, start);


#8069	size_t remaining = varp->xsz * nelems;


#8081		size_t nget = ncx_howmany(varp->type, extent);


#8105getNCvx_ushort_longlong(const NC3_INFO* ncp, const NC_var *varp,


#8108	off_t offset = NC_varoffset(ncp, varp, start);


#8109	size_t remaining = varp->xsz * nelems;


#8121		size_t nget = ncx_howmany(varp->type, extent);


#8145getNCvx_ushort_uint(const NC3_INFO* ncp, const NC_var *varp,


#8148	off_t offset = NC_varoffset(ncp, varp, start);


#8149	size_t remaining = varp->xsz * nelems;


#8161		size_t nget = ncx_howmany(varp->type, extent);


#8185getNCvx_ushort_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#8188	off_t offset = NC_varoffset(ncp, varp, start);


#8189	size_t remaining = varp->xsz * nelems;


#8201		size_t nget = ncx_howmany(varp->type, extent);


#8225getNCvx_ushort_ushort(const NC3_INFO* ncp, const NC_var *varp,


#8228	off_t offset = NC_varoffset(ncp, varp, start);


#8229	size_t remaining = varp->xsz * nelems;


#8241		size_t nget = ncx_howmany(varp->type, extent);


#8266getNCvx_uint_schar(const NC3_INFO* ncp, const NC_var *varp,


#8269	off_t offset = NC_varoffset(ncp, varp, start);


#8270	size_t remaining = varp->xsz * nelems;


#8282		size_t nget = ncx_howmany(varp->type, extent);


#8306getNCvx_uint_uchar(const NC3_INFO* ncp, const NC_var *varp,


#8309	off_t offset = NC_varoffset(ncp, varp, start);


#8310	size_t remaining = varp->xsz * nelems;


#8322		size_t nget = ncx_howmany(varp->type, extent);


#8346getNCvx_uint_short(const NC3_INFO* ncp, const NC_var *varp,


#8349	off_t offset = NC_varoffset(ncp, varp, start);


#8350	size_t remaining = varp->xsz * nelems;


#8362		size_t nget = ncx_howmany(varp->type, extent);


#8386getNCvx_uint_int(const NC3_INFO* ncp, const NC_var *varp,


#8389	off_t offset = NC_varoffset(ncp, varp, start);


#8390	size_t remaining = varp->xsz * nelems;


#8402		size_t nget = ncx_howmany(varp->type, extent);


#8426getNCvx_uint_float(const NC3_INFO* ncp, const NC_var *varp,


#8429	off_t offset = NC_varoffset(ncp, varp, start);


#8430	size_t remaining = varp->xsz * nelems;


#8442		size_t nget = ncx_howmany(varp->type, extent);


#8466getNCvx_uint_double(const NC3_INFO* ncp, const NC_var *varp,


#8469	off_t offset = NC_varoffset(ncp, varp, start);


#8470	size_t remaining = varp->xsz * nelems;


#8482		size_t nget = ncx_howmany(varp->type, extent);


#8506getNCvx_uint_longlong(const NC3_INFO* ncp, const NC_var *varp,


#8509	off_t offset = NC_varoffset(ncp, varp, start);


#8510	size_t remaining = varp->xsz * nelems;


#8522		size_t nget = ncx_howmany(varp->type, extent);


#8546getNCvx_uint_uint(const NC3_INFO* ncp, const NC_var *varp,


#8549	off_t offset = NC_varoffset(ncp, varp, start);


#8550	size_t remaining = varp->xsz * nelems;


#8562		size_t nget = ncx_howmany(varp->type, extent);


#8586getNCvx_uint_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#8589	off_t offset = NC_varoffset(ncp, varp, start);


#8590	size_t remaining = varp->xsz * nelems;


#8602		size_t nget = ncx_howmany(varp->type, extent);


#8626getNCvx_uint_ushort(const NC3_INFO* ncp, const NC_var *varp,


#8629	off_t offset = NC_varoffset(ncp, varp, start);


#8630	size_t remaining = varp->xsz * nelems;


#8642		size_t nget = ncx_howmany(varp->type, extent);


#8667getNCvx_longlong_schar(const NC3_INFO* ncp, const NC_var *varp,


#8670	off_t offset = NC_varoffset(ncp, varp, start);


#8671	size_t remaining = varp->xsz * nelems;


#8683		size_t nget = ncx_howmany(varp->type, extent);


#8707getNCvx_longlong_uchar(const NC3_INFO* ncp, const NC_var *varp,


#8710	off_t offset = NC_varoffset(ncp, varp, start);


#8711	size_t remaining = varp->xsz * nelems;


#8723		size_t nget = ncx_howmany(varp->type, extent);


#8747getNCvx_longlong_short(const NC3_INFO* ncp, const NC_var *varp,


#8750	off_t offset = NC_varoffset(ncp, varp, start);


#8751	size_t remaining = varp->xsz * nelems;


#8763		size_t nget = ncx_howmany(varp->type, extent);


#8787getNCvx_longlong_int(const NC3_INFO* ncp, const NC_var *varp,


#8790	off_t offset = NC_varoffset(ncp, varp, start);


#8791	size_t remaining = varp->xsz * nelems;


#8803		size_t nget = ncx_howmany(varp->type, extent);


#8827getNCvx_longlong_float(const NC3_INFO* ncp, const NC_var *varp,


#8830	off_t offset = NC_varoffset(ncp, varp, start);


#8831	size_t remaining = varp->xsz * nelems;


#8843		size_t nget = ncx_howmany(varp->type, extent);


#8867getNCvx_longlong_double(const NC3_INFO* ncp, const NC_var *varp,


#8870	off_t offset = NC_varoffset(ncp, varp, start);


#8871	size_t remaining = varp->xsz * nelems;


#8883		size_t nget = ncx_howmany(varp->type, extent);


#8907getNCvx_longlong_longlong(const NC3_INFO* ncp, const NC_var *varp,


#8910	off_t offset = NC_varoffset(ncp, varp, start);


#8911	size_t remaining = varp->xsz * nelems;


#8923		size_t nget = ncx_howmany(varp->type, extent);


#8947getNCvx_longlong_uint(const NC3_INFO* ncp, const NC_var *varp,


#8950	off_t offset = NC_varoffset(ncp, varp, start);


#8951	size_t remaining = varp->xsz * nelems;


#8963		size_t nget = ncx_howmany(varp->type, extent);


#8987getNCvx_longlong_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#8990	off_t offset = NC_varoffset(ncp, varp, start);


#8991	size_t remaining = varp->xsz * nelems;


#9003		size_t nget = ncx_howmany(varp->type, extent);


#9027getNCvx_longlong_ushort(const NC3_INFO* ncp, const NC_var *varp,


#9030	off_t offset = NC_varoffset(ncp, varp, start);


#9031	size_t remaining = varp->xsz * nelems;


#9043		size_t nget = ncx_howmany(varp->type, extent);


#9068getNCvx_ulonglong_schar(const NC3_INFO* ncp, const NC_var *varp,


#9071	off_t offset = NC_varoffset(ncp, varp, start);


#9072	size_t remaining = varp->xsz * nelems;


#9084		size_t nget = ncx_howmany(varp->type, extent);


#9108getNCvx_ulonglong_uchar(const NC3_INFO* ncp, const NC_var *varp,


#9111	off_t offset = NC_varoffset(ncp, varp, start);


#9112	size_t remaining = varp->xsz * nelems;


#9124		size_t nget = ncx_howmany(varp->type, extent);


#9148getNCvx_ulonglong_short(const NC3_INFO* ncp, const NC_var *varp,


#9151	off_t offset = NC_varoffset(ncp, varp, start);


#9152	size_t remaining = varp->xsz * nelems;


#9164		size_t nget = ncx_howmany(varp->type, extent);


#9188getNCvx_ulonglong_int(const NC3_INFO* ncp, const NC_var *varp,


#9191	off_t offset = NC_varoffset(ncp, varp, start);


#9192	size_t remaining = varp->xsz * nelems;


#9204		size_t nget = ncx_howmany(varp->type, extent);


#9228getNCvx_ulonglong_float(const NC3_INFO* ncp, const NC_var *varp,


#9231	off_t offset = NC_varoffset(ncp, varp, start);


#9232	size_t remaining = varp->xsz * nelems;


#9244		size_t nget = ncx_howmany(varp->type, extent);


#9268getNCvx_ulonglong_double(const NC3_INFO* ncp, const NC_var *varp,


#9271	off_t offset = NC_varoffset(ncp, varp, start);


#9272	size_t remaining = varp->xsz * nelems;


#9284		size_t nget = ncx_howmany(varp->type, extent);


#9308getNCvx_ulonglong_longlong(const NC3_INFO* ncp, const NC_var *varp,


#9311	off_t offset = NC_varoffset(ncp, varp, start);


#9312	size_t remaining = varp->xsz * nelems;


#9324		size_t nget = ncx_howmany(varp->type, extent);


#9348getNCvx_ulonglong_uint(const NC3_INFO* ncp, const NC_var *varp,


#9351	off_t offset = NC_varoffset(ncp, varp, start);


#9352	size_t remaining = varp->xsz * nelems;


#9364		size_t nget = ncx_howmany(varp->type, extent);


#9388getNCvx_ulonglong_ulonglong(const NC3_INFO* ncp, const NC_var *varp,


#9391	off_t offset = NC_varoffset(ncp, varp, start);


#9392	size_t remaining = varp->xsz * nelems;


#9404		size_t nget = ncx_howmany(varp->type, extent);


#9428getNCvx_ulonglong_ushort(const NC3_INFO* ncp, const NC_var *varp,


#9431	off_t offset = NC_varoffset(ncp, varp, start);


#9432	size_t remaining = varp->xsz * nelems;


#9444		size_t nget = ncx_howmany(varp->type, extent);


#9470getNCvx_schar_uchar(const NC3_INFO* ncp, const NC_var *varp,


#9473	off_t offset = NC_varoffset(ncp, varp, start);


#9474	size_t remaining = varp->xsz * nelems;


#9486		size_t nget = ncx_howmany(varp->type, extent);


#9521NCiocount(const NC3_INFO* const ncp, const NC_var *const varp,


#9526	const size_t *edp = edges + varp->ndims;


#9527	const size_t *shp = varp->shape + varp->ndims;


#9529	if(IS_RECVAR(varp))


#9531		if(varp->ndims == 1 && ncp->recsize <= varp->len)


#9576	assert(shp >= varp->shape + varp->ndims -1


#9581		 	edp0 < edges + varp->ndims;


#9659readNCv(const NC3_INFO* ncp, const NC_var* varp, const size_t* start,


#9663    switch (CASE(varp->type,memtype)) {


#9668       return getNCvx_char_char(ncp,varp,start,nelems,(char*)value);


#9670    return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);


#9674        return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);


#9677        return getNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9680        return getNCvx_schar_short(ncp,varp,start,nelems,(short*)value);


#9683        return getNCvx_schar_int(ncp,varp,start,nelems,(int*)value);


#9686        return getNCvx_schar_float(ncp,varp,start,nelems,(float*)value);


#9689        return getNCvx_schar_double(ncp,varp,start,nelems,(double *)value);


#9692        return getNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);


#9695        return getNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9698        return getNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9701        return getNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9704        return getNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);


#9707        return getNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9710        return getNCvx_short_short(ncp,varp,start,nelems,(short*)value);


#9713        return getNCvx_short_int(ncp,varp,start,nelems,(int*)value);


#9716        return getNCvx_short_float(ncp,varp,start,nelems,(float*)value);


#9719        return getNCvx_short_double(ncp,varp,start,nelems,(double*)value);


#9722        return getNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);


#9725        return getNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9728        return getNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9731        return getNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9735        return getNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);


#9738        return getNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9741        return getNCvx_int_short(ncp,varp,start,nelems,(short*)value);


#9744        return getNCvx_int_int(ncp,varp,start,nelems,(int*)value);


#9747        return getNCvx_int_float(ncp,varp,start,nelems,(float*)value);


#9750        return getNCvx_int_double(ncp,varp,start,nelems,(double*)value);


#9753        return getNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);


#9756        return getNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9759        return getNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9762        return getNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9766        return getNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);


#9769        return getNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9772        return getNCvx_float_short(ncp,varp,start,nelems,(short*)value);


#9775        return getNCvx_float_int(ncp,varp,start,nelems,(int*)value);


#9778        return getNCvx_float_float(ncp,varp,start,nelems,(float*)value);


#9781        return getNCvx_float_double(ncp,varp,start,nelems,(double*)value);


#9784        return getNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);


#9787        return getNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9790        return getNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9793        return getNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9797        return getNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);


#9800        return getNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9803        return getNCvx_double_short(ncp,varp,start,nelems,(short*)value);


#9806        return getNCvx_double_int(ncp,varp,start,nelems,(int*)value);


#9809        return getNCvx_double_float(ncp,varp,start,nelems,(float*)value);


#9812        return getNCvx_double_double(ncp,varp,start,nelems,(double*)value);


#9815        return getNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);


#9818        return getNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9821        return getNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9824        return getNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9828        return getNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9831        return getNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);


#9834        return getNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);


#9837        return getNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);


#9840        return getNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);


#9843        return getNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);


#9846        return getNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);


#9849        return getNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9852        return getNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9855        return getNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9859        return getNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);


#9862        return getNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9865        return getNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);


#9868        return getNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);


#9871        return getNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);


#9874        return getNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);


#9877        return getNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);


#9880        return getNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9883        return getNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9886        return getNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9890        return getNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);


#9893        return getNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9896        return getNCvx_uint_short(ncp,varp,start,nelems,(short*)value);


#9899        return getNCvx_uint_int(ncp,varp,start,nelems,(int*)value);


#9902        return getNCvx_uint_float(ncp,varp,start,nelems,(float*)value);


#9905        return getNCvx_uint_double(ncp,varp,start,nelems,(double*)value);


#9908        return getNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);


#9911        return getNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9914        return getNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9917        return getNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9921        return getNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);


#9924        return getNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9927        return getNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);


#9930        return getNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);


#9933        return getNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);


#9936        return getNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);


#9939        return getNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);


#9942        return getNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9945        return getNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9948        return getNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9952        return getNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);


#9955        return getNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#9958        return getNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);


#9961        return getNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);


#9964        return getNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);


#9967        return getNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);


#9970        return getNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);


#9973        return getNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);


#9976        return getNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#9979        return getNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#9991writeNCv(NC3_INFO* ncp, const NC_var* varp, const size_t* start,


#9995    switch (CASE(varp->type,memtype)) {


#9999        return putNCvx_char_char(ncp,varp,start,nelems,(char*)value);


#10002        return putNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);


#10005        return putNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10008        return putNCvx_schar_short(ncp,varp,start,nelems,(short*)value);


#10011        return putNCvx_schar_int(ncp,varp,start,nelems,(int*)value);


#10014        return putNCvx_schar_float(ncp,varp,start,nelems,(float*)value);


#10017        return putNCvx_schar_double(ncp,varp,start,nelems,(double *)value);


#10020        return putNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);


#10023        return putNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10026        return putNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10029        return putNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10032        return putNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);


#10035        return putNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10038        return putNCvx_short_short(ncp,varp,start,nelems,(short*)value);


#10041        return putNCvx_short_int(ncp,varp,start,nelems,(int*)value);


#10044        return putNCvx_short_float(ncp,varp,start,nelems,(float*)value);


#10047        return putNCvx_short_double(ncp,varp,start,nelems,(double*)value);


#10050        return putNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);


#10053        return putNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10056        return putNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10059        return putNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10062        return putNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);


#10065        return putNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10068        return putNCvx_int_short(ncp,varp,start,nelems,(short*)value);


#10071        return putNCvx_int_int(ncp,varp,start,nelems,(int*)value);


#10074        return putNCvx_int_float(ncp,varp,start,nelems,(float*)value);


#10077        return putNCvx_int_double(ncp,varp,start,nelems,(double*)value);


#10080        return putNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);


#10083        return putNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10086        return putNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10089        return putNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10092        return putNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);


#10095        return putNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10098        return putNCvx_float_short(ncp,varp,start,nelems,(short*)value);


#10101        return putNCvx_float_int(ncp,varp,start,nelems,(int*)value);


#10104        return putNCvx_float_float(ncp,varp,start,nelems,(float*)value);


#10107        return putNCvx_float_double(ncp,varp,start,nelems,(double*)value);


#10110        return putNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);


#10113        return putNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10116        return putNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10119        return putNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10122        return putNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);


#10125        return putNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10128        return putNCvx_double_short(ncp,varp,start,nelems,(short*)value);


#10131        return putNCvx_double_int(ncp,varp,start,nelems,(int*)value);


#10134        return putNCvx_double_float(ncp,varp,start,nelems,(float*)value);


#10137        return putNCvx_double_double(ncp,varp,start,nelems,(double*)value);


#10140        return putNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);


#10143        return putNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10146        return putNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10149        return putNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10152        return putNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10155        return putNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);


#10158        return putNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);


#10161        return putNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);


#10164        return putNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);


#10167        return putNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);


#10170        return putNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);


#10173        return putNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10176        return putNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10179        return putNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10182        return putNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);


#10185        return putNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10188        return putNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);


#10191        return putNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);


#10194        return putNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);


#10197        return putNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);


#10200        return putNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);


#10203        return putNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10206        return putNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10209        return putNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10212        return putNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);


#10215        return putNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10218        return putNCvx_uint_short(ncp,varp,start,nelems,(short*)value);


#10221        return putNCvx_uint_int(ncp,varp,start,nelems,(int*)value);


#10224        return putNCvx_uint_float(ncp,varp,start,nelems,(float*)value);


#10227        return putNCvx_uint_double(ncp,varp,start,nelems,(double*)value);


#10230        return putNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);


#10233        return putNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10236        return putNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10239        return putNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10242        return putNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);


#10245        return putNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10248        return putNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);


#10251        return putNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);


#10254        return putNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);


#10257        return putNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);


#10260        return putNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);


#10263        return putNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10266        return putNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10269        return putNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10272        return putNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);


#10275        return putNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);


#10278        return putNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);


#10281        return putNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);


#10284        return putNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);


#10287        return putNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);


#10290        return putNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);


#10293        return putNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);


#10296        return putNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);


#10299        return putNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);


#10320    NC_var *varp;


#10336    status = NC_lookupvar(nc3, varid, &varp);


#10340    if(memtype == NC_NAT) memtype=varp->type;


#10342    if(memtype == NC_CHAR && varp->type != NC_CHAR)


#10344    else if(memtype != NC_CHAR && varp->type == NC_CHAR)


#10348    if(edges == NULL && varp->ndims > 0) {


#10351	if(varp->shape[0] == 0) {


#10352	    (void)memcpy((void*)modedges,(void*)varp->shape,


#10353                          sizeof(size_t)*varp->ndims);


#10357	    edges = varp->shape;


#10360    status = NCcoordck(nc3, varp, start);


#10364    status = NCedgeck(nc3, varp, start, edges);


#10371    if(varp->ndims == 0) /* scalar variable */


#10373        return( readNCv(nc3, varp, start, 1, (void*)value, memtype) );


#10376    if(IS_RECVAR(varp))


#10380        if(varp->ndims == 1 && nc3->recsize <= varp->len)


#10383            return( readNCv(nc3, varp, start, *edges, (void*)value, memtype) );


#10391    ii = NCiocount(nc3, varp, edges, &iocount);


#10395        return( readNCv(nc3, varp, start, iocount, (void*)value, memtype) );


#10401    ALLOC_ONSTACK(coord, size_t, varp->ndims);


#10402    ALLOC_ONSTACK(upper, size_t, varp->ndims);


#10406    (void) memcpy(coord, start, varp->ndims * sizeof(size_t));


#10409    set_upper(upper, start, edges, &upper[varp->ndims]);


#10414        const int lstatus = readNCv(nc3, varp, coord, iocount, (void*)value, memtype);


#10447    NC_var *varp;


#10466    status = NC_lookupvar(nc3, varid, &varp);


#10471    if(memtype == NC_NAT) memtype=varp->type;


#10473    if(memtype == NC_CHAR && varp->type != NC_CHAR)


#10475    else if(memtype != NC_CHAR && varp->type == NC_CHAR)


#10482    if(edges == NULL && varp->ndims > 0) {


#10485	if(varp->shape[0] == 0) {


#10486	    (void)memcpy((void*)modedges,(void*)varp->shape,


#10487                          sizeof(size_t)*varp->ndims);


#10491	    edges = varp->shape;


#10494    status = NCcoordck(nc3, varp, start);


#10497    status = NCedgeck(nc3, varp, start, edges);


#10501    if(varp->ndims == 0) /* scalar variable */


#10503        return( writeNCv(nc3, varp, start, 1, (void*)value, memtype) );


#10506    if(IS_RECVAR(varp))


#10512        if(varp->ndims == 1


#10513            && nc3->recsize <= varp->len)


#10516            return( writeNCv(nc3, varp, start, *edges, (void*)value, memtype) );


#10524    ii = NCiocount(nc3, varp, edges, &iocount);


#10528        return( writeNCv(nc3, varp, start, iocount, (void*)value, memtype) );


#10534    ALLOC_ONSTACK(coord, size_t, varp->ndims);


#10535    ALLOC_ONSTACK(upper, size_t, varp->ndims);


#10539    (void) memcpy(coord, start, varp->ndims * sizeof(size_t));


#10542    set_upper(upper, start, edges, &upper[varp->ndims]);


#10547        const int lstatus = writeNCv(nc3, varp, coord, iocount, (void*)value, memtype);


v1hpg.c#898ncx_len_NC_var(const NC_var *varp, size_t sizeof_off_t, int version)


#902	assert(varp != NULL);


#905	sz = ncx_len_NC_string(varp->name, version);


#908	    sz += ncx_len_int64(varp->ndims); /* dimids */


#912	    sz += ncx_len_int(varp->ndims); /* dimids */


#914	sz += ncx_len_NC_attrarray(&varp->attrs, version);


#925v1h_put_NC_var(v1hs *psp, const NC_var *varp)


#929	status = v1h_put_NC_string(psp, varp->name);


#933	status = v1h_put_size_t(psp, &varp->ndims);


#938		status = check_v1hs(psp, ncx_len_int64(varp->ndims));


#942				varp->ndims, varp->dimids);


#947  	    status = check_v1hs(psp, ncx_len_int(varp->ndims));


#951			varp->ndims, varp->dimids);


#956	status = v1h_put_NC_attrarray(psp, &varp->attrs);


#960	status = v1h_put_nc_type(psp, &varp->type);


#964	status = v1h_put_size_t(psp, &varp->len);


#971	status = ncx_put_off_t(&psp->pos, &varp->begin, psp->version == 1 ? 4 : 8);


#986	NC_var *varp;


#996	varp = new_x_NC_var(strp, ndims);


#997	if(varp == NULL)


#1008				ndims, varp->dimids);


#1017			ndims, varp->dimids);


#1021	status = v1h_get_NC_attrarray(gsp, &varp->attrs);


#1024	status = v1h_get_nc_type(gsp, &varp->type);


#1028	status = v1h_get_size_t(gsp, &varp->len);


#1036			       &varp->begin, gsp->version == 1 ? 4 : 8);


#1040	*varpp = varp;


#1044	free_NC_var(varp); /* frees name */


var.c#43free_NC_var(NC_var *varp)


#45	if(varp == NULL)


#47	free_NC_attrarrayV(&varp->attrs);


#48	free_NC_string(varp->name);


#50	if(varp->dimids != NULL) free(varp->dimids);


#51	if(varp->shape != NULL) free(varp->shape);


#52	if(varp->dsizes != NULL) free(varp->dsizes);


#54	free(varp);


#67	NC_var *varp;


#79	varp = (NC_var *) malloc(sz);


#80	if(varp == NULL )


#82	(void) memset(varp, 0, sz);


#83	varp->name = strp;


#84	varp->ndims = ndims;


#94	  varp->dimids = (int *)((char *)varp + M_RNDUP(sizeof(NC_var)));


#95	  varp->shape = (size_t *)((char *)varp->dimids + o1);


#96	  varp->dsizes = (off_t *)((char *)varp->shape + o2);


#98	  varp->dimids = (int*)malloc(o1);


#99	  varp->shape = (size_t*)malloc(o2);


#100	  varp->dsizes = (off_t*)malloc(o3);


#103	  varp->dimids = NULL;


#104	  varp->shape = NULL;


#105	  varp->dsizes=NULL;


#109	varp->xsz = 0;


#110	varp->len = 0;


#111	varp->begin = 0;


#113	return varp;


#126	NC_var *varp = NULL;


#136	varp = new_x_NC_var(strp, ndims);


#137	if(varp == NULL )


#143	varp->type = type;


#146	  (void) memcpy(varp->dimids, dimids, ndims * sizeof(int));


#148      varp->dimids=NULL;


#151	return(varp);


#158	NC_var *varp = new_NC_var(rvarp->name->cp, rvarp->type,


#160	if(varp == NULL)


#164	if(dup_NC_attrarrayV(&varp->attrs, &rvarp->attrs) != NC_NOERR)


#166		free_NC_var(varp);


#170	(void) memcpy(varp->shape, rvarp->shape,


#172	(void) memcpy(varp->dsizes, rvarp->dsizes,


#174	varp->xsz = rvarp->xsz;


#175	varp->len = rvarp->len;


#176	varp->begin = rvarp->begin;


#178	return varp;


#423NC_var_shape(NC_var *varp, const NC_dimarray *dims)


#431	varp->xsz = ncx_szof(varp->type);


#433	if(varp->ndims == 0 || varp->dimids == NULL)


#442	for(ip = varp->dimids, op = varp->shape


#443          ; ip < &varp->dimids[varp->ndims]; ip++, op++)


#450		if(*op == NC_UNLIMITED && ip != varp->dimids)


#458	for(shp = varp->shape + varp->ndims -1,


#459				dsp = varp->dsizes + varp->ndims -1;


#460 			shp >= varp->shape;


#464      if( shp != NULL && (shp != varp->shape || !IS_RECVAR(varp)))


#479    if( varp->xsz <= (X_UINT_MAX - 1) / product ) /* if integer multiply will not overflow */


#481	        varp->len = product * varp->xsz;


#482		switch(varp->type) {


#487		        if( varp->len%4 != 0 )


#489			        varp->len += 4 - varp->len%4; /* round up */


#499	        varp->len = X_UINT_MAX;


#502	arrayp("\tshape", varp->ndims, varp->shape);


#503	arrayp("\tdsizes", varp->ndims, varp->dsizes);


#516NC_check_vlen(NC_var *varp, size_t vlen_max) {


#517    size_t prod=varp->xsz;	/* product of xsz and dimensions so far */


#521    assert(varp != NULL);


#522    for(ii = IS_RECVAR(varp) ? 1 : 0; ii < varp->ndims; ii++) {


#523      if(!varp->shape)


#525      if (varp->shape[ii] > vlen_max / prod) {


#528      prod *= varp->shape[ii];


#546int NC_lookupvar(NC3_INFO* ncp, int varid, NC_var **varp)


#554  if(varp)


#555    *varp = elem_NC_vararray(&ncp->vars, (size_t)varid);


#559  if(*varp == NULL)


#577	NC_var *varp = NULL;


#608	varid = NC_findvar(&ncp->vars, name, &varp);


#614	varp = new_NC_var(name, type, ndims, dimids);


#615	if(varp == NULL)


#618	status = NC_var_shape(varp, &ncp->dims);


#621		free_NC_var(varp);


#625	status = incr_NC_vararray(&ncp->vars, varp);


#628		free_NC_var(varp);


#644	NC_var *varp;


#652	varid = NC_findvar(&ncp->vars, name, &varp);


#675	NC_var *varp;


#683	varp = elem_NC_vararray(&ncp->vars, (size_t)varid);


#684	if(varp == NULL)


#689		(void) strncpy(name, varp->name->cp, varp->name->nchars);


#690		name[varp->name->nchars] = 0;


#694		*typep = varp->type;


#697		*ndimsp = (int) varp->ndims;


#701		for(ii = 0; ii < varp->ndims; ii++)


#703			dimids[ii] = varp->dimids[ii];


#708		*nattsp = (int) varp->attrs.nelems;


#720	NC_var *varp;


#740	other = NC_findvar(&ncp->vars, unewname, &varp);


#746	status = NC_lookupvar(ncp, varid, &varp);


#754	old = varp->name;


#767		varp->name = newStr;


#778	status = set_NC_string(varp->name, newname);


#783	NC_hashmapAddVar(&ncp->vars, varid, varp->name->cp);


vardata.c#163    const ncvar_t *varp,	/* variable */


#167    if (varp->has_fillval &&


#168	(*(varp->tinfo->val_equals))((const nctype_t *)varp->tinfo,


#169				     (const void*)varp->fillvalp, valp) ) {


#172	(*varp->val_tostring)(varp, sb, valp);




HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017  | Polyhedron Solutions - INTERNAL USE | COMMERCIAL  (Any O/S) SN 4AKIed