bm_file.c#266   nc_type xtype, xtype2;


#338      if ((ret = nc_inq_var(ncid1, v, name, &xtype, &ndims, dimids, &natts)))


#344      if (strcmp(name, name2) || xtype != xtype2 || ndims != ndims2 || natts != natts2)


#395      if ((ret = nc_inq_type(ncid1, xtype, NULL, &type_size)))


#570	 nc_type xtype;


#577	 if ((ret = nc_inq_var(ncid_in, v, name, &xtype, &ndims, dimids, &natts)))


#581	 if (nc_def_var(ncid_out, name, xtype, ndims, dimids, &varid_out)) ERR;


#639      nc_type xtype;


#654      if ((ret = nc_inq_var(ncid_in, v, name, &xtype, &ndims, dimids, &natts)))


#658      if ((ret = nc_inq_type(ncid_in, xtype, type_name, &type_size)))


dattget.c#48   nc_type xtype;


#54   if ((stat = nc_inq_atttype(ncid, varid, name, &xtype)))


#58   return ncp->dispatch->get_att(ncid, varid, name, value, xtype);


dattput.c#229nc_put_att(int ncid, int varid, const char *name, nc_type xtype,


#235   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#236				 value, xtype);


#241		 nc_type xtype, size_t len, const signed char *value)


#246   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#252		 nc_type xtype, size_t len, const unsigned char *value)


#257   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#263		 nc_type xtype, size_t len, const short *value)


#268   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#274	       nc_type xtype, size_t len, const int *value)


#279   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#285		nc_type xtype, size_t len, const long *value)


#290   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#296		 nc_type xtype, size_t len, const float *value)


#301   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#307		  nc_type xtype, size_t len, const double *value)


#312   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#318		 nc_type xtype, size_t len, const unsigned char *value)


#323   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#329		  nc_type xtype, size_t len, const unsigned short *value)


#334   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#340		nc_type xtype, size_t len, const unsigned int *value)


#345   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#351		    nc_type xtype, size_t len,


#357   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


#363		     nc_type xtype, size_t len,


#369   return ncp->dispatch->put_att(ncid, varid, name, xtype, len,


dcompound.c#99nc_insert_compound(int ncid, nc_type xtype, const char *name,


#105   return ncp->dispatch->insert_compound(ncid, xtype, name,


#141nc_insert_array_compound(int ncid, nc_type xtype, const char *name,


#148   return ncp->dispatch->insert_array_compound(ncid,xtype,name,offset,field_typeid,ndims,dim_sizes);


#175nc_inq_compound(int ncid, nc_type xtype, char *name,


#179   int stat = nc_inq_user_type(ncid,xtype,name,sizep,NULL,nfieldsp,&class);


#203nc_inq_compound_name(int ncid, nc_type xtype, char *name)


#205   return nc_inq_compound(ncid,xtype,name,NULL,NULL);


#226nc_inq_compound_size(int ncid, nc_type xtype, size_t *sizep)


#228   return nc_inq_compound(ncid,xtype,NULL,sizep,NULL);


#249nc_inq_compound_nfields(int ncid, nc_type xtype, size_t *nfieldsp)


#251   return nc_inq_compound(ncid,xtype,NULL,NULL,nfieldsp);


#287nc_inq_compound_field(int ncid, nc_type xtype, int fieldid,


#295   return ncp->dispatch->inq_compound_field(ncid, xtype, fieldid,


#321nc_inq_compound_fieldname(int ncid, nc_type xtype, int fieldid,


#327   return ncp->dispatch->inq_compound_field(ncid, xtype, fieldid,


#353nc_inq_compound_fieldoffset(int ncid, nc_type xtype, int fieldid,


#359   return ncp->dispatch->inq_compound_field(ncid,xtype,fieldid,NULL,offsetp,NULL,NULL,NULL);


#383nc_inq_compound_fieldtype(int ncid, nc_type xtype, int fieldid,


#389   return ncp->dispatch->inq_compound_field(ncid,xtype,fieldid,NULL,NULL,field_typeidp,NULL,NULL);


#413nc_inq_compound_fieldndims(int ncid, nc_type xtype, int fieldid,


#419   return ncp->dispatch->inq_compound_field(ncid,xtype,fieldid,NULL,NULL,NULL,ndimsp,NULL);


#443nc_inq_compound_fielddim_sizes(int ncid, nc_type xtype, int fieldid,


#449   return ncp->dispatch->inq_compound_field(ncid, xtype, fieldid,


#475nc_inq_compound_fieldindex(int ncid, nc_type xtype, const char *name,


#481   return ncp->dispatch->inq_compound_fieldindex(ncid,xtype,name,fieldidp);


dcopy.c#257   nc_type xtype;


#273   if ((retval = nc_inq_var(ncid_in, varid_in, name, &xtype,


#299       src_format == NC_FORMAT_NETCDF4 && xtype > NC_DOUBLE)


#303   if ((retval = nc_inq_type(ncid_in, xtype, type_name, &type_size)))


#313   if ((retval = nc_def_var(ncid_out, name, xtype,


#388      switch (xtype)


#484   nc_type xtype;


#493   if ((res = nc_inq_att(ncid_in, varid_in, name, &xtype, &len)))


#496   if (xtype < NC_STRING)


#501         size_t size = NC_atomictypelen(xtype);


#510	 res = nc_put_att(ncid_out, varid_out, name, xtype,


#516   else if (xtype == NC_STRING)


#540      if ((res = NC_find_equal_type(ncid_in, xtype, ncid_out, &xtype_out)))


#545	 if ((res = nc_inq_user_type(ncid_in, xtype, NULL, &size,


denum.c#71nc_insert_enum(int ncid, nc_type xtype, const char *name,


#77    return ncp->dispatch->insert_enum(ncid, xtype, name,


#107nc_inq_enum(int ncid, nc_type xtype, char *name, nc_type *base_nc_typep,


#111    int stat = nc_inq_user_type(ncid, xtype, name, base_sizep,


#140nc_inq_enum_member(int ncid, nc_type xtype, int idx, char *name,


#146    return ncp->dispatch->inq_enum_member(ncid, xtype, idx, name, value);


#168nc_inq_enum_ident(int ncid, nc_type xtype, long long value,


#174    return ncp->dispatch->inq_enum_ident(ncid,xtype,value,identifier);


dfile.c#1578nc_inq_type(int ncid, nc_type xtype, char *name, size_t *size)


#1584   if(xtype <= NC_NAT) return NC_EBADTYPE;


#1590	if(xtype <= ATOMICTYPEMAX4) {


#1591            if(name) strncpy(name,NC_atomictypename(xtype),NC_MAX_NAME);


#1592            if(size) *size = NC_atomictypelen(xtype);


#1597      return ncp->dispatch->inq_type(ncid,xtype,name,size);


dopaque.c#61nc_inq_opaque(int ncid, nc_type xtype, char *name, size_t *sizep)


#64    int stat = nc_inq_user_type(ncid,xtype,name,sizep,NULL,NULL,&class);


dtype.c#135nc_inq_user_type(int ncid, nc_type xtype, char *name, size_t *size,


#141    return ncp->dispatch->inq_user_type(ncid, xtype, name, size,


dvar.c#207nc_def_var(int ncid, const char *name, nc_type xtype,


#216   return ncp->dispatch->def_var(ncid, name, xtype, ndims,


#448NC_atomictypelen(nc_type xtype)


#451   switch(xtype) {


#476NC_atomictypename(nc_type xtype)


#479   switch(xtype) {


dvarget.c#631   nc_type xtype = NC_NAT;


#634   stat = nc_inq_vartype(ncid, varid, &xtype);


#636   return NC_get_vara(ncid, varid, startp, countp, ip, xtype);


dvarput.c#578   nc_type xtype;


#580   stat = nc_inq_vartype(ncid, varid, &xtype);


#582   return NC_put_vara(ncid, varid, startp, countp, op, xtype);


dvlen.c#118nc_inq_vlen(int ncid, nc_type xtype, char *name, size_t *datum_sizep, nc_type *base_nc_typep)


#121    int stat = nc_inq_user_type(ncid,xtype,name,datum_sizep,base_nc_typep,NULL,&class);


nc3dispatch.c#438NC3_inq_enum_ident(int ncid, nc_type xtype, long long value, char *identifier)


nc3dispatch.h#157	 nc_type xtype, int ndims, const int *dimidsp, int *varidp);


nc4attr.c#30	    nc_type *xtype, nc_type mem_type, size_t *lenp,


#67		return nc4_get_att_special(h5, norm_name, xtype, mem_type, lenp, attnum, is_long, data);


#99   if (xtype)


#100      *xtype = att->nc_typeid;


#951NC4_put_att(int ncid, int varid, const char *name, nc_type xtype,


#954   return nc4_put_att_tc(ncid, varid, name, xtype, memtype, 0, nelems, value);


nc4dispatch.h#128	 nc_type xtype, int ndims, const int *dimidsp, int *varidp);


nc4file.c#753		nc_type *xtype)


#759   assert(h5 && xtype);


#771         *xtype = NC_STRING;


#773         *xtype = NC_CHAR;


#784         *xtype = NC_BYTE;


#791         *xtype = NC_SHORT;


#798         *xtype = NC_INT;


#805         *xtype = NC_FLOAT;


#812         *xtype = NC_DOUBLE;


#819         *xtype = NC_UBYTE;


#826         *xtype = NC_USHORT;


#833         *xtype = NC_UINT;


#840         *xtype = NC_INT64;


#847         *xtype = NC_UINT64;


#856         *xtype = type->nc_typeid;


#860   *xtype = NC_NAT;


#2386			  nc_type *xtype, NC_TYPE_INFO_T *type_info)


#2398   assert(h5 && xtype);


#2403       *xtype = NC_CHAR;


#2408       *xtype = NC_UBYTE;


#2412       *xtype = NC_UBYTE;


#2417       *xtype = NC_BYTE;


#2421       *xtype = NC_BYTE;


#2426       *xtype = NC_SHORT;


#2430       *xtype = NC_SHORT;


#2435       *xtype = NC_USHORT;


#2439       *xtype = NC_USHORT;


#2444       *xtype = NC_INT;


#2448        *xtype = NC_INT;


#2453       *xtype = NC_UINT;


#2457        *xtype = NC_UINT;


#2462       *xtype = NC_FLOAT;


#2466       *xtype = NC_FLOAT;


#2471       *xtype = NC_DOUBLE;


#2475       *xtype = NC_DOUBLE;


#2480       *xtype = NC_NAT;


#2495      type_info->nc_typeid = *xtype;


nc4hdf.c#298nc4_get_hdf_typeid(NC_HDF5_FILE_INFO_T *h5, nc_type xtype,


#310  if (xtype == NC_NAT)


#313  else if (xtype == NC_CHAR || xtype == NC_STRING)


#316      if (xtype == NC_CHAR)


#346      switch (xtype)


#440          if (nc4_find_type(h5, xtype, &type))


#3800nc4_get_typelen_mem(NC_HDF5_FILE_INFO_T *h5, nc_type xtype, int is_long,


#3806  LOG((4, "%s xtype: %d", __func__, xtype));


#3810  switch (xtype)


#3844  if ((retval = nc4_find_type(h5, xtype, &type)))


#3859nc4_get_typeclass(const NC_HDF5_FILE_INFO_T *h5, nc_type xtype, int *type_class)


#3863  LOG((4, "%s xtype: %d", __func__, xtype));


#3867  if (xtype <= NC_STRING)


#3869      switch (xtype)


#3906      if ((retval = nc4_find_type(h5, xtype, &type)))


nc4internal.c#834		   nc_type xtype, int ndims, const int *dim_sizesp)


#855   field->nc_typeid = xtype;


nc4internal.h#331int nc4_get_typelen_mem(NC_HDF5_FILE_INFO_T *h5, nc_type xtype,


#344		 const size_t *countp, nc_type xtype, int is_long, void *op);


#346		 const size_t *countp, nc_type xtype, int is_long, void *op);


#378int nc4_get_hdf_typeid(NC_HDF5_FILE_INFO_T *h5, nc_type xtype,


#380int nc4_get_typeclass(const NC_HDF5_FILE_INFO_T *h5, nc_type xtype,


#397		       nc_type xtype, int ndims, const int *dim_sizesp);


nc4type.c#565NC4_inq_enum_ident(int ncid, nc_type xtype, long long value, char *identifier)


#574   LOG((3, "nc_inq_enum_ident: xtype %d value %d\n", xtype, value));


#581   if (!(type = nc4_rec_find_nc_type(grp->nc4_info->root_grp, xtype)))


nc4var.c#346nc_def_var_nc4(int ncid, const char *name, nc_type xtype,


#378   if (xtype == NC_NAT)


#382   if (h5->cmode & NC_CLASSIC_MODEL && xtype > NC_DOUBLE)


#407   LOG((3, "%s: name %s type %d ndims %d", __func__, norm_name, xtype, ndims));


#432   if (xtype <= NC_STRING)


#436      type_info->nc_typeid = xtype;


#438      if ((retval = nc4_get_hdf_typeid(h5, xtype, &type_info->hdf_typeid,


#449      if (xtype == NC_CHAR)


#479      if (nc4_find_type(grp->nc4_info, xtype, &type_info))


#609NC4_def_var(int ncid, const char *name, nc_type xtype, int ndims,


#616        __func__, ncid, name, xtype, ndims));


#627   return nc_def_var_nc4(ncid, name, xtype, ndims, dimidsp, varidp);


ncaux.c#334findfirstfield(int ncid, nc_type xtype)


#337    nc_type fieldtype = xtype;


#338    if(xtype <= NC_MAX_ATOMIC_TYPE) goto done;


#340    status = nc_inq_compound_fieldtype(ncid, xtype, 0, &fieldtype);


ncd2dispatch.c#2233  	     nc_type xtype, int ndims, const int *dimidsp, int *varidp)


#2626NCD2_inq_compound_field(int ncid, nc_type xtype, int fieldid, char *name,


#2633    ret = nc_inq_compound_field(getnc3id(drno), xtype, fieldid, name, offsetp, field_typeidp, ndimsp, dim_sizesp);


#2638NCD2_inq_compound_fieldindex(int ncid, nc_type xtype, const char *name,


#2644    ret = nc_inq_compound_fieldindex(getnc3id(drno), xtype, name, fieldidp);


ncd2dispatch.h#130	 nc_type xtype, int ndims, const int *dimidsp, int *varidp);


ncdispatch.h#320extern size_t NC_atomictypelen(nc_type xtype);


#321extern char* NC_atomictypename(nc_type xtype);


ncpdispatch.c#438    nc_type xtype;


#443    status = NCP_inq_att(ncid,varid,name,&xtype,NULL);


#445    if(memtype == NC_NAT) memtype = xtype;


#481	nc_type xtype,


#507        return ncmpi_put_att_schar(nc->int_ncid, varid, name, xtype, mpilen, (signed char*)ip);


#509        return ncmpi_put_att_short(nc->int_ncid, varid, name, xtype, mpilen, (short*)ip);


#511        return ncmpi_put_att_int(nc->int_ncid, varid, name, xtype, mpilen, (int*)ip);


#513        return ncmpi_put_att_float(nc->int_ncid, varid, name, xtype, mpilen, (float*)ip);


#515        return ncmpi_put_att_double(nc->int_ncid, varid, name, xtype, mpilen, (double*)ip);


#517         return ncmpi_put_att_uchar(nc->int_ncid, varid, name, xtype, mpilen, (unsigned char*)ip);


#519        return ncmpi_put_att_ushort(nc->int_ncid, varid, name, xtype, mpilen, (unsigned short*)ip);


#521        return ncmpi_put_att_uint(nc->int_ncid, varid, name, xtype, mpilen, (unsigned int*)ip);


#523        return ncmpi_put_att_longlong(nc->int_ncid, varid, name, xtype, mpilen, (long long*)ip);


#525        return ncmpi_put_att_ulonglong(nc->int_ncid, varid, name, xtype, mpilen, (unsigned long long*)ip);


#533NCP_def_var(int ncid, const char *name, nc_type xtype,


#545    status = ncmpi_def_var(nc->int_ncid,name,xtype,ndims,dimidsp,varidp);


#1418NCP_inq_enum_ident(int ncid, nc_type xtype, long long value, char *identifier)


netcdf.h#593nc_insert_compound(int ncid, nc_type xtype, const char *name,


#598nc_insert_array_compound(int ncid, nc_type xtype, const char *name,


#604nc_inq_type(int ncid, nc_type xtype, char *name, size_t *size);


#612nc_inq_compound(int ncid, nc_type xtype, char *name, size_t *sizep,


#617nc_inq_compound_name(int ncid, nc_type xtype, char *name);


#621nc_inq_compound_size(int ncid, nc_type xtype, size_t *sizep);


#625nc_inq_compound_nfields(int ncid, nc_type xtype, size_t *nfieldsp);


#629nc_inq_compound_field(int ncid, nc_type xtype, int fieldid, char *name,


#635nc_inq_compound_fieldname(int ncid, nc_type xtype, int fieldid,


#640nc_inq_compound_fieldindex(int ncid, nc_type xtype, const char *name,


#645nc_inq_compound_fieldoffset(int ncid, nc_type xtype, int fieldid,


#650nc_inq_compound_fieldtype(int ncid, nc_type xtype, int fieldid,


#656nc_inq_compound_fieldndims(int ncid, nc_type xtype, int fieldid,


#662nc_inq_compound_fielddim_sizes(int ncid, nc_type xtype, int fieldid,


#683nc_inq_vlen(int ncid, nc_type xtype, char *name, size_t *datum_sizep,


#714nc_inq_user_type(int ncid, nc_type xtype, char *name, size_t *size,


#719nc_put_att(int ncid, int varid, const char *name, nc_type xtype,


#737nc_insert_enum(int ncid, nc_type xtype, const char *name,


#743nc_inq_enum(int ncid, nc_type xtype, char *name, nc_type *base_nc_typep,


#749nc_inq_enum_member(int ncid, nc_type xtype, int idx, char *name,


#755nc_inq_enum_ident(int ncid, nc_type xtype, long long value, char *identifier);


#765nc_inq_opaque(int ncid, nc_type xtype, char *name, size_t *sizep);


#1009nc_put_att_uchar(int ncid, int varid, const char *name, nc_type xtype,


#1016nc_put_att_schar(int ncid, int varid, const char *name, nc_type xtype,


#1023nc_put_att_short(int ncid, int varid, const char *name, nc_type xtype,


#1030nc_put_att_int(int ncid, int varid, const char *name, nc_type xtype,


#1037nc_put_att_long(int ncid, int varid, const char *name, nc_type xtype,


#1044nc_put_att_float(int ncid, int varid, const char *name, nc_type xtype,


#1051nc_put_att_double(int ncid, int varid, const char *name, nc_type xtype,


#1058nc_put_att_ushort(int ncid, int varid, const char *name, nc_type xtype,


#1065nc_put_att_uint(int ncid, int varid, const char *name, nc_type xtype,


#1072nc_put_att_longlong(int ncid, int varid, const char *name, nc_type xtype,


#1079nc_put_att_ulonglong(int ncid, int varid, const char *name, nc_type xtype,


#1091nc_def_var(int ncid, const char *name, nc_type xtype, int ndims,


#1680nc_put_att_ubyte(int ncid, int varid, const char *name, nc_type xtype,


#1876ncattput(int ncid, int varid, const char *name, nc_type xtype,


#1899ncvardef(int ncid, const char *name, nc_type xtype,


netcdf_f.h#55nc_inq_compound_field_f(int ncid, nc_type xtype, int fieldid, char *name,


tst_atts1.c#709      nc_type xtype;


#713      if (nc_inq_att(ncid, NC_GLOBAL, ATT_TEXT_NAME, &xtype, &len)) ERR;


#714      if (len || xtype != NC_CHAR) ERR;


#716      if (nc_inq_att(ncid, NC_GLOBAL, ATT_SCHAR_NAME, &xtype, &len)) ERR;


#717      if (len || xtype != NC_BYTE) ERR;


#719      if (nc_inq_att(ncid, NC_GLOBAL, ATT_UCHAR_NAME, &xtype, &len)) ERR;


#720      if (len || xtype != NC_UBYTE) ERR;


#722      if (nc_inq_att(ncid, NC_GLOBAL, ATT_SHORT_NAME, &xtype, &len)) ERR;


#723      if (len || xtype != NC_SHORT) ERR;


#725      if (nc_inq_att(ncid, NC_GLOBAL, ATT_INT_NAME, &xtype, &len)) ERR;


#726      if (len || xtype != NC_INT) ERR;


#728      if (nc_inq_att(ncid, NC_GLOBAL, ATT_FLOAT_NAME, &xtype, &len)) ERR;


#729      if (len || xtype != NC_FLOAT) ERR;


#731      if (nc_inq_att(ncid, NC_GLOBAL, ATT_DOUBLE_NAME, &xtype, &len)) ERR;


#732      if (len || xtype != NC_DOUBLE) ERR;


tst_atts3.c#446      nc_type xtype;


#454      if (nc_inq_att(ncid, NC_GLOBAL, ATT_TEXT_NAME, &xtype, &len)) ERR;


#455      if (len || xtype != NC_CHAR) ERR;


#457      if (nc_inq_att(ncid, NC_GLOBAL, ATT_SCHAR_NAME, &xtype, &len)) ERR;


#458      if (len || xtype != NC_BYTE) ERR;


#460      if (nc_inq_att(ncid, NC_GLOBAL, ATT_SHORT_NAME, &xtype, &len)) ERR;


#461      if (len || xtype != NC_SHORT) ERR;


#463      if (nc_inq_att(ncid, NC_GLOBAL, ATT_INT_NAME, &xtype, &len)) ERR;


#464      if (len || xtype != NC_INT) ERR;


#466      if (nc_inq_att(ncid, NC_GLOBAL, ATT_FLOAT_NAME, &xtype, &len)) ERR;


#467      if (len || xtype != NC_FLOAT) ERR;


#469      if (nc_inq_att(ncid, NC_GLOBAL, ATT_DOUBLE_NAME, &xtype, &len)) ERR;


#470      if (len || xtype != NC_DOUBLE) ERR;


tst_compounds.c#35      nc_type xtype, field_xtype;


#72      if (nc_inq_var(ncid, 0, name, &xtype, &ndims, dimids, &natts)) ERR;


#74      if (nc_inq_compound(ncid, xtype, name, &size, &nfields)) ERR;


#76      if (nc_inq_compound_name(ncid, xtype, name)) ERR;


#78      if (nc_inq_compound_size(ncid, xtype, &size)) ERR;


#80      if (nc_inq_compound_nfields(ncid, xtype, &nfields)) ERR;


#82      if (nc_inq_compound_field(ncid, xtype, 0, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#85      if (nc_inq_compound_field(ncid, xtype, 1, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#87      if (nc_inq_compound_fieldname(ncid, xtype, 1, name)) ERR;


#89      if (nc_inq_compound_fieldindex(ncid, xtype, BATTLES_WITH_KLINGONS, &fieldid)) ERR;


#91      if (nc_inq_compound_fieldoffset(ncid, xtype, 1, &offset)) ERR;


#93      if (nc_inq_compound_fieldtype(ncid, xtype, 1, &field_xtype)) ERR;


#108      nc_type xtype, field_xtype;


#158      if (nc_inq_var(ncid, 0, name, &xtype, &ndims, dimids, &natts)) ERR;


#160      if (nc_inq_compound(ncid, xtype, name, &size, &nfields)) ERR;


#162      if (nc_inq_compound_name(ncid, xtype, name)) ERR;


#164      if (nc_inq_compound_size(ncid, xtype, &size)) ERR;


#166      if (nc_inq_compound_nfields(ncid, xtype, &nfields)) ERR;


#168      if (nc_inq_compound_field(ncid, xtype, 0, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#171      if (nc_inq_compound_field(ncid, xtype, 1, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#173      if (nc_inq_compound_fieldname(ncid, xtype, 1, name)) ERR;


#175      if (nc_inq_compound_fieldindex(ncid, xtype, BATTLES_WITH_KLINGONS, &fieldid)) ERR;


#177      if (nc_inq_compound_fieldoffset(ncid, xtype, 1, &offset)) ERR;


#179      if (nc_inq_compound_fieldtype(ncid, xtype, 1, &field_xtype)) ERR;


#218      nc_type xtype;


#233      if (nc_inq_vartype(ncid, 0, &xtype)) ERR;


#234      if (nc_inq_compound(ncid, xtype, name_in, &size_in, &nfields_in)) ERR;


#246      nc_type xtype, field_xtype;


#295      if (nc_inq_att(ncid, NC_GLOBAL, SERVICE_RECORD, &xtype, &len)) ERR;


#297      if (nc_inq_compound(ncid, xtype, name, &size, &nfields)) ERR;


#299      if (nc_inq_compound_nfields(ncid, xtype, &nfields)) ERR;


#301      if (nc_inq_compound_field(ncid, xtype, 0, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#303      if (nc_inq_compound_field(ncid, xtype, 1, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#305      if (nc_inq_compound_fieldindex(ncid, xtype, BATTLES_WITH_KLINGONS, &fieldid)) ERR;


#307      if (nc_inq_compound_fieldoffset(ncid, xtype, 1, &offset)) ERR;


#309      if (nc_inq_compound_fieldtype(ncid, xtype, 1, &field_xtype)) ERR;


#322      nc_type xtype, field_xtype;


#379	 if (nc_inq_var(ncid, 0, name, &xtype, &ndims, dimids, &natts)) ERR;


#381	 if (nc_inq_compound(ncid, xtype, name, &size, &nfields)) ERR;


#383	 if (nc_inq_compound_field(ncid, xtype, 0, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#385	 if (nc_inq_compound_field(ncid, xtype, 1, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#388	 if (nc_inq_compound_field(ncid, xtype, 2, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#391	 if (nc_inq_compound_field(ncid, xtype, 3, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#394	 if (nc_inq_compound_field(ncid, xtype, 4, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#419      nc_type xtype;


#473      if (nc_inq_var(ncid, 0, name, &xtype, &ndims, dimids, &natts)) ERR;


#475      if (nc_inq_compound(ncid, xtype, name, &size, &nfields)) ERR;


#477      if (nc_inq_compound_field(ncid, xtype, 1, name, &offset, &field_typeid,


#498      nc_type xtype, field_xtype;


#595      if (nc_inq_att(ncid, NC_GLOBAL, "HR_Records", &xtype, &len)) ERR;


#597      if (nc_inq_compound(ncid, xtype, name, &size, &nfields)) ERR;


#599      if (nc_inq_compound_field(ncid, xtype, 0, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#601      if (nc_inq_compound_field(ncid, xtype, 1, name, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#834      nc_type xtype;


#886      if (nc_inq_att(ncid, NC_GLOBAL, "HR_Records", &xtype, &len)) ERR;


#900      nc_type xtype;


#955      if (nc_inq_att(ncid, NC_GLOBAL, "HR_Records", &xtype, &len)) ERR;


tst_compounds2.c#28      nc_type xtype, type_id;


#82      if (nc_inq_att(ncid, NC_GLOBAL, "a1", &xtype, &len)) ERR;


#97      nc_type xtype, type_id;


#147      if (nc_inq_att(ncid, NC_GLOBAL, "a1", &xtype, &len)) ERR;


#149      if (nc_inq_compound_field(ncid, xtype, 0, field_name_in,


#153      if (nc_inq_compound_field(ncid, xtype, 1, field_name_in,


tst_compounds3.c#44      nc_type xtype, field_xtype;


#95      if (nc_inq_var(ncid, 0, name_in, &xtype, &ndims, dimids, &natts)) ERR;


#97      if (nc_inq_compound(ncid, xtype, name_in, &size, &nfields)) ERR;


#99      if (nc_inq_compound_field(ncid, xtype, 0, name_in, &offset, &field_xtype, &field_ndims, field_sizes)) ERR;


#103      if (nc_inq_compound_field(ncid, xtype, 1, name_in, &offset, &field_xtype, &field_ndims,


tst_create_files.c#102       nc_type xtype;


#128       if (nc_inq_var(ncid, 0, name_in, &xtype, &ndims, dimids, &natts)) ERR;


#129       if (strcmp(name_in, var_name) || xtype != NC_FLOAT || ndims != 1 ||


tst_dims2.c#31      nc_type xtype_in, xtype = NC_CHAR;


#41      if (nc_def_var(ncid, CRAZY, xtype, NDIMS1, &nuts_dimid, &varid)) ERR;


#47      if (strcmp(name_in, CRAZY) || xtype_in != xtype || ndims_in != NDIMS1 ||


#58      if (strcmp(name_in, CRAZY) || xtype_in != xtype || ndims_in != NDIMS1 ||


#209      nc_type xtype_in, xtype = NC_CHAR;


#219      if (nc_def_var(ncid, TIME, xtype, 2, dimids, &varid)) ERR;


#225      if (strcmp(name_in, TIME) || xtype_in != xtype || ndims_in != NDIMS ||


#236      if (strcmp(name_in, TIME) || xtype_in != xtype || ndims_in != NDIMS ||


#352      nc_type xtype_in, xtype = NC_CHAR;


#364      if (nc_def_var(ncid, TIME, xtype, 2, dimids, &varid)) ERR;


#370      if (strcmp(name_in, TIME) || xtype_in != xtype || ndims_in != NDIMS ||


#389      if (strcmp(name_in, TIME) || xtype_in != xtype || ndims_in != NDIMS ||


#411      if (strcmp(name_in, TIME) || xtype_in != xtype || ndims_in != NDIMS ||


tst_fileinfo.c#81        nc_type xtype;


#114	if(nc_inq_att(root,NC_GLOBAL,NCPROPS,&xtype,&len)!=0) ERR;


#115	if(xtype != NC_CHAR) ERR;


#127	if(nc_inq_atttype(root,NC_GLOBAL,NCPROPS,&xtype)!=0) ERR;


#128	if(xtype != NC_CHAR) ERR;


#143	if(nc_inq_att(root,NC_GLOBAL,SUPERBLOCKATT,&xtype,&len)!=0) ERR;


#144	if(xtype != NC_INT) ERR;


#154	if(nc_inq_atttype(root,NC_GLOBAL,SUPERBLOCKATT,&xtype)!=0) ERR;


#155	if(xtype != NC_INT) ERR;


#170	if(nc_inq_att(root,NC_GLOBAL,ISNETCDF4ATT,&xtype,&len)!=0) ERR;


#171	if(xtype != NC_INT) ERR;


#181	if(nc_inq_atttype(root,NC_GLOBAL,ISNETCDF4ATT,&xtype)!=0) ERR;


#182	if(xtype != NC_INT) ERR;


tst_grps.c#966      int ncid, xtype, g1id, class;


#976      if (nc_def_opaque(g1id, BASE_SIZE, TYPE_NAME, &xtype)) ERR;


#977      if (nc_put_att(g1id, NC_GLOBAL, DATE_MOVIE, xtype, 1, &data)) ERR;


#980      if (nc_inq_user_type(g1id, xtype, name_in, &len_in, NULL, NULL, &class)) ERR;


#988      if (nc_inq_user_type(g1id, xtype, name_in, &len_in, NULL, NULL, &class)) ERR;


#999      if (nc_inq_user_type(g1id, xtype, name_in, &len_in, NULL, NULL, &class)) ERR;


tst_opaques.c#27   nc_type xtype;


#49      if (nc_def_opaque(ncid, BASE_SIZE, TYPE_NAME, &xtype)) ERR;


#50      if (nc_inq_user_type(ncid, xtype, name_in, &base_size_in, &base_nc_type_in, &nfields_in, &class_in)) ERR;


#53      if (nc_inq_opaque(ncid, xtype, name_in, &base_size_in)) ERR;


#55      if (nc_def_var(ncid, VAR_NAME, xtype, 0, NULL, &varid)) ERR;


#83      if (nc_def_opaque(ncid, BASE_SIZE, TYPE_NAME, &xtype)) ERR;


#84      if (nc_inq_user_type(ncid, xtype, name_in, &base_size_in, &base_nc_type_in, &nfields_in, &class_in)) ERR;


#87      if (nc_inq_opaque(ncid, xtype, name_in, &base_size_in)) ERR;


#90      if (nc_def_var(ncid, VAR_NAME, xtype, 1, dimids, &varid)) ERR;


#113      if (nc_def_opaque(ncid, BASE_SIZE, TYPE_NAME, &xtype)) ERR;


#116      if (nc_put_att(ncid, NC_GLOBAL, ATT_NAME, xtype, DIM_LEN, data)) ERR;


#136      if (nc_def_opaque(ncid, BASE_SIZE, TYPE_NAME, &xtype)) ERR;


#139      if (nc_inq_user_type(ncid, xtype, name_in, &base_size_in, &base_nc_type_in,


#143      if (nc_inq_opaque(ncid, xtype, name_in, &base_size_in)) ERR;


#147      if (nc_put_att(ncid, NC_GLOBAL, ATT_NAME, xtype, DIM_LEN, data)) ERR;


#155      if (nc_inq_att(ncid, NC_GLOBAL, ATT_NAME, &xtype, &size_in)) ERR;


#157      if (nc_inq_user_type(ncid, xtype, name_in, &base_size_in, &base_nc_type_in, &nfields_in, &class_in)) ERR;


#160      if (nc_inq_opaque(ncid, xtype, name_in, &base_size_in)) ERR;


util.c#674	int xtype;		/* index of type */


#684	for (rank = 0, vn = 0, xtype = 0, an = 0;  rank <= MAX_RANK; rank++)


#697			     tc++, vn++, xtype = (xtype + 1) % numTypes)


#701				var_name[vn][0] = type_letter[xtype];


#702				var_type[vn] = char2type (type_letter[xtype]);




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