add.c#32    if (test->ndims >= MAX_NC_DIMS) {
#34       "%s: too many dimensions (%d)", pnametest->ndims);
#37    test->dims[test->ndims].size = idim->size;
#38    test->dims[test->ndims].name = (char *) emalloc(strlen(idim->name) + 1);
#39    (void) strcpy(test->dims[test->ndims].nameidim->name);
#41      test->xdimid = test->ndims;
#42    test->ndims++;
#62    test->vars[test->nvars].ndims = ivar->ndims;
#63    test->vars[test->nvars].dims = (int *) emalloc(sizeof(int)*ivar->ndims);
#64    for (i = 0; i < ivar->ndimsi++)
#114    test->ndims = 0;
#203    for (id = 0; id < varp->ndimsid++)
#206      id < varp->ndims - 1 ? ", " : "");
atttests.c#50    int ndims; /* number of dimensions */
#91    if (ncinquire(cdfid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
#106    if (ncinquire(cdfid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
#141    ww.dims = (int *) emalloc(sizeof(int) * ww.ndims);
#142    for (id = 0; id < ww.ndimsid++)
#145    ww.nameww.typeww.ndimsww.dims)) == -1) {
#389    vv.dims = (int *) emalloc(sizeof(int) * vv.ndims);
#390    for (id = 0; id < vv.ndimsid++)
#392    if ((vv_id = ncvardef(cdfidvv.namevv.typevv.ndimsvv.dims))
#487    uu.dims = (int *) emalloc(sizeof(int) * uu.ndims);
#488    for (id = 0; id < uu.ndimsid++)
#491    uu.nameuu.typeuu.ndimsuu.dims)) == -1) {
#670    tt.dims = (int *) emalloc(sizeof(int) * tt.ndims);
#671    for (id=0; id < tt.ndimsid++)
#673    if ((tt_id=ncvardef(cdfidtt.namett.typett.ndimstt.dims)) == -1) {
#684    tu.dims = (int *) emalloc(sizeof(int) * tu.ndims);
#685    for (id = 0; id < tu.ndimsid++)
#687    if ((tu_id=ncvardef(cdfidtu.nametu.typetu.ndimstu.dims)) == -1) {
#711    for (id = 0; id < tu.ndimsid++) { /* copy dimensions from source */
#718    if ((tu2_id=ncvardef(cdfid2tu.nametu.typetu.ndimstu.dims)) == -1) {
#1256    int ndims; /* number of dimensions */
#1279    yav.dims = (int *) emalloc(sizeof(int) * yav.ndims);
#1280    for (id = 0; id < yav.ndimsid++)
#1282    if ((yav_id=ncvardef(cdfidyav.nameyav.typeyav.ndimsyav.dims))
#1295    if (ncinquire(cdfid, &ndims, &nvars, &ngatts1, &xdimid) == -1) {
#1301    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndimsvtmp.dims,
#1313    if (ncinquire(cdfid, &ndims, &nvars, &ngatts2, &xdimid) == -1) {
#1333    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndims,
bm_file.c#45      int ndims;
#75get_starts_counts(int ndims, size_t *dimlen, int p, int my_rank,
#92      for (d = 0, *slice_len = 1, total_len = 1; d < vo->ndimsd++)
#107      for (d = 0; d < vo->ndimsd++)
#114  for (d = 0; d < vo->ndimsd++)
#120  if (d != vo->ndims)
#149      for (d = 1; d < ndimsd++)
#267   int nvarsndimsdimids[NC_MAX_VAR_DIMS], nattsreal_ndims;
#310   if ((ret = nc_inq(ncid1, &ndims, &nvars, &natts, &unlimdimid)))
#314   if (ndims != ndims2 || nvars != nvars2 || natts != natts2 ||
#319   for (d = 0; d < ndimsd++)
#338      if ((ret = nc_inq_var(ncid1vname, &xtype, &ndimsdimids, &natts)))
#344      if (strcmp(namename2) || xtype != xtype2 || ndims != ndims2 || natts != natts2)
#346      for (d = 0; d < ndimsd++)
#361      real_ndims = ndims ? ndims : 1;
#374      for (d=0; d<ndimsd++)
#379      if (ndims == 0)
#382      if ((ret = get_starts_counts(ndimsdimlenpmy_rankslow_countuse_scs,
#470   int nattsnvarsndimsunlimdimid;
#534   if ((ret = nc_inq(ncid_in, &ndims, &nvars, &natts, &unlimdimid)))
#540      for (d = 0; d < ndimsd++)
#571  int ndimsdimids[NC_MAX_VAR_DIMS], natts;
#577  if ((ret = nc_inq_var(ncid_invname, &xtype, &ndimsdimids, &natts)))
#581  if (nc_def_var(ncid_outnamextypendimsdimids, &varid_out)) ERR;
#632 my_ranknvarsnattsndims, *meta_write_us);
#640      int ndimsdimids[NC_MAX_VAR_DIMS], nattsreal_ndims;
#654      if ((ret = nc_inq_var(ncid_invname, &xtype, &ndimsdimids, &natts)))
#664      real_ndims = ndims ? ndims : 1;
#669      for (d = 0; d < ndimsd++)
#679      if (ndims == 0)
#691      if ((ret = get_starts_counts(ndimsdimlenpmy_rankslow_countuse_scs,
#765      for (d = 0, var_num_bytes = type_sized < ndimsd++)
#827   int indimso1;
#900               for (ndims = 0, str2 = token; ; str2 = NULL)
#914      vo[num_vo].chunksize[ndims++] = tmp_int;
#917        vo[num_vo].ndims = ndims;
#927               for (ndims = 0, str2 = token; ; str2 = NULL)
#934      sscanf(subtoken, "%ld", &(vo[num_vo].start[ndims++]));
#936        vo[num_vo].ndims = ndims;
#947               for (ndims = 0, str2 = token; ; str2 = NULL)
#954      sscanf(subtoken, "%ld", &(vo[num_vo].count[ndims++]));
#956        vo[num_vo].ndims = ndims;
#966               for (ndims = 0, str2 = token; ; str2 = NULL)
#973      sscanf(subtoken, "%ld", &(vo[num_vo].inc[ndims++]));
#975        vo[num_vo].ndims = ndims;
#1051     for (d = 0; d < vo[v].ndimsd++)
cdftests.c#277    aa.dims = (int *)emalloc(sizeof(int) * aa.ndims);
#280    aa.ndimsaa.dims)) == -1) {
#369    bb.dims = (int *) emalloc(sizeof(int) * bb.ndims);
#373    bb.ndimsbb.dims)) == -1) {
#484    int ndims; /* number of dimensions */
#515    if (ncinquire(ncid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
#520    if (ndims != test.ndims) {
#522     pnamendimstest.ndims);
#564 cc[iv].dims = (int *) emalloc(sizeof(int) * cc[iv].ndims);
#566 for (id = 1; id < cc[iv].ndimsid++)
#569        cc[iv].ndimscc[iv].dims)) == -1) {
#585    if (ncinquire(ncid, &ndims, &nvars, &ngatts, &xdimid) == -1) {
#590    if (ndims != test.ndims) {
#592     pnamendimstest.ndims);
#621    if (ncinquire (ncid, &ndims, &nvars, &ngatts, &xdimid) != -1) {
#678    dd.dims = (int *) emalloc(sizeof(int) * dd.ndims);
#680    if ((dd_id=ncvardef(ncid0dd.namedd.typedd.ndimsdd.dims)) == -1) {
chunkspec.c#16    size_t ndims; /* number of dimensions in chunkspec string */
#45    size_t ndims = 0;
#50    chunkspecs.ndims = 0;
#65     ndims++;
#71    ndims++;
#72    chunkspecs.ndims = ndims;
#73    chunkspecs.dimids = (int *) emalloc(ndims * sizeof(int));
#74    chunkspecs.chunksizes = (size_t *) emalloc(ndims * sizeof(size_t));
#140    for(idim = 0; idim < chunkspecs.ndimsidim++) {
#153    return chunkspecs.ndims;
dapdump.c#29   &hdr->ndims,
#36 hdr->ncid,hdr->ngatts,hdr->ndims,hdr->nvars,hdr->unlimid);
#81    hdr->dims = (Dim*)malloc(hdr->ndims*sizeof(Dim));
#83    for(i=0;i<hdr->ndims;i++) {
#103   &var->ndims,
#112 var->ndims);
#114 for(j=0;j<var->ndims;j++) {
dapdump.h#20    int ndims;
#31    int ndims;
dcompound.c#143  int ndims, const int *dim_sizes)
#148   return ncp->dispatch->insert_array_compound(ncid,xtype,name,offset,field_typeid,ndims,dim_sizes);
dcopy.c#258   int ndimsdimids_in[NC_MAX_VAR_DIMS], dimids_out[NC_MAX_VAR_DIMS], nattsreal_ndims;
#274                            &ndimsdimids_in, &natts)))
#277   for(i = 0; i < ndimsi++) {
#314                            ndimsdimids_out, &varid_out)))
#334   real_ndims = ndims ? ndims : 1;
#353   for (d=0; d<ndimsd++)
#363   if (ndims == 0)
dgroup.c#205int nc_inq_dimids(int ncid, int *ndims, int *dimids, int include_parents)
#210    return ncp->dispatch->inq_dimids(ncid,ndims,dimids,include_parents);
dimmap.c#11    size_t ndims;
#23    dimmap.ndims = n;
dimtests.c#40    int ndims; /* number of dimensions */
#69    if (dimid != test.ndims - 1) {
#71       pnamedimidtest.ndims-1);
#86    if (ncinquire(cdfid, &ndims, &nvars, &natts, &xdimid) == -1) {
#226    for (dimid = 0 ; dimid < test.ndimsdimid++) { /* loop on all dim ids */
#249    for (dimid = 0 ; dimid < test.ndimsdimid++) { /* loop on all dim ids */
#269 ncdiminq(cdfidtest.ndimsdim.name, &dim.size) != -1) {
#283    if (test.ndims >= 1) { /* if any dimensions have been defined */
#373 ncdimrename(cdfidtest.ndimsdim.name) != -1) {
driver.c#109   for (i = 0; i < test.ndimsi++)
dumplib.c#1697    int ndimsndims1;
#1711 NC_CHECKnc_inq_dimids(ncid, &ndimsNULLinclude_parents ) );
#1713 NC_CHECKnc_inq_ndims(ncid, &ndims) );
#1717 dims = (ncdim_t *) emalloc((ndims + 1) * sizeof(ncdim_t));
#1720 dimids = (int *) emalloc((ndims + 1) * sizeof(int));
#1726     for(i = 0; i < ndimsi++) {
#1732    } while (ndims != ndims1);
#1734    for (dimid = 0; dimid < ndimsdimid++) {
#1740    for (dimid = 0; dimid < ndimsdimid++) {
#1873 int ndims;
#1875 NC_CHECKnc_inq_dimids(grpid, &ndimsNULLDONT_INCLUDE_PARENTS) );
#1876 num_dims += ndims;
#1880 int ndimsidim, *dimidsnundims;
#1882 NC_CHECKnc_inq_dimids(grpid, &ndimsNULLDONT_INCLUDE_PARENTS) );
#1883 dimids = emalloc((ndims + 1) * sizeof(int));
#1884 NC_CHECKnc_inq_dimids(grpid, &ndimsdimidsDONT_INCLUDE_PARENTS) );
#1886 for(idim = 0; idim < ndimsidim++) {
#1890 assert(nundims <= ndims);
dv2i.c#28# define A_DECL(nametypendimsrhs) \
#33# define A_INIT(lhstypendimsrhs)
#49   int ndims=-1, status;
#51   if ((status = nc_inq_varndims(ncidvarid, &ndims)))
#56   return ndims;
#69#define NDIMS_DECL const int ndims = nvdims(ncidvarid); \
#72# define A_DECL(nametypendimsrhs) \
#73  type *const name = (type*) nvmalloc((ndims) * sizeof(type))
#82# define A_INIT(lhstypendimsrhs) \
#84   if((off_t)ndims >= 0) {     \
#87 type *const end = lhs + ndims; \
#95    if ((off_t)ndims < 0) {nc_advise("nvdims",NC_EMAXDIMS,"ndims %d",ndims); return -1;}
#111    int ndims = 0;
#131 status = nc_inq_varndims(ncidvarid, &ndims);
#137 if (ndims > 0 && dimids[0] == recdimid) {
#158    int ndims;
#170    status = nc_inq_varndims(ncidvarid, &ndims);
#176    if (ndims == 0 || dimids[0] != recdimid) {
#180    for (id = 1; id < ndimsid++) {
#200    int ndims;
#204    status = nc_inq_varndims(ncidvarid, &ndims);
#210    if (ndims == 0 || sizes == NULL)
#212    for (id = 0; id < ndimsid++) {
#472    int* ndims,
#488 if(ndims != NULL)
#489 *ndims = (int) nd;
#613    int ndims,
#618 const int status = nc_def_var(ncidnamedatatypendimsdim, &varid);
#651    int* ndims,
#667 if(ndims != NULL)
#668 *ndims = (int) nd;
#686 A_DECL(coordp, size_t, (size_t)ndimsindex);
#687 A_INIT(coordp, size_t, (size_t)ndimsindex);
#710 A_DECL(coordp, size_t, ndimsindex);
#711 A_INIT(coordp, size_t, ndimsindex);
#735 A_DECL(stp, size_t, ndimsstart);
#736 A_DECL(cntp, size_t, ndimscount);
#737 A_INIT(stp, size_t, ndimsstart);
#738 A_INIT(cntp, size_t, ndimscount);
#763 A_DECL(stp, size_t, ndimsstart);
#764 A_DECL(cntp, size_t, ndimscount);
#765 A_INIT(stp, size_t, ndimsstart);
#766 A_INIT(cntp, size_t, ndimscount);
#797 A_DECL(stp, size_t, ndimsstart);
#798 A_DECL(cntp, size_t, ndimscount);
#799 A_DECL(strdpptrdiff_tndimsstride);
#800 A_INIT(stp, size_t, ndimsstart);
#801 A_INIT(cntp, size_t, ndimscount);
#802 A_INIT(strdpptrdiff_tndimsstride);
#834 A_DECL(stp, size_t, ndimsstart);
#835 A_DECL(cntp, size_t, ndimscount);
#836 A_DECL(strdpptrdiff_tndimsstride);
#837 A_INIT(stp, size_t, ndimsstart);
#838 A_INIT(cntp, size_t, ndimscount);
#839 A_INIT(strdpptrdiff_tndimsstride);
#867 int ndims = 0;
#878 ret = nc_inq_varndims(ncidvarid, &ndims);
#883 imp = (ptrdiff_t*) malloc(ndims * sizeof(ptrdiff_t));
#884 for (i=0; i<ndimsi++) imp[i] = map[i] / el_size;
#888 A_DECL(stp, size_t, ndimsstart);
#889 A_DECL(cntp, size_t, ndimscount);
#890 A_DECL(strdpptrdiff_tndimsstride);
#891 A_INIT(stp, size_t, ndimsstart);
#892 A_INIT(cntp, size_t, ndimscount);
#893 A_INIT(strdpptrdiff_tndimsstride);
#924 int ndims = 0;
#935 ret = nc_inq_varndims(ncidvarid, &ndims);
#940 imp = (ptrdiff_t*) malloc(ndims * sizeof(ptrdiff_t));
#941 for (i=0; i<ndimsi++) imp[i] = map[i] / el_size;
#945 A_DECL(stp, size_t, ndimsstart);
#946 A_DECL(cntp, size_t, ndimscount);
#947 A_DECL(strdpptrdiff_tndimsstride);
#948 A_INIT(stp, size_t, ndimsstart);
#949 A_INIT(cntp, size_t, ndimscount);
#950 A_INIT(strdpptrdiff_tndimsstride);
dvar.c#208    int ndims,  const int *dimidsp, int *varidp)
#216   return ncp->dispatch->def_var(ncidnamextypendims,
#299   int ndims;
#304   status = nc_inq_varndims(ncid,varid,&ndims);
#306   if(ndims == 0) return 0; /* scalar */
#505NC_getshape(int ncid, int varid, int ndims, size_t* shape)
#513   for(i = 0; i < ndimsi++)
dvarget.c#94      int ndims;
#95      stat = nc_inq_varndims(ncidvarid, &ndims);
#97      stat = NC_getshape(ncid,varid,ndims,shape);
#111   int ndims;
#113   int stat = nc_inq_varndims(ncid,varid, &ndims);
#115   stat = NC_getshape(ncid,varidndimsshape);
dvarput.c#72      int ndims;
#73      stat = nc_inq_varndims(ncidvarid, &ndims);
#75      stat = NC_getshape(ncidvaridndimsshape);
#88   int ndims;
#90   int stat = nc_inq_varndims(ncid,varid, &ndims);
#92   stat = NC_getshape(ncid,varidndimsshape);
genbin.c#33    int ndimsnvarsnattsngatts;
#41    ndims = listlength(dimdefs);
#91    if (ndims > 0) {
#92        for(idim = 0; idim < ndimsidim++) {
#106     if (vsym->typ.dimset.ndims > 0) { /* a dimensioned variable */
#109 for(idim=0;idim<vsym->typ.dimset.ndims;idim++)
#114            vsym->typ.dimset.ndims,
#121            vsym->typ.dimset.ndims,
#321     if(efield->typ.dimset.ndims == 0){
#332 for(j=0;j<efield->typ.dimset.ndims;j++) {
#342 efield->typ.dimset.ndims,
genc.c#42    int ndimsnvarsnattsngatts;
#49    ndims = listlength(dimdefs);
#166    if (ndims > 0) {
#169 for(idim = 0; idim < ndimsidim++) {
#177 for(idim = 0; idim < ndimsidim++) {
#196      if(vsym->typ.dimset.ndims > maxdims)
#197 maxdims = vsym->typ.dimset.ndims;
#214     vsym->typ.dimset.ndims);
#222 if (vsym->typ.dimset.ndims > 0) {
#307    if (ndims > 0) {
#310        for(idim = 0; idim < ndimsidim++) {
#335     if(dimset->ndims > 0) {
#336         for(idim = 0; idim < dimset->ndimsidim++) {
#352 (dimset->ndims == 0?"0":poolcat(cname(vsym),"_dims")),
#747     if(efield->typ.dimset.ndims > 0) {
#749         for(j=0;j<efield->typ.dimset.ndims;j++) {
#856     if(efield->typ.dimset.ndims == 0) continue;
#859 cname(efield),efield->typ.dimset.ndims);
#860     for(j=0;j<efield->typ.dimset.ndims;j++) {
#881     if(efield->typ.dimset.ndims > 0){
#889     efield->typ.dimset.ndims,
genchar.c#84    int rank = dimset->ndims;
generate.c#81    int rank = dimset->ndims;
#136    int rank = dimset->ndims;
#225    int rank = dimset->ndims;
#385        if(tsym->typ.dimset.ndims > 0) {
#409    ASSERT(dimset->ndims > 0);
genf77.c#51    int ndimsnvarsnattsngatts;
#54    ndims = listlength(dimdefs);
#73    if (ndims > 0) {
#76 for(idim = 0; idim < ndimsidim++) {
#94    if (ndims > 0) {
#97 for(idim = 0; idim < ndimsidim++) {
#121     vsym->typ.dimset.ndims);
#128     if(vsym->typ.dimset.ndims > 0) {
#142     if(vsym->typ.dimset.ndims == 0) {/* scalar */
#151                for(i=dimset->ndims-1;i>=0;i--) {
#231    if (ndims > 0) {
#234        for(idim = 0; idim < ndimsidim++) {
#254     if(dimset->ndims > 0) {
#256         for(idim = 0; idim < dimset->ndimsidim++) {
#257     int reverse = (dimset->ndims - idim) - 1;
#272 (dimset->ndims == 0?"0":poolcat(f77name(vsym),"_dims")),
#326                if(vsym->typ.dimset.ndims == 0)
#343                    && vsym->typ.dimset.ndims > 0) {
#812 for(i=0;i<dimset->ndims;i++) {
#813     int reverse = (dimset->ndims - i) - 1;
#820 for(i=0;i<dimset->ndims;i++) {
#821     int reverse = (dimset->ndims - i) - 1;
genj.c#44    int ndimsnvarsnattsngatts;
#46    ndims = listlength(dimdefs);
#70    if(ndims > 0) {
#73 for(idim = 0; idim < ndimsidim++) {
#92      if(vsym->typ.dimset.ndims > maxdims)
#93 maxdims = vsym->typ.dimset.ndims;
#112    if(ndims > 0) {
#115        for(idim = 0; idim < ndimsidim++) {
#141            if(dimset->ndims > 0) {
#142                for(idim = 0; idim < dimset->ndimsidim++) {
genlib.c#49    for (idim = 0; idim < ndimsidim++) {
#59   vars[ivar].ndims,
#236    if (ndims > 0) {
#239 for (idim = 0; idim < ndimsidim++) {
#246 for (idim = 0; idim < ndimsidim++) {
#261      if (vars[ivar].ndims > maxdims)
#262 maxdims = vars[ivar].ndims;
#276     vars[ivar].ndims);
#283 if (vars[ivar].ndims > 0) {
#345    if (ndims > 0) {
#349    for (idim = 0; idim < ndimsidim++) {
#363     for (idim = 0; idim < vars[ivar].ndimsidim++) {
#371     if (vars[ivar].ndims > 0) { /* a dimensioned variable */
#610    if (ndims > 0) {
#612 for (idim = 0; idim < ndimsidim++) {
#618 for (idim = 0; idim < ndimsidim++) {
#622 for (idim = 0; idim < ndimsidim++) {
#638      if (vars[ivar].ndims > maxdims)
#639 maxdims = vars[ivar].ndims;
#655     vars[ivar].ndims);
#661     if (vars[ivar].ndims > 0) {
#677     if (v->ndims > 0 && v->dims[0] == rec_dim) {
#685     if (v->ndims == 0) { /* scalar */
#692 for (idim = v->ndims-1; idim >= 0; idim--) {
#749    if (ndims > 0)
#751    for (idim = 0; idim < ndimsidim++) {
#767     for (idim = 0; idim < vars[ivar].ndimsidim++) {
#770 vars[ivar].ndims - idim, /* reverse dimensions */
#774     if (vars[ivar].ndims > 0) { /* a dimensioned variable */
#1288 if (vars[ivar].ndims > 0 && vars[ivar].dims[0] == rec_dim) {
#1290     for (jdim = 0; jdim < vars[ivar].ndimsjdim++) {
#1340        if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1354            if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1378            if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1396            if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1413        for (idim = 0; idim < ndimsidim++) {
#1428            if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1435            if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1437                        v->ndims);
#1445     if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1458            if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1476     for (idim = v->ndims-1; idim >= 0; idim--) {
#1502            if (v->ndims > 0 && v->dims[0] == rec_dim && v->type != NC_CHAR) {
#1507                    for (idim = 1; idim < v->ndimsidim++) {
#1521     if (v->ndims > 0 && v->dims[0] == rec_dim) {
#1527 for (idim = 0; idim < v->ndimsidim++) {
#1531 for (idim = v->ndims-1; idim > 0; idim--) {
#1533     v->ndims - idimdims[v->dims[idim]].lname);
#1537                        v->ndimsv->lname);
getfill.c#67     if(field->typ.dimset.ndims > 0) {
#124    int lastdim = (index == (dimset->ndims - 1));
init.c#20int ndims; /* number of dimensions declared for netcdf */
#40    ndims = 0;
load.c#87    if (vars[varnum].ndims > 0) {
#212     for (idim = 0; idim < vars[varnum].ndimsidim++) {
#219     for (idim = 0; idim < vars[varnum].ndimsidim++) {
#411    if (vars[varnum].ndims > 0 && vars[varnum].dims[0] == rec_dim) {
#433    if (v->ndims == 0 || v->dims[0] != rec_dim) {
#445    if (v->ndims >0 && v->dims[0] == rec_dim) {
#533    if (vars[varnum].ndims > 0) {
#544    for (idim = 1; idim < vars[varnum].ndimsidim++) {
nc3dispatch.c#52static int NC3_inq_dimids(int,int* ndims,int*,int);
#307    int retval,d,ndims;
#310    if ((retval = NC3_inq(ncid, &ndims,  NULLNULLNULL)))
#312    if(ndimsp) *ndimsp = ndims;
#314        for (d = 0; d < ndimsd++)
#398  int ndims, const int *dim_sizes)
nc3dispatch.h#157  nc_type xtype, int ndims, const int *dimidsp, int *varidp);
nc3internal.c#917           for(i = 0; i < last_fix->ndimsi++ ) {
nc3internal.h#183 size_t ndims; /* assoc->count */
#212 size_t ndims);
nc4dispatch.h#128  nc_type xtype, int ndims, const int *dimidsp, int *varidp);
#182NC4_inq_dimids(int, int * ndims, int *, int);
nc4file.c#584   int initial_grp_ndims = grp->ndims;  /* Retain for error recovery */
#616   grp->ndims++;
#677      grp->ndims = initial_grp_ndims;
#709   if (!ret && npoints != var->ndimsret++;
#715   for (d = 0; d < var->ndimsd++) {
#1292                  int ndimsdim_size[NC_MAX_VAR_DIMS];
#1296                  if ((ndims = H5Tget_array_ndims(member_hdf_typeid)) < 0) {
#1300                  if (H5Tget_array_dims(member_hdf_typeiddimsNULL) != ndims) {
#1304                  for (d = 0; d < ndimsd++)
#1316                                                   member_xtypendimsdim_size)))
#1507         size_t ndimsNC_DIM_INFO_T *dim)
#1546   var->ndims = ndims;
#1550   if (var->ndims)
#1552      if (!(var->dim = calloc(var->ndims, sizeof(NC_DIM_INFO_T *))))
#1554      if (!(var->dimids = calloc(var->ndims, sizeof(int))))
#1615      if (!(var->chunksizes = malloc(var->ndims * sizeof(size_t))))
#1617      for (d = 0; d < var->ndimsd++)
#1710      assert(ndims);
#1712      if (var->ndims > 1)
#1741      if (num_scales && ndims)
#1745         if (NULL == (var->dimscale_attached = calloc(ndims, sizeof(nc_bool_t))))
#1750         if (NULL == (var->dimscale_hdf5_objids = malloc(ndims * sizeof(struct hdf5_objid))))
#1752         for (d = 0; d < var->ndimsd++)
#1927   int ndims;
#1937   if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0)
#1962      if ((retval = read_var(grpdatasetidobj_namendimsdim)))
#2623      var->ndims = rank;
#2663      if (var->ndims)
#2665 if (!(var->dim = malloc(sizeof(NC_DIM_INFO_T *) * var->ndims))) {
#2670 if (!(var->dimids = malloc(sizeof(int) * var->ndims))) {
#2678      for (d = 0; d < var->ndimsd++)
#2708     grp->ndims++;
#2784 if (!(var->chunksizes = malloc(var->ndims * sizeof(size_t))))
#2786         for (d = 0; d < var->ndimsd++) {
nc4grp.c#448NC4_inq_dimids(int ncid, int *ndims, int *dimids, int include_parents)
#503   if (ndims)
#504      *ndims = num;
nc4hdf.c#85    for (d = 0; d < var->ndimsd++)
#125    for (d = 0; d < var->ndimsd++)
#502  LOG((4, "%s: var name %s ndims %d", __func__var->namevar->ndims));
#504  for (d2 = 0; d2 < var->ndimsd2++)
#584  for (i = 0; i < var->ndimsi++)
#595      var->ndims)
#622  for (d2 = 0; d2 < var->ndimsd2++)
#656      if ((mem_spaceid = H5Screate_simple(var->ndimscountNULL)) < 0)
#673      if (var->ndims)
#674        for (d2=0; d2<var->ndimsd2++)
#727  if (var->ndims)
#729      for (d2 = 0; d2 < var->ndimsd2++)
#779              if(MPI_SUCCESS != MPI_Allreduce(MPI_IN_PLACExtend_sizevar->ndimsMPI_UNSIGNED_LONG_LONGMPI_MAXh5->comm))
#784          for (d2 = 0; d2 < var->ndimsd2++)
#909  for (i = 0; i < var->ndimsi++)
#920      var->ndims)
#947  for (d2 = 0; d2 < var->ndimsd2++) {
#997  for (d2 = 0; d2 < var->ndimsd2++)
#1028          if ((mem_spaceid = H5Screate_simple(var->ndimscountNULL)) < 0)
#1061          if (var->ndims)
#1062            for (d2 = 0; d2 < var->ndimsd2++)
#1195        for (real_data_size = file_type_sized2 = 0; d2 < var->ndimsd2++)
#1204      for (fill_len = 1, d2 = 0; d2 < var->ndimsd2++)
#1456  coords_len[0] = var->ndims;
#1625  if (var->ndims)
#1630      for (d = 0; d < var->ndimsd++) {
#1653      for (d = 0; d < var->ndimsd++)
#1675                                     1/(double)(var->ndims - unlimdim));
#1695          if (H5Pset_chunk(plistidvar->ndimschunksize) < 0)
#1700      if ((spaceid = H5Screate_simple(var->ndimsdimsizemaxdimsize)) < 0)
#1746      if (var->ndims > 1)
#1808  for (d = 0; d < var->ndimsd++)
#1862          if (field->ndims)
#1867              for (d = 0; d < field->ndimsd++)
#1869              if ((hdf_typeid = H5Tarray_create(hdf_base_typeidfield->ndims,
#2075          for (d = 0; d < var->ndimsd++)
#2270          for (d = 0; d < var->ndimsd++)
#2312      if (write_dimid && var->ndims)
#2332            memset(var->dimscale_attached, 0, sizeof(nc_bool_t) * var->ndims);
#2454          if (!(new_size = malloc(v1->ndims * sizeof(hsize_t))))
#2456          for (d1 = 0; d1 < v1->ndimsd1++)
#2501      if (var->dimscale && var->ndims)
#2518          if (var->ndims > 1)
#3647      int ndims = var->ndims;
#3649      for (d = 0; d < ndimsd++)
#3665              for (d = 0; d < var->ndimsd++)
#3708              if (var->ndims)
#3710                  if (!(h5dimlen = malloc(var->ndims * sizeof(hsize_t))))
#3712                  if (!(h5dimlenmax = malloc(var->ndims * sizeof(hsize_t))))
#3723                  if (dataset_ndims != var->ndims) {
#3749              for (d = 0; d < var->ndimsd++)
#3769                      grp->ndims++;
nc4internal.c#156       if (dataset_ndims != var->ndims)
#834    nc_type xtype, int ndims, const int *dim_sizesp)
#857   field->ndims = ndims;
#858   if (ndims)
#862      if (!(field->dim_size = malloc(ndims * sizeof(int))))
#868      for (i = 0; i < ndimsi++)
#1285   if (coord_var->ndims)
#1291      if (NULL == (coord_var->dimscale_attached = calloc(coord_var->ndims, sizeof(nc_bool_t))))
#1320      for (d = 0; d < var->ndims && !finishedd++)
#1344                     if (dims_detached++ == var->ndims)
#1481      if(var->ndims > 0)
#1483         dims_string = (char*)malloc(sizeof(char)*(var->ndims*4));
#1485         for (d = 0; d < var->ndimsd++)
#1492    tabsvar->varidvar->namevar->type_info->nc_typeidvar->ndims, (int)var->dimscale,
#1516  field->offsetfield->nc_typeidfield->ndims));
nc4internal.h#152   int ndims;
#203   int ndims;
#281   int ndims;
#308   int ndims;
#397        nc_type xtype, int ndims, const int *dim_sizesp);
nc4type.c#329  int ndims, const int *dim_sizesp)
#338 nameoffsetfield_typeidndims));
#364     ndimsdim_sizesp)))
#464     *ndimsp = field->ndims;
#466     for (d = 0; d < field->ndimsd++)
nc4var.c#215   for (d = 0; d < var->ndimsd++)
#255   for (d = 0; d < var->ndimsd++)
#269   if (var->ndims == 1 && num_unlim == 1) {
#280   if (var->ndims > 1 && var->ndims == num_unlim) { /* all dims unlimited */
#281       suggested_size = pow((double)DEFAULT_CHUNK_SIZE/type_size, 1.0/(double)(var->ndims));
#282       for (d = 0; d < var->ndimsd++)
#292   for (d = 0; d < var->ndimsd++)
#296        1.0/(double)(var->ndims - num_unlim)) * var->dim[d]->len - .5);
#306   for (d = 0; d < var->ndimsd++)
#321      for (d = 0; d < var->ndimsd++)
#328   for (d = 0; d < var->ndimsd++)
#347               int ndims, const int *dimidsp, int *varidp)
#386   if((unsigned long) ndims > X_INT_MAX) /* Backward compat */
#402   for (d = 0; d < ndimsd++)
#407   LOG((3, "%s: name %s type %d ndims %d", __func__norm_namextypendims));
#411      for (dd = 0; dd < ndimsdd++)
#426   var->ndims = ndims;
#489   if (ndims)
#491      if (!(var->dim = calloc(ndims, sizeof(NC_DIM_INFO_T *))))
#493      if (!(var->dimids = calloc(ndims, sizeof(int))))
#504   for (d = 0; d < ndimsd++)
#552 var->ndimsvar->name));
#553   if (var->ndims)
#554      if (!(var->chunksizes = calloc(var->ndims, sizeof(size_t))))
#572   (!var->ndims || dimidsp[0] != dim->dimid))
#589   if (!var->dimscale && ndims)
#590      if (ndims && !(var->dimscale_attached = calloc(ndims, sizeof(nc_bool_t))))
#609NC4_def_var(int ncid, const char *namenc_type xtype, int ndims,
#616        __func__ncidnamextypendims));
#619   if (ndims && !dimidsp)
#627   return nc_def_var_nc4(ncidnamextypendimsdimidspvaridp);
#688      *ndimsp = var->ndims;
#690      for (d = 0; d < var->ndimsd++)
#701      for (d = 0; d < var->ndimsd++)
#862      if (!var->ndims)
#897      for (d = 0; d < var->ndimsd++)
#919  for (d = 0; d < var->ndimsd++) {
#925  for (d = 0; d < var->ndimsd++)
#1037   if (var->ndims)
#1038      if (!(cs = malloc(var->ndims * sizeof(size_t))))
#1047      for (i = 0; i < var->ndimsi++)
#1054   if (var->ndims)
#1088   if (var->ndims)
#1089      if (!(cs = malloc(var->ndims * sizeof(size_t))))
#1093   for (i = 0; i < var->ndimsi++)
#1099   if (var->ndims)
#1244      if (var->ndims)
#1344   for (d = 0; d < var->ndimsd++)
nc_iter.c#22static int up_start(int ndims, const size_t *dims, int incdim, size_t inc,
#51    int ndims;     /* number of dimensions for variable */
#58    stat = nciter_ndims(vsym, &ndims);
#64    for(dim = 0; dim < ndimsdim++) {
#71    stat = nc_blkio_init(bufsizevalue_sizendimsdimsizesiterp);
#180     int ndims,  /* Number of dimensions */
#209    if(ndimsp) *ndimsp = sym->typ.dimset.ndims;
#217    int ndims = sym->typ.dimset.ndims;
#218    for(i=0;i<ndims;i++) {
ncaux.c#31    size_t ndims;
#107    int ndims, const int* dimsizes)
#116    if(ndims < 0) {status = NC_EINVAL; goto done;}
#117    for(i=0;i<ndims;i++) {
#131    field->ndims = (size_t)ndims;
#132    memcpy(field->dimsizes,dimsizes,sizeof(int)*field->ndims);
#142dimproduct(size_t ndims, int* dimsizes)
#146    for(i=0;i<ndims;i++) product *= (size_t)dimsizes[i];
#168 if(field->ndims > 0) {
#174 (int)field->ndims,field->dimsizes);
#361 totaldimsize = dimproduct(field->ndims,field->dimsizes);
ncaux.h#22    int ndims, const int* dimsizes);
nccomps.h#72    int ndims; /* number of dimensions (rank) */
nccopy.c#135    int ndims;
#147    NC_CHECK(nc_inq_varndims(igrpvarid, &ndims));
#148    chunksizes = (size_t *) emalloc((ndims + 1) * sizeof(size_t));
#149    if(ndims > 0) {
#156 for(dim = 0; dim < ndimsdim++) {
#176    int ndims;
#188    NC_CHECK(nc_inq_varndims(igrpivarid, &ndims));
#189    if(ndims > 0) {
#211    ichunksizes = (size_t *) emalloc((ndims + 1) * sizeof(size_t));
#215 for(dim = 1; dim < ndimsdim++) {
#223    ochunksizes = (size_t *) emalloc((ndims + 1) * sizeof(size_t));
#228    for(dim = 0; dim < ndimsdim++) {
#497 int ndims;
#498 NC_CHECK(nc_inq_varndims(igrpvarid, &ndims));
#499 if (ndims > 0) { /* no chunking for scalar variables */
#501     size_t *chunkp = (size_t *) emalloc(ndims * sizeof(size_t));
#502     int *dimids = (int *) emalloc(ndims * sizeof(int));
#510     for(idim = 0; idim < ndimsidim++) {
#577    int ndims;
#583    NC_CHECK(nc_inq_varndims(ogrpo_varid, &ndims));
#585    if (ndims > 0) { /* no chunking for scalar variables */
#587 int *dimids = (int *) emalloc(ndims * sizeof(int));
#603 for(odim = 0; odim < ndimsodim++) {
#628     size_t *chunkp = (size_t *) emalloc(ndims * sizeof(size_t));
#629     for(odim = 0; odim < ndimsodim++) {
#697    int ndims;
#707    NC_CHECK(nc_inq_ndims(igrp, &ndims));
#714    dimids = (int *) emalloc((ndims + 1) * sizeof(int));
#725    for (dgrp = 0; dgrp < ndimsdgrp++) {
#798    int ndims;
#807    NC_CHECK(nc_inq_varndims(igrpvarid, &ndims));
#808    idimids = (int *) emalloc((ndims + 1) * sizeof(int));
#823    odimids = (int *) emalloc((ndims + 1) * sizeof(int));
#824    for(i = 0; i < ndimsi++) {
#832    NC_CHECK(nc_def_var(ogrpnameo_typeidndimsodimids, &o_varid));
#934    int ndims;
#939    NC_CHECK(nc_inq_varndims(igrpvarid, &ndims));
#940    dimids = (int *) emalloc((ndims + 1) * sizeof(int));
#942    for(dim = 0; dim < ndimsdim++) {
#1137    int ndims;
#1138    NC_CHECK(nc_inq_ndims(ncid, &ndims));
#1146     ndims += count_dims(grpids[igrp]);
#1151    return ndims;
#1173 int ndims;
#1174 NC_CHECKnc_inq_varndims(ncidvarid, &ndims) );
#1175 if (ndims > 0) {
#1177     dimids = (int *) emalloc((ndims + 1) * sizeof(int));
#1272 int ndims;
#1280 NC_CHECK(nc_inq_varndims(ncidvarid, &ndims));
#1281 dimids = (int *) emalloc((1 + ndims) * sizeof(int));
#1282 start[ivar] = (size_t *) emalloc(ndims * sizeof(size_t));
#1283 count[ivar] = (size_t *) emalloc(ndims * sizeof(size_t));
#1287 for(ii = 1; ii < ndimsii++) { /* for rec size, don't include first record dimension */
#1349    size_t ndims;
#1446    ndims = count_dims(igrp);
#1447    NC_CHECK(dimmap_init(ndims));
ncd2dispatch.c#1835     int ndims = nclistlength(node->array.dimset0);
#1836     for(j=0;j<ndims;j++) {
#1839     ASSERT((j == (ndims - 1)));
#2233        nc_type xtype, int ndims, const int *dimidsp, int *varidp)
#2524NCD2_inq_dimids(int ncid, int* ndims, int* p3, int p4)
#2529    ret = nc_inq_dimids(getnc3id(drno), ndimsp3p4);
ncd2dispatch.h#130  nc_type xtype, int ndims, const int *dimidsp, int *varidp);
#183  NCD2_inq_dimids(int, int * ndims, int *, int);
ncdispatch.h#267int (*inq_dimids)(int, int* ndims, int*, int);
#366extern int NC_getshape(int ncid, int varid, int ndims, size_t* shape);
ncdump.c#987    if (varp->ndims > 0) { /* no chunking for scalar variables */
#998     chunkp = (size_t *) emalloc(sizeof(size_t) * (varp->ndims + 1) );
#1003     for(i = 0; i < varp->ndimsi++) {
#1004 printf("%lu%s", (unsigned long)chunkp[i], i+1 < varp->ndims ? ", " : " ;\n");
#1228    if (varp->ndims == 0)
#1230    for (id = 0; id < varp->ndimsid++) {
#1235    for (id = 0; id < varp->ndimsid++) {
#1238 strlcat(shapeid < varp->ndims-1 ? " " : "", shapelen);
#1497   int ndims; /* number of dimensions */
#1567   NC_CHECKnc_inq(ncid, &ndims, &nvars, &ngatts, &xdimid) );
#1569   dims = (ncdim_t *) emalloc((ndims + 1) * sizeof(ncdim_t));
#1570   if (ndims > 0) {
#1637   for (dimid = 0; dimid < ndimsdimid++) {
#1668      NC_CHECKnc_inq_varndims(ncidvarid, &var.ndims) );
#1670      var.dims = (int *) emalloc((var.ndims + 1) * sizeof(int));
#1684      if (var.ndims > 0)
#1686      for (id = 0; id < var.ndimsid++) {
#1728  printf ("%s", id < var.ndims-1 ? ", " : ")");
#1779  NC_CHECKnc_inq_varndims(ncidvarid, &var.ndims) );
#1781  var.dims = (int *) emalloc((var.ndims + 1) * sizeof(int));
#1795  vdims = (size_t *) emalloc((var.ndims + 1) * SIZEOF_SIZE_T);
#1797  for (id = 0; id < var.ndimsid++) {
#1908    int ndims; /* number of dimensions */
#1940    NC_CHECKnc_inq(ncid, &ndims, &nvars, &ngatts, &xdimid) );
#1942    dims = (ncdim_t *) emalloc((ndims + 1) * sizeof(ncdim_t));
#1943    for (dimid = 0; dimid < ndimsdimid++) {
#1960 NC_CHECKnc_inq_varndims(ncidvarid, &var.ndims) );
#1962 var.dims = (int *) emalloc((var.ndims + 1) * sizeof(int));
ncgen.h#144    int      ndims;
ncgen.h#16extern int ndims; /* number of dimensions declared for netcdf */
#37    int ndims;
ncgentab.c#1591      dims[ndims].size = int_val;
#1592      ndims++;
#1606        dims[ndims].size = (size_t) double_val;
#1607        ndims++;
#1616      rec_dim = ndims; /* the unlimited (record) dimension */
#1617      dims[ndims].size = NC_UNLIMITED;
#1618      ndims++;
#1631      (yyvsp[(1) - (1)])->dnum = ndims;
#1633      grow_darray(ndims,  /* must hold ndims+1 dims */
#1635      dims[ndims].name = (char *) emalloc(strlen((yyvsp[(1) - (1)])->name)+1);
#1636      (void) strcpy(dims[ndims].name, (yyvsp[(1) - (1)])->name);
#1638      dims[ndims].lname = decodify((yyvsp[(1) - (1)])->name);
#1686     dummyvar.ndims = 0;
#1719     vars[nvars].ndims = nvdims;
#1736                dimnum = ndims;
#1912        if (vars[varnum].ndims == 0) { /* scalar */
#1919        for(dimnum = 1; dimnum < vars[varnum].ndimsdimnum++)
#2095    ld = vars[varnum].ndims-1;
ncgeny.c#2212               dimset.ndims = count;
#2214     if(dimset.ndims > 0) {
#2286           dimset.ndims = count;
nciter.c#115     int ndims,  /* Number of dimensions */
#146     int ndims,  /* Number of dimensions */
#152    int incdim = ndims - 1;
#184    int ndims;     /* number of dimensions for variable */
#194    NC_CHECK(nc_inq_varndims(ncidvarid, &ndims));
#196    dimids = (int *) emalloc((ndims + 1) * sizeof(int));
#198    iterp->dimsizes = (size_t *) emalloc((ndims + 1) * sizeof(size_t));
#199    iterp->chunksizes = (size_t *) emalloc((ndims + 1) * sizeof(size_t));
#202    for(dim = 0; dim < ndimsdim++) {
#213 if(ndims > 0) {
#222    NC_CHECK(nc_blkio_init(bufsizevalue_sizendimschunkediterp));
ncpdispatch.c#534     int ndims, const int *dimidsp, int *varidp)
#545    status = ncmpi_def_var(nc->int_ncid,name,xtype,ndims,dimidsp,varidp);
#1324    int retval,d,ndims;
#1327    if((retval = NCP_inq(ncid, &ndims,  NULLNULLNULL)))
#1329    if(ndimsp) *ndimsp = ndims;
#1331        for (d = 0; d < ndimsd++)
#1378  int ndims, const int *dim_sizes)
netcdf.h#565nc_inq_dimids(int ncid, int *ndims, int *dimids, int include_parents);
#600  int ndims, const int *dim_sizes);
#1091nc_def_var(int ncid, const char *namenc_type xtype, int ndims,
#1900 int ndims, const int *dimidsp);
netcdf_f.h#47nc_inq_dimids_f(int ncid, int *ndims, int *fdimids, int parent);
#52    int ndims, int *dim_sizesp);
odom.c#20    ASSERT(dimset->ndims > 0);
#25    odom->rank = dimset->ndims;
#45    ASSERT(dimset->ndims > 0 && dimset->ndims >= stop);
putget.c#731 if(varp->ndims == 0)
#763 coordvarp->ndimsip );
#766 for(; ip < coord + varp->ndimsip++, up++)
#791 const size_t *const end = start + varp->ndims;
#794 if(varp->ndims == 0)
#823 if(varp->ndims == 0) /* 'scalar' variable */
#826 if(varp->ndims == 1)
#836 off_t lcoord = (off_t)coord[varp->ndims -1];
#840 const off_t *const end = varp->dsizes + varp->ndims;
#9526 const size_t *edp = edges + varp->ndims;
#9527 const size_t *shp = varp->shape + varp->ndims;
#9531 if(varp->ndims == 1 && ncp->recsize <= varp->len)
#9576 assert(shp >= varp->shape + varp->ndims -1
#9581   edp0 < edges + varp->ndims;
#10348    if(edges == NULL && varp->ndims > 0) {
#10353                          sizeof(size_t)*varp->ndims);
#10371    if(varp->ndims == 0) /* scalar variable */
#10380        if(varp->ndims == 1 && nc3->recsize <= varp->len)
#10401    ALLOC_ONSTACK(coord, size_t, varp->ndims);
#10402    ALLOC_ONSTACK(upper, size_t, varp->ndims);
#10406    (void) memcpy(coordstartvarp->ndims * sizeof(size_t));
#10409    set_upper(upperstartedges, &upper[varp->ndims]);
#10482    if(edges == NULL && varp->ndims > 0) {
#10487                          sizeof(size_t)*varp->ndims);
#10501    if(varp->ndims == 0) /* scalar variable */
#10512        if(varp->ndims == 1
#10534    ALLOC_ONSTACK(coord, size_t, varp->ndims);
#10535    ALLOC_ONSTACK(upper, size_t, varp->ndims);
#10539    (void) memcpy(coordstartvarp->ndims * sizeof(size_t));
#10542    set_upper(upperstartedges, &upper[varp->ndims]);
rec.c#27    int ndimsivnvars;
#38 if (ncvarinq(ncidiv, 0, 0, &ndimsdimids, 0) == -1)
#40 if (ndims > 0 && dimids[0] == recdimid) {
#61    int ndims;
#68    if (ncvarinq(ncidvid, 0, &type, &ndimsdimids, 0) == -1)
#70    if (ndims == 0 || dimids[0] != recdimid)
#73    for (id = 1; id < ndimsid++) {
#233    int ndims;
#237    if (ncvarinq(ncidvarid, 0, 0, &ndimsdimids, 0) == -1)
#239    if (ndims == 0 || sizes == 0)
#241    for (id = 0; id < ndimsid++)
semantics.c#658     if(tsym->typ.dimset.ndims > 0) {
#694 for(j=0;j<vsym->typ.dimset.ndims;j++) {
#1092    lastunlim = (nextunlim == dimset->ndims);
#1173 if(dimset->ndims == 0) continue; /* ignore scalars */
#1177 if(first == dimset->ndims) continue; /* no unlimited dims */
slabs.c#160 va[iv].dims = (int *) emalloc(sizeof(int) * va[iv].ndims);
#161 for (idim = 0; idim < va[iv].ndimsidim++)
#163 varid[iv] = ncvardef(cdfidva[iv].nameva[iv].typeva[iv].ndims,
t_nc.c#52 int ndims;
#161 int ndims;
#200 assert(nc_def_var(idvp->mnemvp->typevp->ndimsvp->dims,
#521 &(vdesc->ndims),
#536 for(jj = 0; jj < vdesc->ndimsjj++ )
test_put.c#238    int ndims;
#253     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#260     IF (ndims != var_rank[i])
#262     for (j = 0; j < ndimsj++) {
#322    int ndims;
#337     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#344     IF (ndims != var_rank[i])
#346     for (j = 0; j < ndimsj++) {
#406    int ndims;
#421     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#428     IF (ndims != var_rank[i])
#430     for (j = 0; j < ndimsj++) {
#490    int ndims;
#505     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#512     IF (ndims != var_rank[i])
#514     for (j = 0; j < ndimsj++) {
#574    int ndims;
#589     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#596     IF (ndims != var_rank[i])
#598     for (j = 0; j < ndimsj++) {
#658    int ndims;
#673     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#680     IF (ndims != var_rank[i])
#682     for (j = 0; j < ndimsj++) {
#742    int ndims;
#757     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#764     IF (ndims != var_rank[i])
#766     for (j = 0; j < ndimsj++) {
#826    int ndims;
#841     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#848     IF (ndims != var_rank[i])
#850     for (j = 0; j < ndimsj++) {
#910    int ndims;
#925     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#932     IF (ndims != var_rank[i])
#934     for (j = 0; j < ndimsj++) {
#994    int ndims;
#1009     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#1016     IF (ndims != var_rank[i])
#1018     for (j = 0; j < ndimsj++) {
#1078    int ndims;
#1093     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#1100     IF (ndims != var_rank[i])
#1102     for (j = 0; j < ndimsj++) {
#1162    int ndims;
#1177     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#1184     IF (ndims != var_rank[i])
#1186     for (j = 0; j < ndimsj++) {
test_read.c#207    int ndims; /* number of dimensions */
#222    err = nc_inq(ncid, &ndims, &nvars, &ngatts, &recdim);
#225    else IF (ndims != NDIMS)
#226 error("nc_inq: wrong number of dimensions returned, %d", ndims);
#246    ndims = NDIMS - 1;
#248    err = nc_inq(ncid, &ndims, &nvars, 0, 0);
#251    else IF (ndims != NDIMS)
#252 error("nc_inq subset: wrong number of dimensions returned, %d", ndims);
#281     err = nc_inq(ncid2, &ndims, &nvars, &ngatts, &recdim);
#284     else IF (ndims != ndims0)
#285 error("nc_inq in define mode: ndims wrong, %d", ndims);
#309     err = nc_inq(ncid2, &ndims, &nvars, &ngatts, &recdim);
#312     else IF (ndims != ndims0 + 1)
#313 error("nc_inq in define mode: ndims wrong, %d", ndims);
#323     err = nc_inq(ncid2, &ndims, &nvars, &ngatts, &recdim);
#326     else IF (ndims != ndims0 + 1)
#327 error("nc_inq in define mode: ndims wrong, %d", ndims);
#373    int ndims;
#376    err = nc_inq_ndims(BAD_ID, &ndims);
#382    err = nc_inq_ndims(ncid, &ndims);
#385    else IF (ndims != NDIMS)
#386 error("nc_inq_ndims: wrong number returned, %d", ndims);
#618    int ndims;
#626 err = nc_inq_var(BAD_IDiname, &datatype, &ndimsdimids, &natts);
#629 err = nc_inq_var(ncid,BAD_VARID,name,&datatype,&ndims,dimids,&natts);
#635 err = nc_inq_var(ncidiname, &datatype, &ndimsdimids, &natts);
#642 else IF (var_rank[i] != ndims)
#643     error("ndims expected: %d, got: %d",var_rank[i],ndims);
#644 else IF (!int_vec_eq(var_dimid[i],dimids,ndims))
#658 err = nc_inq_var(ncidi, 0, 0, &ndims, 0, 0);
#661        else IF (var_rank[i] != ndims)
#662            error("ndims expected: %d, got: %d",var_rank[i],ndims);
#666        else IF (!int_vec_eq(var_dimid[i],dimids,ndims))
#776    int ndims;
#782 err = nc_inq_varndims(BAD_IDi, &ndims);
#785 err = nc_inq_varndims(ncidBAD_VARID, &ndims);
#788 err = nc_inq_varndims(ncidi, &ndims);
#791        else IF (var_rank[i] != ndims)
#792            error("ndims expected: %d, got: %d",var_rank[i],ndims);
test_write.c#25    int ndims;                  /* number of dimensions */
#41 err = nc_inq(ncid, &ndims, &nvars, &ngatts, &recdim);
#44 else IF (ndims != 0)
#45     error("nc_inq: wrong number of dimensions returned, %d", ndims);
#356    int ndims;
#413    err = nc_inq (ncid, &ndims, &nvars, &ngattsNULL);
#416    IF (ndims != 0)
#621    int  ndims;
#641    err = nc_inq_var(ncidvaridname, &datatype, &ndimsdimids, &natts);
#648    IF (ndims != 0)
testcdf.h#27    int ndims;
#45    int ndims; /* number of dimensions declared for netcdf */
testnc3perf.c#49    int ndims;
#253 va[iv].dims = (int *) malloc(sizeof(int) * (unsigned)va[iv].ndims);
#254 for (idim = 0; idim < va[iv].ndimsidim++)
#256 varid[iv] = ncvardef(ncidva[iv].nameva[iv].typeva[iv].ndims,
tst_ar4.c#101   int ndimsdimid[NDIMS3];
#166   if (nc_inq_var(ncidvaridNULLNULL, &ndimsdimidNULL)) ERR;
#167   if (ndims != NDIMS3 || dimid[0] != TIME_DIMID ||
tst_ar4_3d.c#109   int ndimsdimid[NDIMS3];
#174   if (nc_inq_var(ncidvaridNULLNULL, &ndimsdimidNULL)) ERR;
#175   if (ndims != NDIMS3 || dimid[0] != TIME_DIMID ||
tst_ar4_4d.c#215   int ndimsdimid[NDIMS4];
#286   if (nc_inq_var(ncidvaridNULLNULL, &ndimsdimidNULL)) ERR;
#287   if (ndims != NDIMS4 || dimid[0] != TIME_DIMID ||
tst_bug324.c#66 int ndimsnvarsngattsxdimidnunlim;
#72 if ( nc_inq(ncid, &ndims, &nvars, &ngatts, &xdimid) ) ERR;
tst_chunks.c#33      int nvarsndimsngattsunlimdimid;
#59      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#60      if (nvars != 3 || ndims != 3 || ngatts != 0 || unlimdimid != -1) ERR;
#78      int nvarsndimsngattsunlimdimid;
#119      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#120      if (nvars != NUM_TYPE || ndims != NUM_DIM || ngatts != 0 || unlimdimid != 0) ERR;
#143      int nvarsndimsngattsunlimdimid;
#175      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#176      if (nvars != 3 || ndims != 3 || ngatts != 0 || unlimdimid != -1) ERR;
#262      int nvarsndimsngattsunlimdimid;
tst_chunks2.c#19calculate_waste(int ndims, size_t *dimlen, size_t *chunksize, float *waste)
#26   assert(waste && dimlen && chunksize && ndims);
#27   if (!(num_chunks = calloc(ndims, sizeof(size_t)))) ERR;
#33   for (d = 0; d < ndimsd++)
#44   for (d = 0; d < ndimsd++)
#58   for (d = 0; d < ndimsd++)
#92      int ndimsnvarsngattsunlimdimidnatts;
#109      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#110      if (nvars != NUM_VARS || ndims != NDIMS3 || ngatts != 0 || unlimdimid != -1) ERR;
#111      if (nc_inq_var(ncid, 0, name_in, &type_in, &ndimsdims_in, &natts)) ERR;
#112      if (strcmp(name_inVAR_NAME_JOE) || type_in != NC_FLOAT || ndims != NDIMS3 ||
#126      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#127      if (nvars != NUM_VARS || ndims != NDIMS3 || ngatts != 0 || unlimdimid != -1) ERR;
#128      if (nc_inq_var(ncid, 0, name_in, &type_in, &ndimsdims_in, &natts)) ERR;
#129      if (strcmp(name_inVAR_NAME_JOE) || type_in != NC_FLOAT || ndims != NDIMS3 ||
tst_compounds.c#32      int ndimsnvarsnattsunlimdimid;
#65      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#66      if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#72      if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#73      if (strcmp(nameSERVICE_RECORD) || ndims != 0 || natts != 0) ERR;
#105      int ndimsnvarsnattsunlimdimid;
#151      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#152      if (ndims != 1 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#158      if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#159      if (strcmp(nameSERVICE_RECORD) || ndims != 1 || natts != 0 || dimids[0] != 0) ERR;
#217      int ndimsnvarsnattsunlimdimid;
#231      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#232      if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#243      int ndimsnvarsnattsunlimdimid;
#285      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#286      if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
#319      int ndimsnatts;
#379  if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#380  if (strcmp(name, "starbase_13") || ndims != 1 || natts != 0 || dimids[0] != 0) ERR;
#416      int ndimsnatts;
#473      if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#474      if (strcmp(name, "dimension_data") || ndims != 1 || natts != 0 || dimids[0] != 0) ERR;
tst_compounds3.c#41      int ndimsnvarsnattsunlimdimid;
#91      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#92      if (ndims != 1 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#95      if (nc_inq_var(ncid, 0, name_in, &xtype, &ndimsdimids, &natts)) ERR;
#96      if (strcmp(name_inVAR_NAME) || ndims != 1 || natts != 0 || dimids[0] != 0) ERR;
tst_converts.c#84   int ndimsnatts;
#99   if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#100   if (strcmp(var_nameVAR1_NAME) || natts !=0 || ndims != 1 ||
tst_converts2.c#26   int ndimsnattsint_in;
#41      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsNULL, &natts)) ERR;
#42      if (strcmp(var_nameVAR_NAME) || natts !=0 || ndims != 0 ||
#87      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsNULL, &natts)) ERR;
#88      if (strcmp(var_nameVAR_NAME) || natts !=0 || ndims != 1 ||
#147      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsNULL, &natts)) ERR;
#148      if (strcmp(var_nameVAR_NAME) || natts !=0 || ndims != 1 ||
#195      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsNULL, &natts)) ERR;
#196      if (strcmp(var_nameVAR_NAME) || natts !=0 || ndims != 0 ||
tst_coords.c#48  int nvarsndimsngattsunlimdimidnvars_invarids_in[NVARS];
#73  if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#74  if (nvars != 2 || ndims != 2 || ngatts != 0 || unlimdimid != -1) ERR;
#87  if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#88  if (nvars != 2 || ndims != 2 || ngatts != 0 || unlimdimid != -1) ERR;
#479  int ndimsdimids_in[NDIMS4];
#497  if (nc_inq_dimids(ncid, &ndimsdimids_in, 0)) ERR;
#498  if (ndims != NDIMS4 || dimids_in[0] != 0 || dimids_in[1] != 1 ||
#615      int nvarsndimsngattsunlimdimid;
#638      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#639      if (nvars != 1 || ndims != 2 || ngatts != 0 || unlimdimid != 0) ERR;
#658      int nvarsndimsngattsunlimdimid;
#677      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#678      if (nvars != 1 || ndims != 2 || ngatts != 0 || unlimdimid != 0) ERR;
#703      int nvarsndimsngattsunlimdimid;
#718      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#719      if (nvars != 2 || ndims != 1 || ngatts != 0 || unlimdimid != 0) ERR;
#730      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#731      if (nvars != 2 || ndims != 1 || ngatts != 0 || unlimdimid != 0) ERR;
#752      int nvarsndimsngattsunlimdimid;
#779      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#780      if (nvars != NUM_VARS || ndims != NDIMS || ngatts != 0 || unlimdimid != 1) ERR;
tst_coords2.c#47      int nvarsndimsngattsunlimdimid;
#84      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#85      if (nvars != NVARS || ndims != NDIMS || ngatts != 0 || unlimdimid != -1) ERR;
#112      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#113      if (nvars != NVARS || ndims != NDIMS || ngatts != 0 || unlimdimid != -1) ERR;
tst_coords3.c#112   int nvarsndimsngattsunlimdimid;
#121   if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR_RET;
#122   if (nvars != NVARS || ndims != NDIMS || ngatts != 0 || unlimdimid != -1) ERR_RET;
tst_create_files.c#101       int ndimsnvarsnattsunlimdimid;
#122       if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#123       if (ndims != NUMDIMS || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#124       if (nc_inq_dimids(ncid, &ndimsdimids, 1)) ERR;
#125       if (ndims != 1 || dimids[0] != 0) ERR;
#128       if (nc_inq_var(ncid, 0, name_in, &xtype, &ndimsdimids, &natts)) ERR;
#129       if (strcmp(name_invar_name) || xtype != NC_FLOAT || ndims != 1 ||
#155       int ndims;
#174   for (ndims = 1; ndims <= MAX_DIMSndims++)
#176      sprintf(file_name, "tst_%s2_%dD.nc", type_name[t], ndims);
#178      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
#183      if (nc_def_var(ncidVAR_NAMEtypeid[t], ndimsdimids, &varid)) ERR;
#267       int ndims;
#286   for (ndims = 1; ndims <= MAX_DIMSndims++)
#288      sprintf(file_name, "tst_%s2_%dD.nc", type_name[t], ndims);
#290      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
#295      if (nc_def_var(ncidSIMPLE_VAR_NAMEtypeid[t], ndimsdimids, &varid)) ERR;
tst_dims.c#846      int nvarsndimsnattsunlimdimid;
#1053      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#1054      if (ndims != 4 || nvars != 5 || natts != 0) ERR;
tst_diskless3.c#108   int ndimsnvarsnattsunlimdimid;
#128   if((status=nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid))) ERRSTAT(status);
#129   if (ndims != 1 && nvars != 1 && natts != 0 && unlimdimid != 0) ERRSTAT(status);
tst_files.c#66      int ndimsnvarsnattsunlimdimid;
#89      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#90      if (ndims != 2 || nvars != 2 || natts != 0 || unlimdimid != -1) ERR;
#100      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#101      if (ndims != 2 || nvars != 3 || natts != 0 || unlimdimid != -1) ERR;
#102      if (nc_inq(ncid2, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#103      if (ndims != 2 || nvars != 3 || natts != 0 || unlimdimid != -1) ERR;
#104      if (nc_inq(ncid3, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#105      if (ndims != 2 || nvars != 3 || natts != 0 || unlimdimid != -1) ERR;
#116      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#117      if (ndims != 0 || nvars != 0 || natts != 0 || unlimdimid != -1) ERR;
#128      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#129      if (ndims != 1 || nvars != 0 || natts != 0 || unlimdimid != -1) ERR;
#144      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#145      if (ndims != 1 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#148      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#149      if (ndims != 1 || strcmp(var_nameVAR1_NAME) || var_type != NC_BYTE ||
#179      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#180      if (ndims != 2 || nvars != 2 || natts != 0 || unlimdimid != -1) ERR;
#195      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#196      if (ndims != 1 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#204      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#207      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#208      if (ndims != 1 || strcmp(var_nameVAR1_NAME) || var_type != NC_INT ||
#216      int ndimsnvarsnattsunlimdimid;
#235      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#236      if (ndims != 2 || nvars != 2 || natts != 2 || unlimdimid != -1) ERR;
#245      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#246      if (ndims != 2 || strcmp(var_nameVAR1_NAME) || var_type != NC_INT ||
#248      if (nc_inq_var(ncid, 1, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#249      if (ndims != 2 || strcmp(var_nameVAR2_NAME) || var_type != NC_UINT ||
#384   int ndimsnvarsnattsunlimdimid;
#435   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#436   if (ndims != REDEF_NDIMS || nvars != 2 || natts != 2 || unlimdimid != -1) ERR;
#437   if (nc_inq_var(ncid, 0, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#438   if (strcmp(var_nameREDEF_VAR1_NAME) || xtype_in != NC_INT || ndims != REDEF_NDIMS ||
#440   if (nc_inq_var(ncid, 1, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#441   if (strcmp(var_nameREDEF_VAR2_NAME) || xtype_in != NC_BYTE || ndims != REDEF_NDIMS ||
#451   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#452   if (ndims != REDEF_NDIMS || nvars != 2 || natts != 2 || unlimdimid != -1) ERR;
#453   if (nc_inq_var(ncid, 0, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#454   if (strcmp(var_nameREDEF_VAR1_NAME) || xtype_in != NC_INT || ndims != REDEF_NDIMS ||
#456   if (nc_inq_var(ncid, 1, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#457   if (strcmp(var_nameREDEF_VAR2_NAME) || xtype_in != NC_BYTE || ndims != REDEF_NDIMS ||
#481   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#482   if (ndims != REDEF_NDIMS || nvars != 2 || natts != 2 || unlimdimid != -1) ERR;
#483   if (nc_inq_var(ncid, 0, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#484   if (strcmp(var_nameREDEF_VAR1_NAME) || xtype_in != NC_INT || ndims != REDEF_NDIMS ||
#486   if (nc_inq_var(ncid, 1, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#487   if (strcmp(var_nameREDEF_VAR2_NAME) || xtype_in != NC_BYTE || ndims != REDEF_NDIMS ||
#496   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#497   if (ndims != REDEF_NDIMS || nvars != 2 || natts != 2 || unlimdimid != -1) ERR;
#509   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#510   if (ndims != REDEF_NDIMS || nvars != 3 || natts != 3 || unlimdimid != -1) ERR;
#511   if (nc_inq_var(ncid, 0, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#512   if (strcmp(var_nameREDEF_VAR1_NAME) || xtype_in != NC_INT || ndims != REDEF_NDIMS ||
#514   if (nc_inq_var(ncid, 1, var_name, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#515   if (strcmp(var_nameREDEF_VAR2_NAME) || xtype_in != NC_BYTE || ndims != REDEF_NDIMS ||
#517   if (nc_inq_var(ncid, 2, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#518   if (ndims != REDEF_NDIMS || strcmp(var_nameREDEF_VAR3_NAME) || var_type != NC_BYTE ||
#529   if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#530   if (ndims != REDEF_NDIMS || strcmp(var_nameREDEF_VAR1_NAME) || var_type != NC_INT ||
#532   if (nc_inq_var(ncid, 1, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#533   if (ndims != REDEF_NDIMS || strcmp(var_nameREDEF_VAR2_NAME) || var_type != NC_BYTE ||
#535   if (nc_inq_var(ncid, 2, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#536   if (ndims != REDEF_NDIMS || strcmp(var_nameREDEF_VAR3_NAME) || var_type != NC_BYTE ||
tst_files2.c#89create_sample_file(char *file_name, int ndims, int *dim_len,
#100   if (ndims != MAX_DIMS && ndims != MAX_DIMS - 1) ERR_RET;
#111   slab_nelems = dim_len[ndims - 1] * dim_len[ndims - 2];
#117   for (d = 0; d < ndimsd++)
#128      if (nc_def_var(ncidvarnameNC_FLOATndimsdimids,
#136   for (d = 0; d < ndimsd++)
#138      if (d < ndims - 2)
#150      if (ndims == MAX_DIMS)
#191      int ndims[NUM_TRIES];
#214  ndims[t] = 4;
#215  for (d = 0; d < ndims[t]; d++)
#220  if (create_sample_file(file_name[t], ndims[t], dim_len[t], num_vars[t],
#273  if (ndims[t] == MAX_DIMS)
#283     if (ndims[t] == MAX_DIMS)
tst_fill_attr_vanish.c#37  int ndimsdimids_in[RANK_P];
tst_fillbug.c#83 int formatndimsnvarsngattsxdimidndims_grpdimids_grp[3],
#95 if ( nc_inq(ncid, &ndims, &nvars, &ngatts, &xdimid) ) ERR;
#122 if ( nc_inq_varndims(ncidvarid, &ndims) ) ERR;
#123 if (ndims > 0) {
#130     for (dim = 0; dim < ndims && is_recvar == 0; dim++) {
tst_fillbug.c#25   int ndimsdimids_in[RANK_P];
#54   if (nc_inq_var(ncid, 1, NULLNULL, &ndimsdimids_inNULL)) ERR;
#55   if (ndims != 3 || dimids_in[0] != 0 || dimids_in[1] != 2 || dimids_in[2] != 1) ERR;
#82   if (nc_inq_var(ncid, 1, NULLNULL, &ndimsdimids_inNULL)) ERR;
#83   if (ndims != 3 || dimids_in[0] != 0 || dimids_in[1] != 2 || dimids_in[2] != 1) ERR;
tst_h_atts.c#47   int ndims;
#203      if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#204      if (ndims != 0) ERR;
#254      if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#255      if (ndims != 0) ERR;
#279      if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#280      if (ndims != 0) ERR;
tst_h_dimscales.c#49   int ndimsd;
#76     if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#77     if (ndims > MAX_DIMSERR;
#96        for (d = 0; d < ndimsd++)
tst_h_dimscales2.c#265      int dndims;
#291        if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#292        if (ndims > NDIMS2ERR;
#317   for (d = 0; d < ndimsd++)
#369      int dndims;
#471        if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#496   for (d = 0; d < ndimsd++)
#672      int dndims;
#772        if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#797   for (d = 0; d < ndimsd++)
#857      int dndims;
#957        if ((ndims = H5Sget_simple_extent_ndims(spaceid)) < 0) ERR;
#982   for (d = 0; d < ndimsd++)
tst_h_scalar.c#270        int ndims;
#284        if (nc_inq_varndims(ncidvarid, &ndims)) ERR;
#285        if (ndims != 0) ERR;
#298        if (nc_inq_varndims(ncidvarid, &ndims)) ERR;
#299        if (ndims != 0) ERR;
#313        if (nc_inq_varndims(ncidvarid, &ndims)) ERR;
#314        if (ndims != 0) ERR;
tst_h_strbug.c#95 int ncidvaridndims;
#102 if (nc_inq_varndims(ncidvarid, &ndims )) ERR;
#103 if (ndims != 0) ERR;
#113     int ncidvaridndims;
#120     if (nc_inq_varndims(ncidvarid, &ndims )) ERR;
#121     if (ndims != 0) ERR;
#131 int ncidvaridndims;
#148 int ncidvaridndims;
#167     int ncidvaridndims;
#176     if (nc_inq_varndims(ncidvarid, &ndims )) ERR;
#177     if (ndims != RANKERR;
#178 if (!(dimids = malloc(ndims * sizeof(int)))) ERR;
tst_interops5.c#158  int ncidgrpidnvarsngattsndimsunlimdimidngrps;
#165  if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#166  if (ndims != 2 || nvars != 0 || ngatts != 0 || unlimdimid != -1) ERR;
#169  if (nc_inq(grpid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#170  if (ndims != 0 || nvars != 1 || ngatts != 0 || unlimdimid != -1) ERR;
tst_knmi.c#86   int ndimsdimid[NDIMS3];
tst_nofill.c#418    int ndims, *dimidsdim;
#423    if (nc_inq_varndims(ncid1varid, &ndims)) ERR;
#424    dimids = malloc((ndims + 1) * sizeof(int));
#428    for(dim = 0; dim < ndimsdim++) {
tst_opaques.c#45      int  nvarsnattsndimsunlimdimid;
#61      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#62      if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#63      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsNULL, &natts)) ERR;
#64      if (ndims != 0 || strcmp(var_nameVAR_NAME) || natts != 0) ERR;
#79      int  nvarsnattsndimsunlimdimiddimids_var[1];
#96      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#97      if (ndims != 1 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#98      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#99      if (ndims != 1 || strcmp(var_nameVAR_NAME) ||
#181      int  nvarsnattsndimsunlimdimid;
#200      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#201      if (ndims != 0 || nvars != 0 || natts != 0 || unlimdimid != -1) ERR;
tst_small.c#94   int ndimsnvarsnattsunlimdimid;
#116  if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#117  if (ndims != 0 && nvars != 0 && natts != 1 && unlimdimid != -1) ERR;
#146   int ndimsnvarsnattsunlimdimid;
#179   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#180   if (ndims != 2 && nvars != 1 && natts != 0 && unlimdimid != 0) ERR;
#194   int ndimsnvarsnattsunlimdimid;
#224   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#225   if (ndims != 2 && nvars != 1 && natts != 0 && unlimdimid != -1) ERR;
#239   int ndimsnvarsnattsunlimdimid;
#261   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#262   if (ndims != 1 && nvars != 1 && natts != 0 && unlimdimid != 0) ERR;
#462   int ndimsnvarsnattsunlimdimid;
#485   if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#486   if (ndims != 1 && nvars != 1 && natts != 0 && unlimdimid != 0) ERR;
tst_strings.c#30      int ndimsnvarsnattsunlimdimid;
#38      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#39      if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
#46      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#47      if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
#61      int ndimsnvarsnattsunlimdimid;
#77      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#78      if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
#85      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#86      if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
#254      int ndimsnvarsnattsunlimdimid;
#440      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#441      if (ndims != NDIMS || nvars != 2 || natts != 0 || unlimdimid != -1) ERR;
#459      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#460      if (ndims != NDIMS || nvars != 2 || natts != 0 || unlimdimid != -1) ERR;
tst_strings2.c#25      int ndimsnvarsnattsunlimdimid;
#35      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#36      if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
#43      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#44      if (ndims != 0 || nvars != 0 || natts != 1 || unlimdimid != -1) ERR;
tst_sync.c#23      int ndimsnvarsnattsunlimdimiddimid_in;
#41      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#42      if (ndims != 1 || nvars != 3 || natts != 0 || unlimdimid != -1) ERR;
#43      if (nc_inq_var(ncid, 2, name_in, &xtype_in, &ndims, &dimid_in, &natts)) ERR;
#44      if (strcmp(name_inDIM_NAME) || xtype_in != NC_FLOAT || ndims != 1 ||
tst_varms.c#40   int nvarsnattsndimsunlimdimid;
#182      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#183      if (ndims != 3 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#253      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#254      if (ndims != 2 || nvars != 2 || natts != 0 || unlimdimid != -1) ERR;
tst_vars.c#795      int ndimsnvarsnattsunlimdimid;
#809      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#810      if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
#815      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
#818   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#829      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#830      if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
#835      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
#838   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#858      int ndimsnvarsnattsunlimdimid;
#885      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#886      if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
#893  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
#896      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#908      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#909      if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
#916  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
#919      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#942      int ndimsnvarsnattsunlimdimid;
#969      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#970      if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
#978  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
#981      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#993      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#994      if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
#1002  if (nc_inq_var(ncidiname_in, &xtype_in, &ndims,
#1005      ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#1027      int varidndimsnatts;
#1041      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
#1044   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#1069      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
#1072   ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
tst_vars2.c#589      int ndimsnvarsnattsunlimdimid;
#609      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#610      if (ndims != NDIMS4 || nvars != 1 || natts != 0 ||
#615      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
#618          ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#626      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#627      if (ndims != NDIMS4 || nvars != 1 || natts != 0 ||
#632      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
#635          ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
#658      int ndimsnvarsnattsunlimdimid;
#682      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#683      if (ndims != NDIMS5 || nvars != 1 || natts != 0 ||
#688      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#689      if (strcmp(name_inVAR_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
#709      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#710      if (ndims != NDIMS5 || nvars != 1 || natts != 0 ||
#715      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#716      if (strcmp(name_inVAR_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
#739      int ndimsnvarsnattsunlimdimid;
#759      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#760      if (ndims != NDIMS6 || nvars != 1 || natts != 0 ||
#765      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#766      if (strcmp(name_inVAR_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
#780      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#781      if (ndims != NDIMS6 || nvars != 1 || natts != 0 ||
#786      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#787      if (strcmp(name_inVAR_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 ||
#805      int ndimsnvarsnattsunlimdimid;
#817      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#818      if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#821      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsNULL, &natts)) ERR;
#822      if (strcmp(name_inVAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR;
#829      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#830      if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#833      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsNULL, &natts)) ERR;
#834      if (strcmp(name_inVAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR;
#941      int ndimsnvarsnattsunlimdimid;
#960      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#961      if (ndims != NDIMS17 || nvars != 1 || natts != 0 ||
#966      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#967      if (strcmp(name_inVAR_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 ||
#979      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#980      if (ndims != NDIMS17 || nvars != 1 || natts != 0 ||
#985      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#986      if (strcmp(name_inVAR_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 ||
tst_vars3.c#77      int nvarsndimsngattsunlimdimiddimids_in[2], natts;
#109      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#110      if (nvars != 2 || ndims != 2 || ngatts != 0 || unlimdimid != -1) ERR;
#113      if (nc_inq_dimids(ncid, &ndimsdimids_in, 1)) ERR;
#114      if (ndims != 2 || dimids_in[0] != x_dimid || dimids_in[1] != y_dimidERR;
#121      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#122      if (strcmp(name_inV1_NAME) || xtype_in != NC_DOUBLE || ndims != 1 ||
#124      if (nc_inq_var(ncid, 1, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#125      if (strcmp(name_inD1_NAME) || xtype_in != NC_DOUBLE || ndims != 1 ||
#133      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#134      if (nvars != 2 || ndims != 2 || ngatts != 0 || unlimdimid != -1) ERR;
#137      if (nc_inq_dimids(ncid, &ndimsdimids_in, 1)) ERR;
#138      if (ndims != 2 || dimids_in[0] != x_dimid || dimids_in[1] != y_dimidERR;
#145      if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#146      if (strcmp(name_inV1_NAME) || xtype_in != NC_DOUBLE || ndims != 1 ||
#148      if (nc_inq_var(ncid, 1, name_in, &xtype_in, &ndimsdimids_in, &natts)) ERR;
#149      if (strcmp(name_inD1_NAME) || xtype_in != NC_DOUBLE || ndims != 1 ||
#165      int nvarsndimsngattsunlimdimid;
#186      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#187      if (nvars != 1 || ndims != 0 || ngatts != 0 || unlimdimid != -1) ERR;
#205      int nvarsndimsngattsunlimdimid;
#221      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#222      if (nvars != 1 || ndims != 2 || ngatts != 0 || unlimdimid != -1) ERR;
#236      int ndimsdimids_in[RANK_P];
#263      if (nc_inq_var(ncid, 1, NULLNULL, &ndimsdimids_inNULL)) ERR;
#264      if (ndims != 3 || dimids_in[0] != 0 || dimids_in[1] != 2 || dimids_in[2] != 1) ERR;
#277      if (nc_inq_var(ncid, 1, NULLNULL, &ndimsdimids_inNULL)) ERR;
#278      if (ndims != 3 || dimids_in[0] != 0 || dimids_in[1] != 2 || dimids_in[2] != 1) ERR;
#292      int nvarsndimsngattsunlimdimid;
#310      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#311      if (nvars != NUM_VARS || ndims != 1 || ngatts != 0 || unlimdimid != 0) ERR;
#364      int ndims = 1;
#370      if ( nc_def_var(ncidSCALAR_VARNAMENC_FLOATndims, &dimid, &varid) ) ERR;
tst_vars4.c#29      int ndimsnvarsngattsunlimdimidnatts;
#38      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#39      if (nvars != NUM_VARS || ndims != NDIMS2 || ngatts != 0 || unlimdimid != -1) ERR;
#40      if (nc_inq_var(ncid, 0, name_in, &type_in, &ndimsdims_in, &natts)) ERR;
#41      if (strcmp(name_inVAR_NAME) || type_in != NC_FLOAT || ndims != NDIMS2 ||
#52      if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
#53      if (nvars != NUM_VARS || ndims != NDIMS2 || ngatts != 0 || unlimdimid != -1) ERR;
#54      if (nc_inq_var(ncid, 0, name_in, &type_in, &ndimsdims_in, &natts)) ERR;
#55      if (strcmp(name_inVAR_NAME) || type_in != NC_FLOAT || ndims != NDIMS2 ||
tst_vl.c#108      int nvarsnattsndimsunlimdimiddimids_var[1];
#135      if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
#136      if (ndims != 1 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
#137      if (nc_inq_var(ncid, 0, var_name, &var_type, &ndimsdimids_var, &natts)) ERR;
#138      if (ndims != 1 || strcmp(var_nameVAR_NAME) ||
util.c#216    for(i=0;i<dimset->ndims;i++) {
#227   return (dimset->ndims > 0 && dimset->dimsyms[0]->dim.declsize == NC_UNLIMITED);
#238    for(i=0;i<dimset->ndims;i++) {
#250    for(i=0;i<dimset->ndims;i++) {
#647    for(;start<dimset->ndims;start++) {
#651    return dimset->ndims;
#663    for(i=dimset->ndims-1;i>=0;i--) {
#667    return dimset->ndims;
#677    for(count=0,i=dimset->ndims-1;i>=0;i--) {
util.c#931    int ndims;
#941 err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#948 IF (ndims != var_rank[i])
#950 for (j = 0; j < ndimsj++) {
util.h#69#define rankfor(dimset) ((dimset)->ndims)
utils.c#183    int ndims;
#187    NC_CHECKnc_inq_varndims(ncidvarid, &ndims) );
#189    if (ndims > 0) {
#193 dimids = (int *) emalloc((ndims + 1) * sizeof(int));
#198 for (dim = 0; dim < ndims && is_recvar == 0; dim++) {
#210    if (ndims > 0) {
#212 dimids = (int *) emalloc((ndims + 1) * sizeof(int));
v1hpg.c#908     sz += ncx_len_int64(varp->ndims); /* dimids */
#912     sz += ncx_len_int(varp->ndims); /* dimids */
#933 status = v1h_put_size_t(psp, &varp->ndims);
#938 status = check_v1hs(pspncx_len_int64(varp->ndims));
#942 varp->ndimsvarp->dimids);
#947       status = check_v1hs(pspncx_len_int(varp->ndims));
#951 varp->ndimsvarp->dimids);
#985 size_t ndims;
#992 status = v1h_get_size_t(gsp, &ndims);
#996 varp = new_x_NC_var(strpndims);
#1004 status = check_v1hs(gspncx_len_int64(ndims));
#1008 ndimsvarp->dimids);
#1013     status = check_v1hs(gspncx_len_int(ndims));
#1017 ndimsvarp->dimids);
var.c#65 size_t ndims)
#68 const size_t o1 = M_RNDUP(ndims * sizeof(int));
#69 const size_t o2 = M_RNDUP(ndims * sizeof(size_t));
#73  o1 + o2 + ndims * sizeof(off_t);
#75 const size_t o3 = ndims * sizeof(off_t);
#84 varp->ndims = ndims;
#86 if(ndims != 0)
#123 size_t ndims, const int *dimids)
#136 varp = new_x_NC_var(strpndims);
#145 if( ndims != 0 && dimids != NULL)
#146   (void) memcpy(varp->dimidsdimidsndims * sizeof(int));
#159  rvarp->ndimsrvarp->dimids);
#171  rvarp->ndims * sizeof(size_t));
#173  rvarp->ndims * sizeof(size_t));
#433 if(varp->ndims == 0 || varp->dimids == NULL)
#443          ; ip < &varp->dimids[varp->ndims]; ip++, op++)
#458 for(shp = varp->shape + varp->ndims -1,
#459 dsp = varp->dsizes + varp->ndims -1;
#502 arrayp("\tshape", varp->ndimsvarp->shape);
#503 arrayp("\tdsizes", varp->ndimsvarp->dsizes);
#522    for(ii = IS_RECVAR(varp) ? 1 : 0; ii < varp->ndimsii++) {
#571  int ndims, const int *dimids, int *varidp)
#598 if((unsigned long) ndims > X_INT_MAX) /* Backward compat */
#614 varp = new_NC_var(nametypendimsdimids);
#697 *ndimsp = (int) varp->ndims;
#701 for(ii = 0; ii < varp->ndimsii++)
vardata.c#248    int vrank = vp->ndims;
#291    int vrank = vp->ndims;
#391     int ndims, /* Number of dimensions */
#399    for (id = ndims-1; id > 0; id--) {
#432    int rank = vp->ndims;
#537    int vrank = vp->ndims;
#728    int vrank = vp->ndims;
#783   if (!upcorner(vdims,vp->ndims,cor,add))
vardef.c#142    if (ncvardef(cdfidva[0].nameva[0].typeva[0].ndimsva[0].dims)
#169 va[iv].dims = (int *) emalloc(sizeof(int) * va[iv].ndims);
#170 for (id = 0; id < va[iv].ndimsid++)
#173   va[iv].ndimsva[iv].dims)) == -1) {
#187       &tmp.ndimstmp.dims, &tmp.natts) == -1) {
#194     tmp.ndims != va[iv].ndims ||
#202 for (id = 0; id < va[iv].ndimsid++) {
#214   va[0].ndimsva[0].dims) != -1) {
#219    if (ncvardef(cdfid, "badtype", BAD_TYPEva[0].ndimsva[0].dims) != -1) {
#229    va[0].dims[va[0].ndims-1] = -1;
#230    if (ncvardef(cdfid, "baddims", va[0].typeva[0].ndimsva[0].dims)
varget.c#54    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#60 for (id = 0; id < test.vars[iv].ndimsid++) {
#67 id = test.vars[iv].ndims - 1;
#84 long mqv = test.vars[iv].ndims -1 ;
vargetg.c#53    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#60 for (id = 0; id < test.vars[iv].ndimsid++) {
#73 id = test.vars[iv].ndims - 1;
varput.c#60    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#64 for (id = 0; id < test.vars[iv].ndimsid++) {
#72 id = test.vars[iv].ndims - 1;
#88 long mqv = test.vars[iv].ndims -1 ;
varputg.c#57    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#62 for (id = 0; id < test.vars[iv].ndimsid++) {
#76 id = test.vars[iv].ndims - 1;
vartests.c#51    xx.dims = (int *) emalloc(sizeof(int) * xx.ndims);
#52    for (id = 0; id < xx.ndimsid++)
#55    xx.namexx.typexx.ndimsxx.dims)) == -1) {
#128       &var.ndimsvar.dims, &var.natts) == -1) {
#144 if (var.ndims != test.vars[varid].ndims) {
#146   pnamevar.ndimstest.vars[varid].ndimsvarid);
#150     for (idim = 0; idim < var.ndimsidim++)
#166       &var.ndimsvar.dims, &var.natts) == -1) {
#181 if (var.ndims != test.vars[varid].ndims) {
#183   pnamevar.ndimstest.vars[varid].ndimsvarid);
#187     for (idim = 0; idim < var.ndimsidim++)
#198       &var.ndimsvar.dims, &var.natts) != -1 ||
#200       &var.ndimsvar.dims, &var.natts) != -1) {
#216       &var.ndimsvar.dims, &var.natts) != -1) {
#270 for (id = 0; id < test.vars[iv].ndimsid++) { /* set corners */
#403    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#408 for (id = 0; id < test.vars[iv].ndimsid++)
#411 elm.coords[test.vars[iv].ndims/2] = -1;
#416 elm.coords[test.vars[iv].ndims/2] =
#417   test.dims[test.vars[iv].dims[test.vars[iv].ndims/2]].size;
#491    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#496 for (id = 0; id < test.vars[iv].ndimsid++)
#499 elm.coords[test.vars[iv].ndims/2] = -1;
#504 elm.coords[test.vars[iv].ndims/2] =
#505   test.dims[test.vars[iv].dims[test.vars[iv].ndims/2]].size;
#587    yy.dims = (int *) emalloc(sizeof(int) * yy.ndims);
#588    for (id = 0; id < yy.ndimsid++)
#591    yy.nameyy.typeyy.ndimsyy.dims)) == -1) {
#596    zz.dims = (int *) emalloc(sizeof(int) * zz.ndims);
#597    for (id = 0; id < zz.ndimsid++)
#599    if (ncvardef(cdfidzz.namezz.typezz.ndimszz.dims) == -1) {
#617   &var.type, &var.ndimsvar.dims, &var.natts) == -1) {
vputget.c#55 for (id = 0; id < test.vars[iv].ndimsid++) { /* set cubes */
#93     for (id = 0 ; id < test.vars[iv].ndimsid++)
#95     (id < test.vars[iv].ndims-1) ? ", " : "");
#98     for (id = 0 ; id < test.vars[iv].ndimsid++)
#100     (id < test.vars[iv].ndims-1) ? ", " : "");
vputgetg.c#72 for (id = test.vars[iv].ndims-1; id >= 0; --id) { /* set cubes */
#79     hc[0].imap[id] = id == test.vars[iv].ndims-1
#90     hc[1].imap[id] = id == test.vars[iv].ndims-1
#103     hc[2].imap[id] = id == test.vars[iv].ndims-1
#129 for (id = 0 ; id < test.vars[iv].ndimsid++)
#131 (id < test.vars[iv].ndims-1) ? ", " : "");
#134 for (id = 0 ; id < test.vars[iv].ndimsid++)
#136 (id < test.vars[iv].ndims-1) ? ", " : "");
#139 for (id = 0 ; id < test.vars[iv].ndimsid++)
#141 (id < test.vars[iv].ndims-1) ? ", " : "");
#144 for (id = 0 ; id < test.vars[iv].ndimsid++)
#146 (id < test.vars[iv].ndims-1) ? ", " : "");
#151 for (id = 0; id < test.vars[iv].ndimsid++)


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