dv2i.c#612    nc_type	datatype,


#618	const int status = nc_def_var(ncid, name, datatype, ndims, dim, &varid);


#650    nc_type*	datatype,


#657	const int status = nc_inq_var(ncid, varid, name, datatype,


#992    nc_type	datatype,


#997	const int status = nc_put_att(ncid, varid, name, datatype, len, value);


#1012    nc_type*	datatype,


#1017	const int status = nc_inq_att(ncid, varid, name, datatype, &ll);


nc3dispatch.h#149NC3_put_att(int ncid, int varid, const char *name, nc_type datatype,


nc3internal.h#375nc3_cktype(int mode, nc_type datatype);


nc4dispatch.h#120NC4_put_att(int ncid, int varid, const char *name, nc_type datatype,


ncd2dispatch.c#2225NCD2_put_att(int ncid, int varid, const char* name, nc_type datatype,


ncd2dispatch.h#122NCD2_put_att(int ncid, int varid, const char *name, nc_type datatype,


netcdf.h#1781nctypelen(nc_type datatype);


test_put.c#237    nc_type datatype;


#253	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#258	    IF (datatype != var_type[i])


#275		if (inRange3(expect,datatype,NCT_TEXT)) {


#321    nc_type datatype;


#337	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#342	    IF (datatype != var_type[i])


#359		if (inRange3(expect,datatype,NCT_UCHAR)) {


#405    nc_type datatype;


#421	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#426	    IF (datatype != var_type[i])


#443		if (inRange3(expect,datatype,NCT_SCHAR)) {


#489    nc_type datatype;


#505	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#510	    IF (datatype != var_type[i])


#527		if (inRange3(expect,datatype,NCT_SHORT)) {


#573    nc_type datatype;


#589	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#594	    IF (datatype != var_type[i])


#611		if (inRange3(expect,datatype,NCT_INT)) {


#657    nc_type datatype;


#673	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#678	    IF (datatype != var_type[i])


#695		if (inRange3(expect,datatype,NCT_LONG)) {


#741    nc_type datatype;


#757	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#762	    IF (datatype != var_type[i])


#779		if (inRange3(expect,datatype,NCT_FLOAT)) {


#825    nc_type datatype;


#841	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#846	    IF (datatype != var_type[i])


#863		if (inRange3(expect,datatype,NCT_DOUBLE)) {


#909    nc_type datatype;


#925	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#930	    IF (datatype != var_type[i])


#947		if (inRange3(expect,datatype,NCT_USHORT)) {


#993    nc_type datatype;


#1009	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#1014	    IF (datatype != var_type[i])


#1031		if (inRange3(expect,datatype,NCT_UINT)) {


#1077    nc_type datatype;


#1093	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#1098	    IF (datatype != var_type[i])


#1115		if (inRange3(expect,datatype,NCT_LONGLONG)) {


#1161    nc_type datatype;


#1177	    err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#1182	    IF (datatype != var_type[i])


#1199		if (inRange3(expect,datatype,NCT_ULONGLONG)) {


#1247    nc_type datatype;


#1259		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1262		IF (datatype != ATT_TYPE(i,j))


#1269		    expect[k] = hash4( datatype, -1, &k, NCT_TEXT);


#1270		    if (inRange3(expect[k], datatype, NCT_TEXT)) {


#1285                    if (inRange3(expect[k],datatype,NCT_TEXT)


#1287                        IF (!equal(value[k],expect[k],datatype,NCT_TEXT)) {


#1322    nc_type datatype;


#1334		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1337		IF (datatype != ATT_TYPE(i,j))


#1344		    expect[k] = hash4( datatype, -1, &k, NCT_UCHAR);


#1345		    if (inRange3(expect[k], datatype, NCT_UCHAR)) {


#1360                    if (inRange3(expect[k],datatype,NCT_UCHAR)


#1362                        IF (!equal(value[k],expect[k],datatype,NCT_UCHAR)) {


#1397    nc_type datatype;


#1409		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1412		IF (datatype != ATT_TYPE(i,j))


#1419		    expect[k] = hash4( datatype, -1, &k, NCT_SCHAR);


#1420		    if (inRange3(expect[k], datatype, NCT_SCHAR)) {


#1435                    if (inRange3(expect[k],datatype,NCT_SCHAR)


#1437                        IF (!equal(value[k],expect[k],datatype,NCT_SCHAR)) {


#1472    nc_type datatype;


#1484		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1487		IF (datatype != ATT_TYPE(i,j))


#1494		    expect[k] = hash4( datatype, -1, &k, NCT_SHORT);


#1495		    if (inRange3(expect[k], datatype, NCT_SHORT)) {


#1510                    if (inRange3(expect[k],datatype,NCT_SHORT)


#1512                        IF (!equal(value[k],expect[k],datatype,NCT_SHORT)) {


#1547    nc_type datatype;


#1559		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1562		IF (datatype != ATT_TYPE(i,j))


#1569		    expect[k] = hash4( datatype, -1, &k, NCT_INT);


#1570		    if (inRange3(expect[k], datatype, NCT_INT)) {


#1585                    if (inRange3(expect[k],datatype,NCT_INT)


#1587                        IF (!equal(value[k],expect[k],datatype,NCT_INT)) {


#1622    nc_type datatype;


#1634		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1637		IF (datatype != ATT_TYPE(i,j))


#1644		    expect[k] = hash4( datatype, -1, &k, NCT_LONG);


#1645		    if (inRange3(expect[k], datatype, NCT_LONG)) {


#1660                    if (inRange3(expect[k],datatype,NCT_LONG)


#1662                        IF (!equal(value[k],expect[k],datatype,NCT_LONG)) {


#1697    nc_type datatype;


#1709		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1712		IF (datatype != ATT_TYPE(i,j))


#1719		    expect[k] = hash4( datatype, -1, &k, NCT_FLOAT);


#1720		    if (inRange3(expect[k], datatype, NCT_FLOAT)) {


#1735                    if (inRange3(expect[k],datatype,NCT_FLOAT)


#1737                        IF (!equal(value[k],expect[k],datatype,NCT_FLOAT)) {


#1772    nc_type datatype;


#1784		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1787		IF (datatype != ATT_TYPE(i,j))


#1794		    expect[k] = hash4( datatype, -1, &k, NCT_DOUBLE);


#1795		    if (inRange3(expect[k], datatype, NCT_DOUBLE)) {


#1810                    if (inRange3(expect[k],datatype,NCT_DOUBLE)


#1812                        IF (!equal(value[k],expect[k],datatype,NCT_DOUBLE)) {


#1847    nc_type datatype;


#1859		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1862		IF (datatype != ATT_TYPE(i,j))


#1869		    expect[k] = hash4( datatype, -1, &k, NCT_USHORT);


#1870		    if (inRange3(expect[k], datatype, NCT_USHORT)) {


#1885                    if (inRange3(expect[k],datatype,NCT_USHORT)


#1887                        IF (!equal(value[k],expect[k],datatype,NCT_USHORT)) {


#1922    nc_type datatype;


#1934		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#1937		IF (datatype != ATT_TYPE(i,j))


#1944		    expect[k] = hash4( datatype, -1, &k, NCT_UINT);


#1945		    if (inRange3(expect[k], datatype, NCT_UINT)) {


#1960                    if (inRange3(expect[k],datatype,NCT_UINT)


#1962                        IF (!equal(value[k],expect[k],datatype,NCT_UINT)) {


#1997    nc_type datatype;


#2009		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#2012		IF (datatype != ATT_TYPE(i,j))


#2019		    expect[k] = hash4( datatype, -1, &k, NCT_LONGLONG);


#2020		    if (inRange3(expect[k], datatype, NCT_LONGLONG)) {


#2035                    if (inRange3(expect[k],datatype,NCT_LONGLONG)


#2037                        IF (!equal(value[k],expect[k],datatype,NCT_LONGLONG)) {


#2072    nc_type datatype;


#2084		err = nc_inq_att(ncid, i, ATT_NAME(i,j), &datatype, &length);


#2087		IF (datatype != ATT_TYPE(i,j))


#2094		    expect[k] = hash4( datatype, -1, &k, NCT_ULONGLONG);


#2095		    if (inRange3(expect[k], datatype, NCT_ULONGLONG)) {


#2110                    if (inRange3(expect[k],datatype,NCT_ULONGLONG)


#2112                        IF (!equal(value[k],expect[k],datatype,NCT_ULONGLONG)) {


test_read.c#617    nc_type datatype;


#626	err = nc_inq_var(BAD_ID, i, name, &datatype, &ndims, dimids, &natts);


#629	err = nc_inq_var(ncid,BAD_VARID,name,&datatype,&ndims,dimids,&natts);


#635	err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, &natts);


#640	else IF (var_type[i] != datatype)


#641	    error("type expected: %d, got: %d",var_type[i],datatype);


#653	err = nc_inq_var(ncid, i, 0, &datatype, 0, 0, 0);


#656        else IF (var_type[i] != datatype)


#657            error("type expected: %d, got: %d",var_type[i],datatype);


#806    nc_type datatype;


#812	err = nc_inq_vartype(BAD_ID, i, &datatype);


#815	err = nc_inq_vartype(ncid, BAD_VARID, &datatype);


#818	err = nc_inq_vartype(ncid, i, &datatype);


#821        else IF (var_type[i] != datatype)


#822            error("type expected: %d, got: %d", var_type[i], datatype);


#1500    nc_type datatype;


#1507	err = nc_inq_atttype(ncid, i, "noSuch", &datatype);


#1511            err = nc_inq_atttype(BAD_ID, i, ATT_NAME(i,j), &datatype);


#1514            err = nc_inq_atttype(ncid, BAD_VARID, ATT_NAME(i,j), &datatype);


#1517            err = nc_inq_atttype(ncid, i, ATT_NAME(i,j), &datatype);


#1521		IF (datatype != ATT_TYPE(i,j))


test_write.c#625    nc_type datatype;


#641    err = nc_inq_var(ncid, varid, name, &datatype, &ndims, dimids, &natts);


#646    IF (datatype != NC_SHORT)


#1310    nc_type datatype;		/* of att */


#1326	    datatype = ATT_TYPE(i,j);


#1328            err = nc_put_att(BAD_ID, varid, name, datatype, length, buf);


#1331            err = nc_put_att(ncid, varid, BAD_NAME, datatype, length, buf);


#1334            err = nc_put_att(ncid, BAD_VARID, name, datatype, length, buf);


#1342		value = hash(datatype, -1, &k );


#1343		if (!inRange(value, datatype))


#1345		err = dbl2nc(value, datatype, p);


#1348		p += nctypelen(datatype);


#1350            err = nc_put_att(ncid, varid, name, datatype, length, buf);


#1390    nc_type datatype;           /* of att */


#1488	    err = nc_inq_att(ncid_out, i, "a", &datatype, &length);


#1491	    IF (datatype != NC_CHAR)


#1536    nc_type datatype;


#1600            err = nc_inq_att(ncid, varid, name, &datatype, &length);


#1603            IF (datatype != atttype)


#1607            if (datatype == NC_CHAR) {


#1612                    expect = hash(datatype, -1, &k);


#1624                    expect = hash(datatype, -1, &k);


#1625		    if (inRange(expect, datatype)) {


#1626			IF (!equal(value[k],expect,datatype,NCT_DOUBLE)) {


tests.h#487int inRange(const double value, const nc_type datatype);


#511int inRange3(const double value, const nc_type datatype, const nct_itype itype);


#532int nc2dbl ( const nc_type datatype, const void *p, double *result);


#534int dbl2nc ( const double d, const nc_type datatype, void *p);


util.c#20inRange(const double value, const nc_type datatype)


#24    switch (datatype) {


#42inRange_uchar(const double value, const nc_type datatype)


#44    if (datatype == NC_BYTE) {


#48    return inRange(value, datatype);


#52inRange_schar(const double value, const nc_type datatype)


#56    if (datatype == NC_UBYTE) {


#64    return inRange(value, datatype);


#68inRange_float(const double value, const nc_type datatype)


#72    switch (datatype) {


#104	if(datatype == NC_FLOAT) {


#128    const nc_type datatype,


#134            return inRange_schar(value, datatype);


#136	return inRange_uchar(value, datatype);


#138	return inRange_float(value, datatype);


#142    return inRange(value, datatype);


#260int nc2dbl ( const nc_type datatype, const void *p, double *result)


#264    switch (datatype) {


#293int dbl2nc ( const double d, const nc_type datatype, void *p)


#298        switch (datatype) {


#930    nc_type datatype;


#941	err = nc_inq_var(ncid, i, name, &datatype, &ndims, dimids, NULL);


#946	IF (datatype != var_type[i])


#1015    nc_type datatype;


#1030	    err = nc_inq_att(ncid, i, name, &datatype, &length);


#1033	    IF (datatype != ATT_TYPE(i,j))


#1037	    if (datatype == NC_CHAR) {


#1042		    IF (text[k] != hash(datatype, -1, &k)) {


#1051		    expect = hash(datatype, -1, &k);




HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017  | Polyhedron Solutions - INTERNAL USE | COMMERCIAL  (Any O/S) SN 4AKIed