add.c#61    test->vars[test->nvars].type = ivar->type;
#89     test->atts[ia].type = iatt->type;
#99    test->atts[test->natts].type = iatt->type;
#138 test->atts[ib-1].type =  test->atts[ib].type;
#177    switch (varp->type) {
attr.c#40ncx_len_NC_attrV(nc_type type, size_t nelems)
#42 switch(type) {
#74 nc_type type,
#78 const size_t xsz = ncx_len_NC_attrV(typenelems);
#92 attrp->type = type;
#110 nc_type type,
#126 attrp = new_x_NC_attr(strptypenelems);
#141  rattrp->typerattrp->nelems);
#479 *datatypep = attrp->type;
#625ncx_pad_putn_Iuchar(void **xpp, size_t nelems, const uchar *tpnc_type type)
#627 switch(type) {
#657ncx_pad_getn_Iuchar(const void **xpp, size_t nelemsuchar *tpnc_type type)
#659 switch(type) {
#690ncx_pad_putn_Ischar(void **xpp, size_t nelems, const schar *tpnc_type type)
#692 switch(type) {
#722ncx_pad_getn_Ischar(const void **xpp, size_t nelemsschar *tpnc_type type)
#724 switch(type) {
#755ncx_pad_putn_Ishort(void **xpp, size_t nelems, const short *tpnc_type type)
#757 switch(type) {
#787ncx_pad_getn_Ishort(const void **xpp, size_t nelems, short *tpnc_type type)
#789 switch(type) {
#820ncx_pad_putn_Iint(void **xpp, size_t nelems, const int *tpnc_type type)
#822 switch(type) {
#852ncx_pad_getn_Iint(const void **xpp, size_t nelems, int *tpnc_type type)
#854 switch(type) {
#885ncx_pad_putn_Ifloat(void **xpp, size_t nelems, const float *tpnc_type type)
#887 switch(type) {
#917ncx_pad_getn_Ifloat(const void **xpp, size_t nelems, float *tpnc_type type)
#919 switch(type) {
#950ncx_pad_putn_Idouble(void **xpp, size_t nelems, const double *tpnc_type type)
#952 switch(type) {
#982ncx_pad_getn_Idouble(const void **xpp, size_t nelems, double *tpnc_type type)
#984 switch(type) {
#1016ncx_pad_putn_Ilong(void **xpp, size_t nelems, const long *tpnc_type type)
#1018 switch(type) {
#1048ncx_pad_getn_Ilong(const void **xpp, size_t nelems, long *tpnc_type type)
#1050 switch(type) {
#1082ncx_pad_putn_Ilonglong(void **xpp, size_t nelems, const longlong *tpnc_type type)
#1084 switch(type) {
#1114ncx_pad_getn_Ilonglong(const void **xpp, size_t nelemslonglong *tpnc_type type)
#1116 switch(type) {
#1147ncx_pad_putn_Iushort(void **xpp, size_t nelems, const ushort *tpnc_type type)
#1149 switch(type) {
#1179ncx_pad_getn_Iushort(const void **xpp, size_t nelemsushort *tpnc_type type)
#1181 switch(type) {
#1212ncx_pad_putn_Iuint(void **xpp, size_t nelems, const uint *tpnc_type type)
#1214 switch(type) {
#1244ncx_pad_getn_Iuint(const void **xpp, size_t nelemsuint *tpnc_type type)
#1246 switch(type) {
#1277ncx_pad_putn_Iulonglong(void **xpp, size_t nelems, const ulonglong *tpnc_type type)
#1279 switch(type) {
#1309ncx_pad_getn_Iulonglong(const void **xpp, size_t nelemsulonglong *tpnc_type type)
#1311 switch(type) {
#1383 nc_type type,
#1408    status = nc3_cktype(nc->modetype);
#1412    if(memtype == NC_NATmemtype = type;
#1414    if(memtype != NC_CHAR && type == NC_CHAR)
#1416    if(memtype == NC_CHAR && type != NC_CHAR)
#1432     const size_t xsz = ncx_len_NC_attrV(typenelems);
#1439            attrp->type = type;
#1444                status = dispatchput(&xpnelems, (const void*)valuetypememtype);
#1471    attrp = new_NC_attr(nametypenelems);
#1476        status = dispatchput(&xpnelems, (const void*)valuetypememtype);
#1514    if(memtype == NC_NATmemtype = attrp->type;
#1516    if(memtype != NC_CHAR && attrp->type == NC_CHAR)
#1518    if(memtype == NC_CHAR && attrp->type != NC_CHAR)
#1526        return ncx_pad_getn_Ischar(&xp,attrp->nelems,(schar*)value,attrp->type);
#1528        return ncx_pad_getn_Ishort(&xp,attrp->nelems,(short*)value,attrp->type);
#1530          return ncx_pad_getn_Iint(&xp,attrp->nelems,(int*)value,attrp->type);
#1532        return ncx_pad_getn_Ifloat(&xp,attrp->nelems,(float*)value,attrp->type);
#1534        return ncx_pad_getn_Idouble(&xp,attrp->nelems,(double*)value,attrp->type);
#1536          return ncx_pad_getn_Ilonglong(&xp,attrp->nelems,(longlong*)value,attrp->type);
#1538        return ncx_pad_getn_Iuchar(&xpattrp->nelems , (uchar *)valueattrp->type);
#1540          return ncx_pad_getn_Iushort(&xp,attrp->nelems,(ushort*)value,attrp->type);
#1542          return ncx_pad_getn_Iuint(&xp,attrp->nelems,(uint*)value,attrp->type);
#1544          return ncx_pad_getn_Iulonglong(&xp,attrp->nelems,(ulonglong*)value,attrp->type);
atttests.c#98 if (ncattput(cdfidNC_GLOBALatts[ia].nameatts[ia].type,
#118       &tmp.type, &tmp.len) == -1) {
#122 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#128 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#133 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#145    ww.nameww.typeww.ndimsww.dims)) == -1) {
#152       atts[ia].nameatts[ia].typeatts[ia].lenatts[ia].val)
#162       &tmp.type, &tmp.len) == -1) {
#166 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#172 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#177 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#191 if (ncattput(cdfidww_idatts[ia-1].nameatts[ia].type,
#198 tmp.type = atts[ia].type;
#206       &tmp.type, &tmp.len) == -1) {
#210 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#216 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#221 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#235    if (ncattput(cdfidww_id, "bogus_att2", atts[0].type,
#245    if (ncattput(cdfidww_idatts[0].nameatts[0].type,
#251 if (ncattput(cdfidww_idatts[0].nameatts[0].type,
#258    if (ncattput(cdfidww_id, "new_name", atts[0].type,
#270 if (ncattput(cdfidww_idatts[ia+1].nameatts[ia].type,
#278 tmp.type = atts[ia].type;
#285 if (ncattinq(cdfidww_idatts[ia+1].name, &tmp.type, &tmp.len)
#291 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#297 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#303 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#310    if (ncattput(cdfidtest.nvarsatts[0].nameatts[0].typeatts[0].len,
#320    if (ncattput(cdfidww_idatts[0].nameatts[0].typeatts[0].len,
#351    nc_type type;
#366       &type, &len) == -1) {
#371 if (type != test.atts[ia].type) {
#392    if ((vv_id = ncvardef(cdfidvv.namevv.typevv.ndimsvv.dims))
#400    if (ncattinq(cdfidvv_id, "nonesuch", &type, &len) != -1) {
#405    if (ncattinq(cdfidtest.nvarstest.atts[0].name, &type, &len) != -1) {
#412       &type, &len) == -1) {
#417 if (type != test.atts[ia].type) {
#436    if (ncattinq(cdfidNC_GLOBALtest.atts[0].name, &type, &len) != -1) {
#491    uu.nameuu.typeuu.ndimsuu.dims)) == -1) {
#499   vmax.namevmax.typevmax.lenvmax.val)
#509       &tmp.type, &tmp.len) == -1) {
#513 if (tmp.type != test.atts[ia].type) {
#523 tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
#530 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#534   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#536     val_out(test.atts[ia].typetest.atts[ia].len,
#539     val_out(tmp.typetmp.lentmp.val);
#552       &tmp.type, &tmp.len) == -1) {
#557 if (tmp.type != test.atts[ia].type) {
#568 tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
#575 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#579   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#581     val_out(test.atts[ia].typetest.atts[ia].len,
#584     val_out(tmp.typetmp.lentmp.val);
#665    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#673    if ((tt_id=ncvardef(cdfidtt.namett.typett.ndimstt.dims)) == -1) {
#678    if (ncattput(cdfidtt_idatt.nameatt.typeatt.lenatt.val) == -1) {
#687    if ((tu_id=ncvardef(cdfidtu.nametu.typetu.ndimstu.dims)) == -1) {
#692    if (ncattput(cdfidtu_idatt.nameatt.typeatt.lenatt.val) == -1) {
#718    if ((tu2_id=ncvardef(cdfid2tu.nametu.typetu.ndimstu.dims)) == -1) {
#729    if (ncattinq(cdfid2NC_GLOBALatt.name, &tmp.type, &tmp.len) == -1) {
#733    if (att.type != tmp.type || att.len != tmp.len) {
#738    tmp.val = emalloc(att.len * nctypelen(att.type));
#743    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#755    if (ncattinq(cdfid2tu2_idatt.name, &tmp.type, &tmp.len) == -1) {
#759    if (att.type != tmp.type || att.len != tmp.len) {
#764    tmp.val = emalloc(att.len * nctypelen(att.type));
#769    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#785    if (ncattput(cdfidNC_GLOBALatt2.nameatt2.typeatt2.lenatt2.val)
#798    if (ncattinq(cdfid2tu2_idatt2.name, &tmp.type, &tmp.len) == -1) {
#802    if (att2.type != tmp.type || att2.len != tmp.len) {
#807    tmp.val = emalloc(att2.len * nctypelen(att2.type));
#812    if (val_cmp(tmp.typetmp.lentmp.valatt2.val) != 0) {
#827    if (ncattinq(cdfidtu_idatt2.name, &tmp.type, &tmp.len) == -1) {
#831    if (att2.type != tmp.type || att2.len != tmp.len) {
#836    tmp.val = emalloc(att2.len * nctypelen(att2.type));
#841    if (val_cmp(tmp.typetmp.lentmp.valatt2.val) != 0) {
#984    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val)
#1125    if (ncattput(cdfidNC_GLOBALatty.nameatty.typeatty.len,
#1132    if (ncattput(cdfidNC_GLOBALattz.nameattz.typeattz.len,
#1146    if (ncattinq(cdfidNC_GLOBALnewname, &tmp.type, &tmp.len) == -1) {
#1150    if (atty.type != tmp.type || atty.len != tmp.len) {
#1155    tmp.val = emalloc(atty.len * nctypelen(atty.type));
#1160    if (val_cmp(tmp.typetmp.lentmp.valatty.val) != 0) {
#1165    if (ncattinq(cdfidNC_GLOBALatty.name, &tmp.type, &tmp.len) != -1) {
#1207    if (val_cmp(tmp.typetmp.lentmp.valatty.val) != 0) {
#1274    if (ncattput(cdfidNC_GLOBALyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1282    if ((yav_id=ncvardef(cdfidyav.nameyav.typeyav.ndimsyav.dims))
#1288    if (ncattput(cdfidyav_idyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1301    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndimsvtmp.dims,
#1322    if (ncattinq(cdfidNC_GLOBALyaa.name, &atmp.type, &atmp.len) != -1) {
#1333    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndims,
#1343    if (ncattinq(cdfidyav_idyaa.name, &atmp.type, &atmp.len) != -1) {
#1349    if (ncattput(cdfidNC_GLOBALyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1354    if (ncattput(cdfidyav_idyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
cdftests.c#279    if ((aa_id = ncvardef(ncidaa.nameaa.type,
#289   aa_units.typeaa_units.len, (void *) aa_units.val) == -1) {
#372    if ((bb_id = ncvardef(ncidbb.namebb.type,
#380    if (ncattput(ncidbb_idbb_range.namebb_range.typebb_range.len,
#568 if ((cc_id = ncvardef(ncidcc[iv].namecc[iv].type,
#576 if (ncattput(ncidcc_idcc_units.namecc_units.type,
#680    if ((dd_id=ncvardef(ncid0dd.namedd.typedd.ndimsdd.dims)) == -1) {
#687    if (ncattput(ncid0dd_iddd_fill_val.namedd_fill_val.type,
#806    if (ncattput(ncidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#821    if (ncattinq(ncidNC_GLOBALatt.name, &att.type, &att.len) != -1) {
dumplib.c#420prim_type_name(nc_type type)
#422    switch (type) {
#448 error("prim_type_name: bad type %d", type);
#1273    switch (varp->type) {
#1463    if( !is_user_defined_type(varp->type) ) {
#1464 varp->val_tostring = tostring_funcs[varp->type - 1];
#1756is_user_defined_type(nc_type type) {
#1757    nctype_t *typeinfop = get_typeinfo(type);
#1768get_type_name(int ncidnc_type type, char *name)
#1771    if (is_user_defined_type(type)) {
#1772 NC_CHECK(nc_inq_user_type(ncidtypenameNULLNULLNULLNULL));
#1774 strncpy(nameprim_type_name(type), NC_MAX_NAME + 1);
#1777    strncpy(nameprim_type_name(type), NC_MAX_NAME + 1);
dumplib.h#71extern void get_type_name(int ncidnc_type type, char *name);
#89extern int  is_user_defined_type ( nc_type type );
dv2i.c#28# define A_DECL(nametypendimsrhs) \
#29 const type *const name = ((const type *)(rhs))
#33# define A_INIT(lhstypendimsrhs)
#72# define A_DECL(nametypendimsrhs) \
#73  type *const name = (type*) nvmalloc((ndims) * sizeof(type))
#82# define A_INIT(lhstypendimsrhs) \
#86 type *tp = lhs; \
#87 type *const end = lhs + ndims; \
#90 *tp++ = (type) *lp++; \
#157    nc_type type;
#167    status = nc_inq_vartype(ncidvarid, &type);
#179    size = nctypelen(type);
#877 nc_type type;
#880 ret = nc_inq_vartype(ncidvarid, &type);
#882 el_size = nctypelen(type);
#934 nc_type type;
#937 ret = nc_inq_vartype(ncidvarid, &type);
#939 el_size = nctypelen(type);
dvar.c#407nctypelen(nc_type type)
#409   switch(type){
genc.c#523nctype(nc_type type)
#525    switch (type) {
#549ncctype(nc_type type)
#551    switch (type) {
#577 PANIC1("ncctype: bad type code:%d",type);
genf77.c#29static const char* nftype(nc_type type);
#31static const char* ncftype(nc_type type);
#32static const char* nfdtype(nc_type type);
#612nftype(nc_type type)
#614    switch (type) {
#628nfdtype(nc_type type)
#630    switch (type) {
#671ncftype(nc_type type)
#673    switch (type) {
#687 PANIC1("ncctype: bad type code:%d",type);
genj.c#24static const char* jtypeallcaps(nc_type type);
#25static const char* jtypecap(nc_type type);
#26static const char* jtype(nc_type type);
#27static const char* jarraytype(nc_type type);
#217jtypeallcaps(nc_type type)
#219    switch (type) {
#232      default: PANIC1("ncctype: bad type code:%d",type);
#238jtypecap(nc_type type)
#240    switch (type) {
#255      default: PANIC1("ncctype: bad type code:%d",type);
#287jtype(nc_type type)
#289    switch (type) {
#304      default: PANIC1("ncctype: bad type code:%d",type);
#314jarraytype(nc_type type)
#316    switch (type) {
#346 PANIC1("ncctype: bad type code:%d",type);
genlib.c#58   vars[ivar].type,
#68 switch(atts[iatt].type) {
#71     atts[iatt].typeatts[iatt].len,
#81     atts[iatt].typeatts[iatt].len,
#86     atts[iatt].typeatts[iatt].len,
#91     atts[iatt].typeatts[iatt].len,
#96     atts[iatt].typeatts[iatt].len,
#122     nc_type type, /* netCDF type code */
#133    switch (type) {
#295 if (atts[iatt].type != NC_CHAR) {
#304     if (atts[iatt].type != NC_CHAR) {
#307     ncatype(atts[iatt].type),
#375 nctype(vars[ivar].type),
#383 nctype(vars[ivar].type),
#397     if (atts[iatt].type == NC_CHAR) { /* string */
#411     val_string = cstring(atts[iatt].type,atts[iatt].val,jatt);
#423 ncatype(atts[iatt].type),
#427 nctype(atts[iatt].type),
#453     nc_type type) /* netCDF type code */
#455    switch (type) {
#489     nc_type type) /* netCDF type code */
#491    switch (type) {
#517     nc_type type) /* netCDF type code */
#519    switch (type) {
#548     nc_type type) /* netCDF type code */
#550    switch (type) {
#682     if (v->type == NC_CHAR) {
#686 sprintf(stmnt, "%s  %s", ncftype(v->type),
#689 sprintf(stmnt, "%s  %s(", ncftype(v->type),
#713 if (atts[iatt].len > max_atts[(int) atts[iatt].type]) {
#714     max_atts[(int)atts[iatt].type] = atts[iatt].len;
#778 ftypename(vars[ivar].type),
#786 ftypename(vars[ivar].type),
#799     if (atts[iatt].type == NC_CHAR) { /* string */
#813     val_string = fstring(atts[iatt].type,atts[iatt].val,jatt);
#815     nfstype(atts[iatt].type),
#824 nfftype(atts[iatt].type),
#828 ftypename(atts[iatt].type),
#830 nfstype(atts[iatt].type));
#901     nc_type type) /* netCDF type code */
#903    switch (type) {
#928     nc_type type) /* netCDF type code */
#930    switch (type) {
#956     nc_type type) /* netCDF type code */
#958    switch (type) {
#983     nc_type type) /* netCDF type code */
#985    switch (type) {
#1008     nc_type type) /* netCDF type code */
#1010    switch (type) {
#1039     nc_type type, /* netCDF type code */
#1050    switch (type) {
#1303    nc_type type
#1306    switch(type) {
#1472 if (v->type != NC_CHAR) {
#1473     sprintf(stmnt, "%s  %s(", ncftype(v->type),
#1502            if (v->ndims > 0 && v->dims[0] == rec_dim && v->type != NC_CHAR) {
#1512                            f_fill_name(v->type));
#1540 if (v->type != NC_CHAR) {
#1543     nfftype(v->type), v->lnamev->lnamev->lnamev->lname);
#1547     nfftype(v->type), v->lnamev->lnamev->lname,
genlib.h#125extern const char* nctype(nc_type type);
#126extern const char* ncctype(nc_type type);
#127extern const char* ncstype(nc_type type);
genlib.h#25extern const char* nctype ( nc_type  type );
#26extern const char* ncctype ( nc_type  type );
#27extern const char* ncstype ( nc_type  type );
#28extern const char* ncatype ( nc_type  type );
#29extern const char* nfstype ( nc_type  type );
#30extern const char* nfftype ( nc_type  type );
#31extern char* fstring ( nc_type  type, void* valp, int num );
#34extern size_t nctypesizenc_type type );
#71extern void nc_getfill ( nc_type  type, union genericgval );
#74extern void nc_putfill ( nc_type  type, void* val, union genericgval );
#77extern void nc_fill ( nc_type  type, size_t num, void* datp,
getfill.c#19     nc_type type,
#22    switch(type) {
#49     nc_type type, /* netcdf type code  */
#60    switch (type) {
#80 switch (type) {
#108     nc_type type,
#112    switch(type) {
load.c#100 ncctype(vars[varnum].type),
#104 switch (vars[varnum].type) {
#112     switch (vars[varnum].type) {
#131 switch (vars[varnum].type) {
#166       switch (vars[varnum].type) {
#231     ncstype(vars[varnum].type),
#239     ncstype(vars[varnum].type),
#247 ncctype(vars[varnum].type),
#250 switch (vars[varnum].type) {
#285 ncstype(vars[varnum].type),
#349    switch (vars[varnum].type) {
#439    if (v->type != NC_CHAR) {
#448    if (v->type != NC_CHAR) {
#450 nfftype(v->type), v->lnamev->lname);
#454    strlen(nfftype(v->type)) +
#462 nfftype(v->type), v->lnamechar_expr);
#514    switch (vars[varnum].type) {
#549    switch (vars[varnum].type) {
nc3internal.c#93nc3_cktype(int modenc_type type)
#96        if (type >= NC_BYTE && type < NC_STRING) return NC_NOERR;
#98        if (type >= NC_BYTE && type <= NC_DOUBLE) return NC_NOERR;
#100        if (type >= NC_BYTE && type <= NC_DOUBLE) return NC_NOERR;
#111ncx_howmany(nc_type type, size_t xbufsize)
#113 switch(type){
nc3internal.h#129 nc_type type; /* the discriminant */
#150 nc_type type,
#186 nc_type type; /* the discriminant */
#378ncx_howmany(nc_type type, size_t xbufsize);
nc4attr.c#23int nc4typelen(nc_type type);
#152  NC_TYPE_INFO_T *type;
#155  if ((retval = nc4_find_type(h5att->nc_typeid, &type)))
#159         if ((retval = nc4_get_typelen_mem(h5type->u.v.base_nc_typeid, 0, &base_typelen)))
#459  NC_TYPE_INFO_T *type;
#463  if ((retval = nc4_find_type(h5file_type, &type)))
#467         if ((retval = nc4_get_typelen_mem(h5type->u.v.base_nc_typeid, 0, &base_typelen)))
nc4file.c#197nc4typelen(nc_type type)
#199   switch(type){
#755   NC_TYPE_INFO_T *type;
#854      if((type = nc4_rec_find_hdf_type(h5->root_grpnative_typeid)))
#856         *xtype = type->nc_typeid;
#980      NC_TYPE_INFO_T *type;
#983      if((type = nc4_rec_find_hdf_type(h5->root_grpnative_typeid)))
#984  *type_info = type;
#994      if (type)
#1202   NC_TYPE_INFO_T *type;
#1222   if ((retval = nc4_type_list_add(grptype_sizetype_name, &type)))
#1226   type->committed = NC_TRUE;
#1227   type->hdf_typeid = hdf_typeid;
#1228   H5Iinc_ref(type->hdf_typeid);        /* Increment number of objects using ID */
#1229   type->native_hdf_typeid = native_typeid;
#1237         type->nc_type_class = NC_STRING;
#1249            type->nc_type_class = NC_COMPOUND;
#1265               if ((member_hdf_typeid = H5Tget_member_type(type->native_hdf_typeidm)) < 0)
#1272               member_name = H5Tget_member_name(type->native_hdf_typeidm);
#1285               member_offset = H5Tget_member_offset(type->native_hdf_typeidm);
#1313                  if ((retval = nc4_field_list_add(&type->u.c.fieldtype->u.c.num_fields++, member_name,
#1327                  if ((retval = nc4_field_list_add(&type->u.c.fieldtype->u.c.num_fields++, member_name,
#1370               type->nc_type_class = NC_STRING;
#1376               type->nc_type_class = NC_VLEN;
#1395               type->u.v.base_nc_typeid = base_nc_type;
#1396               type->u.v.base_hdf_typeid = base_hdf_typeid;
#1402         type->nc_type_class = NC_OPAQUE;
#1416            type->nc_type_class = NC_ENUM;
#1433            type->u.e.base_nc_typeid = base_nc_type;
#1434            type->u.e.base_hdf_typeid = base_hdf_typeid;
#1437            if ((type->u.e.num_members = H5Tget_nmembers(hdf_typeid)) < 0)
#1445            for (i = 0; i < type->u.e.num_membersi++)
#1471               if ((retval = nc4_enum_member_add(&type->u.e.enum_membertype->size,
#1849   NC_TYPE_INFO_T *type;
#1902      if ((retval = nc4_find_type(grp->nc4_infoatt->nc_typeid, &type)))
#2026   switch(oinfo.statbuf.type)
#2075         LOG((0, "Unknown object class %d in %s!", oinfo.statbuf.type__func__));
nc4hdf.c#301  NC_TYPE_INFO_T *type;
#440          if (nc4_find_type(h5xtype, &type))
#442          if (!type)
#444          typeid = type->hdf_typeid;
#1834commit_type(NC_GRP_INFO_T *grpNC_TYPE_INFO_T *type)
#1838  assert(grp && type);
#1841  if (type->committed)
#1845  if (type->nc_type_class == NC_COMPOUND)
#1850      if ((type->hdf_typeid = H5Tcreate(H5T_COMPOUNDtype->size)) < 0)
#1852      LOG((4, "creating compound type %s hdf_typeid 0x%x", type->name,
#1853           type->hdf_typeid));
#1855      for (field = type->u.c.fieldfieldfield = field->l.next)
#1858                                           &hdf_base_typeidtype->endianness)))
#1883          if (H5Tinsert(type->hdf_typeidfield->namefield->offset,
#1890  else if (type->nc_type_class == NC_VLEN)
#1893      if ((retval = nc4_get_hdf_typeid(grp->nc4_infotype->u.v.base_nc_typeid,
#1894                                       &type->u.v.base_hdf_typeidtype->endianness)))
#1898      if ((type->hdf_typeid = H5Tvlen_create(type->u.v.base_hdf_typeid)) < 0)
#1901  else if (type->nc_type_class == NC_OPAQUE)
#1904      if ((type->hdf_typeid = H5Tcreate(H5T_OPAQUEtype->size)) < 0)
#1907  else if (type->nc_type_class == NC_ENUM)
#1911      if (!type->u.e.enum_member)
#1915      if ((retval = nc4_get_hdf_typeid(grp->nc4_infotype->u.e.base_nc_typeid,
#1916                                       &type->u.e.base_hdf_typeidtype->endianness)))
#1920      if ((type->hdf_typeid =  H5Tenum_create(type->u.e.base_hdf_typeid)) < 0)
#1924      for (enum_m = type->u.e.enum_memberenum_menum_m = enum_m->l.next)
#1925        if (H5Tenum_insert(type->hdf_typeidenum_m->nameenum_m->value) < 0)
#1930      LOG((0, "Unknown class: %d", type->nc_type_class));
#1935  if (H5Tcommit(grp->hdf_grpidtype->nametype->hdf_typeid) < 0)
#1937  type->committed = NC_TRUE;
#1938  LOG((4, "just committed type %s, HDF typeid: 0x%x", type->name,
#1939       type->hdf_typeid));
#1944  if ((type->native_hdf_typeid = H5Tget_native_type(type->hdf_typeid,
#2134      if (H5G_DATASET == statbuf.type)
#2619  NC_TYPE_INFO_T *type;
#2637  for (type = grp->typetypetype = type->l.next)
#2638    if ((retval = commit_type(grptype)))
#3803  NC_TYPE_INFO_T *type;
#3844  if ((retval = nc4_find_type(h5xtype, &type)))
#3847  if (!type)
#3850  *len = type->size;
#3852  LOG((5, "type->size: %d", type->size));
#3903      NC_TYPE_INFO_T *type;
#3906      if ((retval = nc4_find_type(h5xtype, &type)))
#3908      if (!type)
#3911      *type_class = type->nc_type_class;
#3924reportobject(int log, hid_t id, unsigned int type)
#3935    switch (type) {
nc4internal.c#393   NC_TYPE_INFO_T *type, *res;
#399   for (type = start_grp->typetypetype = type->l.next)
#401      if ((equal = H5Tequal(type->native_hdf_typeid ? type->native_hdf_typeid : type->hdf_typeidtarget_hdf_typeid)) < 0)
#404  return type;
#422   NC_TYPE_INFO_T *type, *res;
#427   for (type = start_grp->typetypetype = type->l.next)
#428      if (!strcmp(type->namename))
#429  return type;
#445   NC_TYPE_INFO_T *type;
#450   for (type = start_grp->typetypetype = type->l.next)
#451      if (type->nc_typeid == target_nc_typeid)
#452  return type;
#474nc4_find_type(const NC_HDF5_FILE_INFO_T *h5nc_type typeidNC_TYPE_INFO_T **type)
#476   if (typeid < 0 || !type)
#478   *type = NULL;
#486   if(!(*type = nc4_rec_find_nc_type(h5->root_grptypeid)))
#776   NC_TYPE_INFO_T *type;
#782   for (type = grp->typetypetype = type->l.next)
#783      if (!strcmp(type->namename))
#803                  NC_TYPE_INFO_T **type)
#812   obj_list_add((NC_LIST_NODE_T **)(&grp->type), (NC_LIST_NODE_T *)new_type);
#824   if (type)
#825      *type = new_type;
#930nc4_type_free(NC_TYPE_INFO_T *type)
#933   assert(type->rc);
#934   type->rc--;
#937   if (0 == type->rc)
#940      if (type->hdf_typeid && H5Tclose(type->hdf_typeid) < 0)
#942      if (type->native_hdf_typeid && H5Tclose(type->native_hdf_typeid) < 0)
#946      if (type->name)
#947         free(type->name);
#950      switch (type->nc_type_class)
#958               field = type->u.c.field;
#963                  field_list_del(&type->u.c.fieldfield);
#974               enum_member = type->u.e.enum_member;
#985               if (H5Tclose(type->u.e.base_hdf_typeid) < 0)
#991            if (H5Tclose(type->u.v.base_hdf_typeid) < 0)
#999      free(type);
#1088type_list_del(NC_TYPE_INFO_T **listNC_TYPE_INFO_T *type)
#1091   obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)type);
#1094   return nc4_type_free(type);
#1132   NC_TYPE_INFO_T *type, *t;
#1191   type = grp->type;
#1192   while (type)
#1194      LOG((4, "%s: deleting type %s", __func__type->name));
#1195      t = type->l.next;
#1196      if ((retval = type_list_del(&grp->typetype)))
#1198      type = t;
#1457   NC_TYPE_INFO_T *type;
#1504   for (type = grp->typetypetype = type->l.next)
#1507    "name: %s num_fields: %d", tabstype->nc_typeid,
#1508    type->hdf_typeidtype->size, (int)type->committedtype->name,
#1509    type->u.c.num_fields));
#1511      if (type->nc_type_class == NC_COMPOUND)
#1514  for (field = type->u.c.fieldfieldfield = field->l.next)
#1518      else if (type->nc_type_class == NC_VLEN)
#1521         LOG((4, "base_nc_type: %d", type->u.v.base_nc_typeid));
#1523      else if (type->nc_type_class == NC_OPAQUE)
#1525      else if (type->nc_type_class == NC_ENUM)
#1528         LOG((4, "base_nc_type: %d", type->u.e.base_nc_typeid));
#1532  LOG((0, "Unknown class: %d", type->nc_type_class));
nc4internal.h#279   NC_TYPE_INFO_T *type;
#316   NC_TYPE_INFO_T *type;
#367int nc4_find_type(const NC_HDF5_FILE_INFO_T *h5, int typeid1NC_TYPE_INFO_T **type);
#371NC_TYPE_INFO_T *nc4_rec_find_equal_type(NC_GRP_INFO_T *start_grp, int ncid1NC_TYPE_INFO_T *type);
#384int nc4_type_free(NC_TYPE_INFO_T *type);
#394                  NC_TYPE_INFO_T **type);
nc4type.c#90   NC_TYPE_INFO_T *type = NULL;
#125      for (type = grptwo->typetypetype = type->l.next)
#126  if (!strcmp(norm_nametype->name))
#129        *typeidp = type->nc_typeid;
#135   if (!type)
#136      if ((type = nc4_rec_find_named_type(grp->nc4_info->root_grpnorm_name)))
#138     *typeidp = type->nc_typeid;
#143   if (!type)
#156   NC_TYPE_INFO_T *type;
#167   if (h5 && grp->type)
#168      for (type = grp->typetypetype = type->l.next)
#171     typeids[num] = type->nc_typeid;
#191   NC_TYPE_INFO_T *type;
#230   if ((retval = nc4_type_list_add(grpsizenorm_name, &type)))
#234   type->nc_type_class = type_class;
#236      type->u.v.base_nc_typeid = base_typeid;
#238      type->u.e.base_nc_typeid = base_typeid;
#242      *typeidp = type->nc_typeid;
#265   NC_TYPE_INFO_T *type;
#290   if (!(type = nc4_rec_find_nc_type(grp->nc4_info->root_grptypeid1)))
#294      strcpy(nametype->name);
#298      if (type->nc_type_class == NC_VLEN)
#300      else if (type->nc_type_class == NC_STRING)
#303  *size = type->size;
#332   NC_TYPE_INFO_T *type;
#349   if ((retval = nc4_find_type(grp->nc4_infotypeid1, &type)))
#353   if (!type || type->nc_type_class != NC_COMPOUND)
#358   if (type->committed)
#362   if ((retval = nc4_field_list_add(&type->u.c.fieldtype->u.c.num_fields,
#366   type->u.c.num_fields++;
#377   NC_TYPE_INFO_T *type;
#387   if (!(type = nc4_rec_find_nc_type(grp->nc4_info->root_grptypeid1)))
#393      if (type->nc_type_class == NC_COMPOUND)
#394         *nfieldsp = type->u.c.num_fields;
#395      else if (type->nc_type_class == NC_ENUM)
#396  *nfieldsp = type->u.e.num_members;
#404      if (type->nc_type_class == NC_VLEN)
#406      else if (type->nc_type_class == NC_STRING)
#409  *size = type->size;
#412      strcpy(nametype->name);
#418      if (type->nc_type_class == NC_ENUM)
#419         *base_nc_typep = type->u.e.base_nc_typeid;
#420      else if (type->nc_type_class == NC_VLEN)
#421         *base_nc_typep = type->u.v.base_nc_typeid;
#429      *classp = type->nc_type_class;
#441   NC_TYPE_INFO_T *type;
#450   if (!(type = nc4_rec_find_nc_type(grp->nc4_info->root_grptypeid1)))
#454   for (field = type->u.c.fieldfieldfield = field->l.next)
#496   NC_TYPE_INFO_T *type;
#509   if ((retval = nc4_find_type(NC4_DATA(nc), typeid1, &type)))
#513   if (!type || type->nc_type_class != NC_COMPOUND)
#521   for (field = type->u.c.fieldfieldfield = field->l.next)
#568   NC_TYPE_INFO_T *type;
#581   if (!(type = nc4_rec_find_nc_type(grp->nc4_info->root_grpxtype)))
#585   if (type->nc_type_class != NC_ENUM)
#589   enum_member = type->u.e.enum_member;
#590   for (i = 0; i < type->u.e.num_membersi++)
#592      switch (type->u.e.base_nc_typeid)
#631   if (i == type->u.e.num_members)
#644   NC_TYPE_INFO_T *type;
#656   if (!(type = nc4_rec_find_nc_type(grp->nc4_info->root_grptypeid1)))
#660   if (type->nc_type_class != NC_ENUM)
#664   if (idx >= type->u.e.num_members)
#668   enum_member = type->u.e.enum_member;
#676      memcpy(valueenum_member->valuetype->size);
#688   NC_TYPE_INFO_T *type;
#704   if ((retval = nc4_find_type(grp->nc4_infotypeid1, &type)))
#708   if (!type || type->nc_type_class != NC_ENUM)
#713   if (type->committed)
#717   if ((retval = nc4_enum_member_add(&type->u.e.enum_membertype->size,
#720   type->u.e.num_members++;
nccomps.h#70    nc_type type;
#91    nc_type type;
ncdump.c#190prim_type_name(nc_type type)
#192    switch (type) {
#224 error("prim_type_name: bad type %d", type);
#548    nc_type type,
#570    if (type == NC_CHAR) {
#579 switch (type) {
#673     nc_type type,
#696 switch (type) {
#772    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#773    att.tinfo = get_typeinfo(att.type);
#778    if (is_user_defined_type(att.type) || att.type == NC_STRING)
#780    if (is_user_defined_type(att.type))
#786 get_type_name(ncidatt.typeatt_type_name);
#790 print_type_name(ncidatt.type);
#802 att.type = NC_CHAR;
#805    if (! is_user_defined_type(att.type) ) {
#808 if(att.type == NC_CHAR) /* null-terminate retrieved text att value */
#811        pr_att_valgs(kindatt.typeatt.lenatt.valgp);
#825 if(att.type == NC_STRING) {
#840       NC_CHECKnc_inq_user_type(ncidatt.type,  type_name, &type_size,
#914        NC_CHECKnc_inq_enum_ident(ncidatt.typevalue,
#1153    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#1157    switch (att.type) {
#1187 pr_att_valsx(att.typeatt.lenatt.valsattvalsattvalslen);
#1193    if(att.type == NC_CHAR
#1195                          || att.type == NC_CHAR
#1206 get_type_name(ncidatt.typeatt_type_name);
#1424    nc_status = nc_inq_att(ncid,varid,_FillValue,&att.type,&att.len);
#1427       att.type == vp->type && att.len == 1) {
#1430 switch (vp->type) {
#1671      NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1674      get_type_name(ncidvar.typetype_name);
#1675      var.tinfo = get_typeinfo(var.type);
#1681      print_type_name (ncidvar.type);
#1782  NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1784  var.tinfo = get_typeinfo(var.type);
#1820  var.fmt = get_fmt(ncidvaridvar.type);
#1963 NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1983 printf (" type=\"%s\" />\n", prim_type_name(var.type));
#1989 printf (" type=\"%s\">\n", prim_type_name(var.type));
ncgen.h#36    nc_type type;
#52    nc_type type;
ncgentab.c#1685     dummyvar.type = NC_DOUBLE;
#1707     vars[nvars].type = type_code;
#1907        valtype = vars[varnum].type; /* variable type */
#2579    atts[natts].type = valtype;
#2586        nc_putfill(atts[natts].type,atts[natts].val,
#2588        if(atts[natts].type != vars[atts[natts].var].type) {
nctime0.c#63 int type;
#81    stat = nc_inq_att(ncidvaridCF_CAL_ATT_NAME, &catt.type, &catt.len);
#82    if(stat == NC_NOERR && catt.type == NC_CHAR && catt.len > 0) {
#89 ctype = calmap[itype].type;
#163    if(attp->type == NC_CHAR && attp->valgp && STREQ((char *)attp->name, "bounds")) {
#167    if(attp->type == NC_STRING && attp->valgp && STREQ((char *)attp->name, "bounds")) {
#206    nc_status = nc_inq_att(ncidvarid, "units", &uatt.type, &uatt.len);
#207    if(nc_status == NC_NOERR && uatt.type == NC_CHAR) { /* TODO: NC_STRING? */
#280    nc_type type = att->type; /* local copy */
#289    if (type == NC_CHAR || type == NC_STRING) /* must be numeric */
#298    assert ( type == NC_BYTE   || type == NC_SHORT  || type == NC_INT
#299          || type == NC_FLOAT  || type == NC_DOUBLE || type == NC_UBYTE
#300          || type == NC_USHORT || type == NC_UINT   || type == NC_INT64
#301          || type == NC_UINT64 );
#303    assert ( type == NC_BYTE   || type == NC_SHORT  || type == NC_INT
#304          || type == NC_FLOAT  || type == NC_DOUBLE );
#326 var.type = att->type; /* insert attrib type into fake var */
occurlfunctions.c#26static void* cvt(char* value, enum OCCURLFLAGTYPE type);
#55    } else switch (f->type) {
#272        stat = ocset_curlopt(state,ocflag->flag,cvt(triple->value,ocflag->type));
#280cvt(char* value, enum OCCURLFLAGTYPE type)
#282    switch (type) {
ocinternal.h#146    enum OCCURLFLAGTYPE type;
onstack.h#51# define ALLOC_ONSTACK(nametypenelems) \
#52 type *const name = (type *) alloca((ALLOCA_ARG_T)((nelems) * sizeof(type)))
#61# define ALLOC_ONSTACK(nametypenelems) \
#62 type name[nelems]
#76# define ALLOC_ONSTACK(nametypenelems) \
#77 type *const name = (type *) malloc((nelems) * sizeof(type))
putget.c#361 if( (*attrpp)->type != varp->type || (*attrpp)->nelems != 1 )
#388 switch(varp->type){
#877 size_t nput = ncx_howmany(varp->typeextent);
#923 size_t nput = ncx_howmany(varp->typeextent);
#968 size_t nput = ncx_howmany(varp->typeextent);
#1013 size_t nput = ncx_howmany(varp->typeextent);
#1058 size_t nput = ncx_howmany(varp->typeextent);
#1103 size_t nput = ncx_howmany(varp->typeextent);
#1148 size_t nput = ncx_howmany(varp->typeextent);
#1193 size_t nput = ncx_howmany(varp->typeextent);
#1238 size_t nput = ncx_howmany(varp->typeextent);
#1283 size_t nput = ncx_howmany(varp->typeextent);
#1328 size_t nput = ncx_howmany(varp->typeextent);
#1374 size_t nput = ncx_howmany(varp->typeextent);
#1419 size_t nput = ncx_howmany(varp->typeextent);
#1464 size_t nput = ncx_howmany(varp->typeextent);
#1509 size_t nput = ncx_howmany(varp->typeextent);
#1554 size_t nput = ncx_howmany(varp->typeextent);
#1599 size_t nput = ncx_howmany(varp->typeextent);
#1644 size_t nput = ncx_howmany(varp->typeextent);
#1689 size_t nput = ncx_howmany(varp->typeextent);
#1734 size_t nput = ncx_howmany(varp->typeextent);
#1779 size_t nput = ncx_howmany(varp->typeextent);
#1825 size_t nput = ncx_howmany(varp->typeextent);
#1870 size_t nput = ncx_howmany(varp->typeextent);
#1915 size_t nput = ncx_howmany(varp->typeextent);
#1960 size_t nput = ncx_howmany(varp->typeextent);
#2005 size_t nput = ncx_howmany(varp->typeextent);
#2050 size_t nput = ncx_howmany(varp->typeextent);
#2095 size_t nput = ncx_howmany(varp->typeextent);
#2140 size_t nput = ncx_howmany(varp->typeextent);
#2185 size_t nput = ncx_howmany(varp->typeextent);
#2230 size_t nput = ncx_howmany(varp->typeextent);
#2276 size_t nput = ncx_howmany(varp->typeextent);
#2321 size_t nput = ncx_howmany(varp->typeextent);
#2366 size_t nput = ncx_howmany(varp->typeextent);
#2411 size_t nput = ncx_howmany(varp->typeextent);
#2456 size_t nput = ncx_howmany(varp->typeextent);
#2501 size_t nput = ncx_howmany(varp->typeextent);
#2546 size_t nput = ncx_howmany(varp->typeextent);
#2591 size_t nput = ncx_howmany(varp->typeextent);
#2636 size_t nput = ncx_howmany(varp->typeextent);
#2681 size_t nput = ncx_howmany(varp->typeextent);
#2727 size_t nput = ncx_howmany(varp->typeextent);
#2772 size_t nput = ncx_howmany(varp->typeextent);
#2817 size_t nput = ncx_howmany(varp->typeextent);
#2862 size_t nput = ncx_howmany(varp->typeextent);
#2907 size_t nput = ncx_howmany(varp->typeextent);
#2952 size_t nput = ncx_howmany(varp->typeextent);
#2997 size_t nput = ncx_howmany(varp->typeextent);
#3042 size_t nput = ncx_howmany(varp->typeextent);
#3087 size_t nput = ncx_howmany(varp->typeextent);
#3132 size_t nput = ncx_howmany(varp->typeextent);
#3178 size_t nput = ncx_howmany(varp->typeextent);
#3223 size_t nput = ncx_howmany(varp->typeextent);
#3268 size_t nput = ncx_howmany(varp->typeextent);
#3313 size_t nput = ncx_howmany(varp->typeextent);
#3358 size_t nput = ncx_howmany(varp->typeextent);
#3403 size_t nput = ncx_howmany(varp->typeextent);
#3448 size_t nput = ncx_howmany(varp->typeextent);
#3493 size_t nput = ncx_howmany(varp->typeextent);
#3538 size_t nput = ncx_howmany(varp->typeextent);
#3583 size_t nput = ncx_howmany(varp->typeextent);
#3629 size_t nput = ncx_howmany(varp->typeextent);
#3674 size_t nput = ncx_howmany(varp->typeextent);
#3719 size_t nput = ncx_howmany(varp->typeextent);
#3764 size_t nput = ncx_howmany(varp->typeextent);
#3809 size_t nput = ncx_howmany(varp->typeextent);
#3854 size_t nput = ncx_howmany(varp->typeextent);
#3899 size_t nput = ncx_howmany(varp->typeextent);
#3944 size_t nput = ncx_howmany(varp->typeextent);
#3989 size_t nput = ncx_howmany(varp->typeextent);
#4034 size_t nput = ncx_howmany(varp->typeextent);
#4080 size_t nput = ncx_howmany(varp->typeextent);
#4125 size_t nput = ncx_howmany(varp->typeextent);
#4170 size_t nput = ncx_howmany(varp->typeextent);
#4215 size_t nput = ncx_howmany(varp->typeextent);
#4260 size_t nput = ncx_howmany(varp->typeextent);
#4305 size_t nput = ncx_howmany(varp->typeextent);
#4350 size_t nput = ncx_howmany(varp->typeextent);
#4395 size_t nput = ncx_howmany(varp->typeextent);
#4440 size_t nput = ncx_howmany(varp->typeextent);
#4485 size_t nput = ncx_howmany(varp->typeextent);
#4531 size_t nput = ncx_howmany(varp->typeextent);
#4576 size_t nput = ncx_howmany(varp->typeextent);
#4621 size_t nput = ncx_howmany(varp->typeextent);
#4666 size_t nput = ncx_howmany(varp->typeextent);
#4711 size_t nput = ncx_howmany(varp->typeextent);
#4756 size_t nput = ncx_howmany(varp->typeextent);
#4801 size_t nput = ncx_howmany(varp->typeextent);
#4846 size_t nput = ncx_howmany(varp->typeextent);
#4891 size_t nput = ncx_howmany(varp->typeextent);
#4936 size_t nput = ncx_howmany(varp->typeextent);
#4982 size_t nput = ncx_howmany(varp->typeextent);
#5027 size_t nput = ncx_howmany(varp->typeextent);
#5072 size_t nput = ncx_howmany(varp->typeextent);
#5117 size_t nput = ncx_howmany(varp->typeextent);
#5162 size_t nput = ncx_howmany(varp->typeextent);
#5207 size_t nput = ncx_howmany(varp->typeextent);
#5252 size_t nput = ncx_howmany(varp->typeextent);
#5297 size_t nput = ncx_howmany(varp->typeextent);
#5342 size_t nput = ncx_howmany(varp->typeextent);
#5387 size_t nput = ncx_howmany(varp->typeextent);
#5434 size_t nget = ncx_howmany(varp->typeextent);
#5475 size_t nget = ncx_howmany(varp->typeextent);
#5515 size_t nget = ncx_howmany(varp->typeextent);
#5555 size_t nget = ncx_howmany(varp->typeextent);
#5595 size_t nget = ncx_howmany(varp->typeextent);
#5635 size_t nget = ncx_howmany(varp->typeextent);
#5675 size_t nget = ncx_howmany(varp->typeextent);
#5715 size_t nget = ncx_howmany(varp->typeextent);
#5755 size_t nget = ncx_howmany(varp->typeextent);
#5795 size_t nget = ncx_howmany(varp->typeextent);
#5835 size_t nget = ncx_howmany(varp->typeextent);
#5876 size_t nget = ncx_howmany(varp->typeextent);
#5916 size_t nget = ncx_howmany(varp->typeextent);
#5956 size_t nget = ncx_howmany(varp->typeextent);
#5996 size_t nget = ncx_howmany(varp->typeextent);
#6036 size_t nget = ncx_howmany(varp->typeextent);
#6076 size_t nget = ncx_howmany(varp->typeextent);
#6116 size_t nget = ncx_howmany(varp->typeextent);
#6156 size_t nget = ncx_howmany(varp->typeextent);
#6196 size_t nget = ncx_howmany(varp->typeextent);
#6236 size_t nget = ncx_howmany(varp->typeextent);
#6277 size_t nget = ncx_howmany(varp->typeextent);
#6317 size_t nget = ncx_howmany(varp->typeextent);
#6357 size_t nget = ncx_howmany(varp->typeextent);
#6397 size_t nget = ncx_howmany(varp->typeextent);
#6437 size_t nget = ncx_howmany(varp->typeextent);
#6477 size_t nget = ncx_howmany(varp->typeextent);
#6517 size_t nget = ncx_howmany(varp->typeextent);
#6557 size_t nget = ncx_howmany(varp->typeextent);
#6597 size_t nget = ncx_howmany(varp->typeextent);
#6637 size_t nget = ncx_howmany(varp->typeextent);
#6678 size_t nget = ncx_howmany(varp->typeextent);
#6718 size_t nget = ncx_howmany(varp->typeextent);
#6758 size_t nget = ncx_howmany(varp->typeextent);
#6798 size_t nget = ncx_howmany(varp->typeextent);
#6838 size_t nget = ncx_howmany(varp->typeextent);
#6878 size_t nget = ncx_howmany(varp->typeextent);
#6918 size_t nget = ncx_howmany(varp->typeextent);
#6958 size_t nget = ncx_howmany(varp->typeextent);
#6998 size_t nget = ncx_howmany(varp->typeextent);
#7038 size_t nget = ncx_howmany(varp->typeextent);
#7079 size_t nget = ncx_howmany(varp->typeextent);
#7119 size_t nget = ncx_howmany(varp->typeextent);
#7159 size_t nget = ncx_howmany(varp->typeextent);
#7199 size_t nget = ncx_howmany(varp->typeextent);
#7239 size_t nget = ncx_howmany(varp->typeextent);
#7279 size_t nget = ncx_howmany(varp->typeextent);
#7319 size_t nget = ncx_howmany(varp->typeextent);
#7359 size_t nget = ncx_howmany(varp->typeextent);
#7399 size_t nget = ncx_howmany(varp->typeextent);
#7439 size_t nget = ncx_howmany(varp->typeextent);
#7480 size_t nget = ncx_howmany(varp->typeextent);
#7520 size_t nget = ncx_howmany(varp->typeextent);
#7560 size_t nget = ncx_howmany(varp->typeextent);
#7600 size_t nget = ncx_howmany(varp->typeextent);
#7640 size_t nget = ncx_howmany(varp->typeextent);
#7680 size_t nget = ncx_howmany(varp->typeextent);
#7720 size_t nget = ncx_howmany(varp->typeextent);
#7760 size_t nget = ncx_howmany(varp->typeextent);
#7800 size_t nget = ncx_howmany(varp->typeextent);
#7840 size_t nget = ncx_howmany(varp->typeextent);
#7881 size_t nget = ncx_howmany(varp->typeextent);
#7921 size_t nget = ncx_howmany(varp->typeextent);
#7961 size_t nget = ncx_howmany(varp->typeextent);
#8001 size_t nget = ncx_howmany(varp->typeextent);
#8041 size_t nget = ncx_howmany(varp->typeextent);
#8081 size_t nget = ncx_howmany(varp->typeextent);
#8121 size_t nget = ncx_howmany(varp->typeextent);
#8161 size_t nget = ncx_howmany(varp->typeextent);
#8201 size_t nget = ncx_howmany(varp->typeextent);
#8241 size_t nget = ncx_howmany(varp->typeextent);
#8282 size_t nget = ncx_howmany(varp->typeextent);
#8322 size_t nget = ncx_howmany(varp->typeextent);
#8362 size_t nget = ncx_howmany(varp->typeextent);
#8402 size_t nget = ncx_howmany(varp->typeextent);
#8442 size_t nget = ncx_howmany(varp->typeextent);
#8482 size_t nget = ncx_howmany(varp->typeextent);
#8522 size_t nget = ncx_howmany(varp->typeextent);
#8562 size_t nget = ncx_howmany(varp->typeextent);
#8602 size_t nget = ncx_howmany(varp->typeextent);
#8642 size_t nget = ncx_howmany(varp->typeextent);
#8683 size_t nget = ncx_howmany(varp->typeextent);
#8723 size_t nget = ncx_howmany(varp->typeextent);
#8763 size_t nget = ncx_howmany(varp->typeextent);
#8803 size_t nget = ncx_howmany(varp->typeextent);
#8843 size_t nget = ncx_howmany(varp->typeextent);
#8883 size_t nget = ncx_howmany(varp->typeextent);
#8923 size_t nget = ncx_howmany(varp->typeextent);
#8963 size_t nget = ncx_howmany(varp->typeextent);
#9003 size_t nget = ncx_howmany(varp->typeextent);
#9043 size_t nget = ncx_howmany(varp->typeextent);
#9084 size_t nget = ncx_howmany(varp->typeextent);
#9124 size_t nget = ncx_howmany(varp->typeextent);
#9164 size_t nget = ncx_howmany(varp->typeextent);
#9204 size_t nget = ncx_howmany(varp->typeextent);
#9244 size_t nget = ncx_howmany(varp->typeextent);
#9284 size_t nget = ncx_howmany(varp->typeextent);
#9324 size_t nget = ncx_howmany(varp->typeextent);
#9364 size_t nget = ncx_howmany(varp->typeextent);
#9404 size_t nget = ncx_howmany(varp->typeextent);
#9444 size_t nget = ncx_howmany(varp->typeextent);
#9486 size_t nget = ncx_howmany(varp->typeextent);
#9663    switch (CASE(varp->type,memtype)) {
#9995    switch (CASE(varp->type,memtype)) {
#10340    if(memtype == NC_NATmemtype=varp->type;
#10342    if(memtype == NC_CHAR && varp->type != NC_CHAR)
#10344    else if(memtype != NC_CHAR && varp->type == NC_CHAR)
#10471    if(memtype == NC_NATmemtype=varp->type;
#10473    if(memtype == NC_CHAR && varp->type != NC_CHAR)
#10475    else if(memtype != NC_CHAR && varp->type == NC_CHAR)
rec.c#60    nc_type type;
#68    if (ncvarinq(ncidvid, 0, &type, &ndimsdimids, 0) == -1)
#72    size = nctypelen(type);
semantics.c#1010     nc_type type) /* netCDF type code */
#1012    switch (type) {
slabs.c#34val_stuff(typeviival) /* v[ii] = val */
#35     nc_type type; /* netcdf type of v, NC_BYTE, ..., NC_DOUBLE */
#42    switch (type) {
#74val_diff(typeviival) /* v[ii] != val */
#75     nc_type type; /* netcdf type of v, NC_BYTE, ..., NC_DOUBLE */
#82    switch (type) {
#163 varid[iv] = ncvardef(cdfidva[iv].nameva[iv].typeva[iv].ndims,
#180 v = emalloc(WSIZE*XSIZE*YSIZE*ZSIZE * nctypelen(va[iv].type));
#193 val_stuff(va[iv].typeviiVF(corner));
#228 if (val_diff(va[iv].typev, 0, VF(point))) {
#249 if (val_diff(va[iv].typevii-1, VF(point))) {
#277 if (val_diff(va[iv].typev,
#319 if (val_diff(va[iv].type,v,
t_nc.c#51 nc_type type;
#59 nc_type type;
#74chkgot(nc_type type, union getret got, double check)
#76 switch(type){
#154 nc_type type;
#200 assert(nc_def_var(idvp->mnemvp->typevp->ndimsvp->dims,
#504 assert( nc_inq_att(idNC_GLOBALadesc->mnem, &(adesc->type), &(adesc->len))== NC_NOERR);
#505 assert( adesc->type == NC_CHAR );
#520 &(vdesc->type),
#530 if(tvp->type != vdesc->type)
#533 ii, (int)tvp->type, (int)vdesc->type);
#560 if( nc_inq_att(idiireqattr[0], &(adesc->type), &(adesc->len))
#562 assert( adesc->type == NC_CHAR );
#570 nc_inq_att(idiireqattr[1], &(adesc->type), &(adesc->len))
#573 assert( adesc->type == NC_DOUBLE );
#576 chkgot(adesc->typegottvp->validmin);
#580 nc_inq_att(idiireqattr[2], &(adesc->type), &(adesc->len))
#583 assert( adesc->type == NC_DOUBLE );
#586 chkgot(adesc->typegottvp->validmax);
#590 nc_inq_att(idiireqattr[3], &(adesc->type), &(adesc->len))
#593 assert( adesc->type == NC_DOUBLE );
#596 chkgot(adesc->typegottvp->scalemin);
#600 nc_inq_att(idiireqattr[4], &(adesc->type), &(adesc->len))
#603 assert( adesc->type == NC_DOUBLE );
#606 chkgot(adesc->typegottvp->scalemax);
#609 if( nc_inq_att(idiireqattr[5], &(adesc->type), &(adesc->len))== NC_NOERR)
#611 assert( adesc->type == NC_CHAR );
test_put.c#22    const nc_type type,
#30    return MAX(minMIN(maxhash4typerankindexitype)));
#39    const nc_type type,
#47    return MAX(minMIN(maxhash4typerankindexitype)));
#56    const nc_type type,
#64    return MAX(minMIN(maxhash4typerankindexitype)));
#73    const nc_type type,
#81    return MAX(minMIN(maxhash4typerankindexitype)));
#90    const nc_type type,
#98    return MAX(minMIN(maxhash4typerankindexitype)));
#107    const nc_type type,
#115    return MAX(minMIN(maxhash4typerankindexitype)));
#124    const nc_type type,
#132    return MAX(minMIN(maxhash4typerankindexitype)));
#141    const nc_type type,
#149    return MAX(minMIN(maxhash4typerankindexitype)));
#158    const nc_type type,
#166    return MAX(minMIN(maxhash4typerankindexitype)));
#175    const nc_type type,
#183    return MAX(minMIN(maxhash4typerankindexitype)));
#192    const nc_type type,
#200    return MAX(minMIN(maxhash4typerankindexitype)));
#209    const nc_type type,
#217    return MAX(minMIN(maxhash4typerankindexitype)));
testcdf.h#26    nc_type type;
#35    nc_type type;
testnc3perf.c#48    nc_type type;
#73val_stuff(typeviival) /* v[ii] = val */
#74     nc_type type; /* netcdf type of v, NC_BYTE, ..., NC_DOUBLE */
#88    switch (type) {
#118val_diff(typeviival) /* v[ii] != val */
#119     nc_type type; /* netcdf type of v, NC_BYTE, ..., NC_DOUBLE */
#133    switch (type) {
#256 varid[iv] = ncvardef(ncidva[iv].nameva[iv].typeva[iv].ndims,
#275     * nctypelen(va[iv].type));
#288 val_stuff(va[iv].typeviiVF(corner));
#332 if (val_diff(va[iv].typev, 0, VF(point)))
#356 if (val_diff(va[iv].typeviiVF(point)))
#387 if (val_diff(va[iv].typev,
#430 if (val_diff(va[iv].type,v,
tests.h#536double hash( const nc_type type, const int rank, const size_t *index );
#539    const nc_type type,
tst_fills.c#203  nc_type type;
#206  if (nc_inq_vartype(ncidvarid, &type)) ERR;
#207  switch(type) {
#264  nc_type type;
#269  if (nc_inq_vartype(ncidvarid, &type)) ERR;
#270  switch(type) {
tst_h_atts2.c#55  if (obj_info.type != H5O_TYPE_NAMED_DATATYPEERR_RET;
tst_h_atts3.c#156  if (obj_info.type != H5O_TYPE_NAMED_DATATYPEERR;
#275  if (obj_info.type != H5O_TYPE_NAMED_DATATYPEERR;
tst_h_atts4.c#147  if (obj_info.type != H5O_TYPE_NAMED_DATATYPEERR;
tst_h_compounds2.c#140  if (obj_info.type == H5O_TYPE_NAMED_DATATYPE)
#203  if (obj_info.type == H5O_TYPE_NAMED_DATATYPE)
tst_h_files4.c#24   *(int *)op_data = object_info->type;
tst_h_refs.c#84 nc_type type;
#92 if (nc_inq_atttype(ncidNC_GLOBALINT_ATT_NAME, &type)) ERR;
#93 if (type != NC_INTERR;
#100 if (nc_inq_vartype(ncidvarid, &type)) ERR;
#101 if (type != NC_INTERR;
#107 if (nc_inq_atttype(ncidvaridINT_ATT_NAME, &type)) ERR;
#108 if (type != NC_INTERR;
tst_h_scalar.c#99    nc_type type;
#110    if (nc_inq_atttype(ncidobjVSTR_ATT1_NAME, &type)) ERR_GOTO;
#111    if (type != NC_STRINGERR_GOTO;
#120    if (nc_inq_atttype(ncidobjVSTR_ATT2_NAME, &type)) ERR_GOTO;
#121    if (type != NC_STRINGERR_GOTO;
#130    if (nc_inq_atttype(ncidobjVSTR_ATT3_NAME, &type)) ERR_GOTO;
#131    if (type != NC_STRINGERR_GOTO;
#141    if (nc_inq_atttype(ncidobjVSTR_ATT4_NAME, &type)) ERR_GOTO;
#142    if (type != NC_STRINGERR_GOTO;
#152    if (nc_inq_atttype(ncidobjFSTR_ATT_NAME, &type)) ERR_GOTO;
#153    if (type != NC_CHARERR_GOTO;
#162    if (nc_inq_atttype(ncidobjINT_ATT_NAME, &type)) ERR_GOTO;
#163    if (type != NC_INTERR_GOTO;
#269        nc_type type;
#282 if (nc_inq_vartype(ncidvarid, &type)) ERR;
#283 if (type != NC_STRINGERR;
#296 if (nc_inq_vartype(ncidvarid, &type)) ERR;
#297 if (type != NC_STRINGERR;
#311 if (nc_inq_vartype(ncidvarid, &type)) ERR;
#312 if (type != NC_INTERR;
tst_h_strbug.c#96 nc_type type;
#100 if (nc_inq_vartype(ncidvarid, &type)) ERR;
#101 if (type != NC_STRINGERR;
#114     nc_type type;
#118     if (nc_inq_vartype(ncidvarid, &type)) ERR;
#119     if (type != NC_STRINGERR;
#132 nc_type type;
#136 if (nc_inq_att(ncidNC_GLOBALVS_ATT_NAME, &type, &len)) ERR;
#137 if (type != NC_STRINGERR;
#149 nc_type type;
#153 if (nc_inq_att(ncidNC_GLOBALFS_ATT_NAME, &type, &len)) ERR;
#154 if (type != NC_CHARERR;
#168     nc_type type;
#174     if (nc_inq_vartype(ncidvarid, &type)) ERR;
#175     if (type != NC_STRINGERR;
tst_h_vars2.c#84  if (obj_info.type != H5O_TYPE_DATASETERR;
#157  if (obj_info.type != H5O_TYPE_DATASETERR;
#243      if (obj_info.type != H5O_TYPE_DATASETERR;
tst_inq_type.c#35int test_type_should_fail(int ncid, int type, char* tstring) {
#38  if(!nc_inq_type(ncid,type,NULL,NULL)) ERR;
#44int test_type(int ncid, int type, char* tstring) {
#47  if(nc_inq_type(ncid,type,NULL,NULL)) ERR;
tst_large.c#41    nc_type type = NC_BYTE;
#51    if (nc_def_var(ncid, "var", typeNUMDIMSdimids, &varid)) ERR;
util.c#377hash( const nc_type type, const int rank, const size_t *index )
#388 switch (type) {
#404 switch (type) {
#421 switch (type) {
#436 switch (type) {
#452 switch (type) {
#482hash( const nc_type type, const int rank, const size_t *index )
#493 switch (type) {
#509 switch (type) {
#526 switch (type) {
#541 switch (type) {
#557 switch (type) {
#583    const nc_type type,
#590    result = hashtyperankindex );
#591    if (itype == NCT_UCHAR && type == NC_BYTE && result >= -128 && result < 0)
#1091s_nc_type(nc_type type)
#1093 switch((int)type){
v1hpg.c#210 int type = 0;
#214 status =  ncx_get_int_int(gsp->pos, &type);
#223 assert(type == NC_BYTE
#224 || type == NC_CHAR
#225 || type == NC_SHORT
#226 || type == NC_INT
#227 || type == NC_FLOAT
#228 || type == NC_DOUBLE
#229 || type == NC_UBYTE
#230 || type == NC_USHORT
#231 || type == NC_UINT
#232 || type == NC_INT64
#233 || type == NC_UINT64
#234 || type == NC_STRING);
#237 *typep = (nc_typetype;
#249v1h_put_NCtype(v1hs *pspNCtype type)
#251 const int itype = (int) type;
#268 int type = 0;
#272 status =  ncx_get_int_int(gsp->pos, &type);
#282 *typep = (NCtypetype;
#539 NCtype type = NC_UNSPECIFIED;
#545 status = v1h_get_NCtype(gsp, &type);
#556 if(type != NC_DIMENSION)
#666 status = v1h_put_nc_type(psp, &attrp->type);
#726 nc_type type;
#734 status = v1h_get_nc_type(gsp, &type);
#742 attrp = new_x_NC_attr(strptypenelems);
#847 NCtype type = NC_UNSPECIFIED;
#853 status = v1h_get_NCtype(gsp, &type);
#863 if(type != NC_ATTRIBUTE)
#960 status = v1h_put_nc_type(psp, &varp->type);
#1024 status = v1h_get_nc_type(gsp, &varp->type);
#1134 NCtype type = NC_UNSPECIFIED;
#1140 status = v1h_get_NCtype(gsp, &type);
#1151 if(type != NC_VARIABLE)
val.c#17val_fill(typelenvals)
#18     nc_type type; /* netcdf type, NC_BYTE, ..., NC_DOUBLE */
#33    switch (type) {
#68val_fill_zero(typelenvals)
#69     nc_type type; /* netcdf type, NC_BYTE, ..., NC_DOUBLE */
#83    switch (type) {
#122val_cmp (typelenv1v2)
#123     nc_type type; /* netcdf type, NC_BYTE, ..., NC_DOUBLE */
#138    switch (type) {
#199val_out(typelenvals)
#200     nc_type type; /* netcdf type, NC_BYTE, ..., NC_DOUBLE */
#215    switch (type) {
var.c#122new_NC_var(const char *unamenc_type type,
#143 varp->type = type;
#158 NC_var *varp = new_NC_var(rvarp->name->cprvarp->type,
#387ncx_szof(nc_type type)
#389 switch(type){
#431 varp->xsz = ncx_szof(varp->type);
#482 switch(varp->type) {
#570NC3_def_var( int ncid, const char *namenc_type type,
#593 status = nc3_cktype(nc->modetype);
#614 varp = new_NC_var(nametypendimsdimids);
#694 *typep = varp->type;
vardata.c#476 if(vp->type == NC_CHAR && (vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
#770 if(vp->type == NC_CHAR &&
vardef.c#142    if (ncvardef(cdfidva[0].nameva[0].typeva[0].ndimsva[0].dims)
#172 if ((va_id[iv] = ncvardef(cdfidva[iv].nameva[iv].type,
#186 if (ncvarinq(cdfidva_id[iv], tmp.name, &tmp.type,
#193     tmp.type != va[iv].type ||
#213    if (ncvardef(cdfidva[0].nameva[0].type,
#224    if (ncvardef(cdfid, "badndims", va[0].type, -1, va[0].dims) != -1) {
#230    if (ncvardef(cdfid, "baddims", va[0].typeva[0].ndimsva[0].dims)
#245 switch(va[iv].type) {
varget.c#65 hc.vals = emalloc(nctypelen(test.vars[iv].type) + 8);
vargetg.c#67 hc.vals = emalloc(nctypelen(test.vars[iv].type) + 8);
varput.c#69 hc.vals = emalloc(nctypelen(test.vars[iv].type));
#70 val_fill(test.vars[iv].type, 1, hc.vals);
varputg.c#69 hc.vals = emalloc(nctypelen(test.vars[iv].type));
#70 val_fill(test.vars[iv].type, 1, hc.vals);
vartests.c#55    xx.namexx.typexx.ndimsxx.dims)) == -1) {
#127 if (ncvarinq(cdfidvaridvar.name, &var.type,
#139 if (var.type != test.vars[varid].type) {
#141   pnamevar.typetest.vars[varid].typevarid);
#165 if (ncvarinq(cdfidvaridvar.name, &var.type,
#176 if (var.type != test.vars[varid].type) {
#178   pnamevar.typetest.vars[varid].typevarid);
#197    if (ncvarinq(cdfid, -1, var.name, &var.type,
#199 ncvarinq(cdfidtest.nvarsvar.name, &var.type,
#215 if (ncvarinq(cdfidvaridvar.name, &var.type,
#284     switch (test.vars[iv].type) { /* get values of right type to put */
#326     switch (test.vars[iv].type) { /* compare values of right type */
#591    yy.nameyy.typeyy.ndimsyy.dims)) == -1) {
#599    if (ncvardef(cdfidzz.namezz.typezz.ndimszz.dims) == -1) {
#617   &var.type, &var.ndimsvar.dims, &var.natts) == -1) {
vputget.c#80     hc[ie].vals = emalloc(nel[ie]*nctypelen(test.vars[iv].type) + 8);
#81     tmp.vals = emalloc(nel[ie]*nctypelen(test.vars[iv].type) + 8);
#84     val_fill(test.vars[iv].typenel[ie], hc[ie].vals);
#112 if (val_cmp(test.vars[iv].typenel[ie],
vputgetg.c#80nctypelen(test.vars[iv].type)
#91nctypelen(test.vars[iv].type)
#104 ? -nctypelen(test.vars[iv].type)
#108 hc[2].offset = (nel[2]-1)*nctypelen(test.vars[iv].type);
#112     int nelms = (int)nel[ie]*nctypelen(test.vars[iv].type) + 8;
#118     val_fill(test.vars[iv].typenel[ie], hc[ie].vals);
#164     if (val_cmp(test.vars[iv].typenel[ie],


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