bm_file.c#83   int sd;
#92      for (d = 0, *slice_len = 1, total_len = 1; d < vo->ndimsd++)
#94  start[d] = vo->start[d];
#95  count[d] = vo->count[d];
#96  (*slice_len) *= count[d];
#97  total_len *= dimlen[d];
#107      for (d = 0; d < vo->ndimsd++)
#108  total[d] = 0;
#114  for (d = 0; d < vo->ndimsd++)
#116     total[d] += count[d];
#117     if (total[d] >= dimlen[d])
#120  if (d != vo->ndims)
#149      for (d = 1; d < ndimsd++)
#151  start[d] = 0;
#152  count[d] = dimlen[d];
#153  *slice_len *= dimlen[d];
#205   void *d = NULL, *d2 = NULL;
#223      if(!(d = malloc(typelen * len)))
#230      if ((ret = nc_get_att(ncid1varidnamed)))
#236      if (memcmp(dd2typelen * len))
#242   if (d)
#243      free(d);
#265   int avd;
#319   for (d = 0; d < ndimsd++)
#321      if ((ret = nc_inq_dim(ncid1dname, &len)))
#323      if ((ret = nc_inq_dim(ncid2dname2, &len2)))
#346      for (d = 0; d < ndimsd++)
#347  if (dimids[d] != dimids2[d])
#374      for (d=0; d<ndimsd++)
#375  if ((ret = nc_inq_dimlen(ncid1dimids[d], &dimlen[d])))
#474   int avd;
#540      for (d = 0; d < ndimsd++)
#542  if ((ret = nc_inq_dim(ncid_indname, &len)))
#552   (d == unlimdimid) ? NC_UNLIMITED : len,
#641      int d;
#669      for (d = 0; d < ndimsd++)
#670  if ((ret = nc_inq_dimlen(ncid_indimids[d], &dimlen[d])))
#765      for (d = 0, var_num_bytes = type_sized < ndimsd++)
#766  var_num_bytes *= dimlen[d];
#843   int vd;
#1051     for (d = 0; d < vo[v].ndimsd++)
#1053       dvo[v].start[d], dvo[v].count[d], dvo[v].inc[d]);
cdf.c#219    unsigned int i,j,d;
#258         else for(d=0;d<nclistlength(testnode->array.dimsetall);d++) {
#259     CDFnodevdim = (CDFnode*)nclistget(var->array.dimsetall,d);
#260     CDFnodetdim = (CDFnode*)nclistget(testnode->array.dimsetall,d);
data.c#738  NCConstant d;
#739  d.nctype = NC_COMPOUND;
#740  d.lineno = (dl->length > 0?dl->data[0].lineno:0);
#741  d.value.compoundv = dl;
#742  d.filled = 0;
#743  return d;
dcopy.c#260   int ad;
#353   for (d=0; d<ndimsd++)
#355      if ((retval = nc_inq_dimlen(ncid_indimids_in[d], &dimlen[d])))
#358      LOG((4, "nc_copy_var: there are %d data", dimlen[d]));
#366   for (d=0; d<real_ndimsd++)
#368      start[d] = 0;
#369      count[d] = d ? dimlen[d] : 1;
#370      if (dreclen *= dimlen[d];
ddispatch.c#166void NC_set_dispatch_override(NC_Dispatchd)
#168    NC_dispatch_override = d;
dumplib.c#145 char *d = dst;
#151 while (n-- != 0 && *d != '\0')
#152 d++;
#153 dlen = d - dst;
#160 *d++ = *s;
#165 *d = '\0';
genlib.c#1869 char *d = dst;
#1875 while (n-- != 0 && *d != '\0')
#1876 d++;
#1877 dlen = d - dst;
#1884 *d++ = *s;
#1889 *d = '\0';
lookup3.c#821  uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, klm=0, z;
#851      d[0] = hashlittle(bhlenm);
#855       e[l] &= (c[l]^d[l]);
#856       f[l] &= ~(c[l]^d[l]);
#859       x[l] &= d[l];
#860       y[l] &= ~d[l];
nc3dispatch.c#307    int retval,d,ndims;
#314        for (d = 0; d < ndimsd++)
#315            dimids[d] = d;
nc4file.c#692   int d;
#715   for (d = 0; d < var->ndimsd++) {
#717     nc4_find_dim(grpvar->dimids[d], &var->dim[d], NULL);
#1294                  int d;
#1304                  for (d = 0; d < ndimsd++)
#1305                     dim_size[d] = dims[d];
#1512   int nattsad;
#1617      for (d = 0; d < var->ndimsd++)
#1618         var->chunksizes[d] = chunksize[d];
#1752         for (d = 0; d < var->ndimsd++)
#1754            if (H5DSiterate_scales(var->hdf_datasetiddNULLdimscale_visitor,
#1755                                   &(var->dimscale_hdf5_objids[d])) < 0)
#1757            var->dimscale_attached[d] = NC_TRUE;
#2514   int vda;
#2678      for (d = 0; d < var->ndimsd++)
#2684  if ((dimid = SDgetdimid(var->sdsidd)) == FAIL) {
#2722  var->dimids[d] = dim->dimid;
#2723  var->dim[d] = dim;
#2786         for (d = 0; d < var->ndimsd++) {
#2787     var->chunksizes[d] = chunkdefs.chunk_lengths[d];
nc4grp.c#453   int dnum = 0;
#470  for (d = 0; d < numd++)
#471     dimids[d] = d;
nc4hdf.c#72  int d;
#85    for (d = 0; d < var->ndimsd++)
#86      if (var->dimids[d] == dimid && !var->dimscale)
#89               __func__var->dimids[d], var->name));
#92              if (H5DSattach_scale(var->hdf_datasetiddimscaleidd) < 0)
#94              var->dimscale_attached[d] = NC_TRUE;
#112  int d;
#125    for (d = 0; d < var->ndimsd++)
#126      if (var->dimids[d] == dimid && !var->dimscale)
#129               __func__var->dimids[d], var->name));
#131            if (var->dimscale_attached && var->dimscale_attached[d])
#133                if (H5DSdetach_scale(var->hdf_datasetiddimscaleidd) < 0)
#135                var->dimscale_attached[d] = NC_FALSE;
#1526  int d;
#1630      for (d = 0; d < var->ndimsd++) {
#1631 dim = var->dim[d];
#1632 assert(dim && dim->dimid == var->dimids[d]);
#1653      for (d = 0; d < var->ndimsd++)
#1655          dim = var->dim[d];
#1656   assert(dim && dim->dimid == var->dimids[d]);
#1657          dimsize[d] = dim->unlimited ? NC_HDF5_UNLIMITED_DIMSIZE : dim->len;
#1658          maxdimsize[d] = dim->unlimited ? H5S_UNLIMITED : (hsize_t)dim->len;
#1660            if (var->chunksizes[d])
#1661              chunksize[d] = var->chunksizes[d];
#1672                  chunksize[d] = 1;
#1674                  chunksize[d] = pow((double)DEFAULT_CHUNK_SIZE/type_size,
#1679                if (!dim->unlimited && chunksize[d] > dim->len)
#1680                  chunksize[d] = dim->len;
#1683                var->chunksizes[d] = chunksize[d];
#1797  int d;
#1808  for (d = 0; d < var->ndimsd++)
#1809    chunk_size_bytes *= var->chunksizes[d];
#1864              int d;
#1867              for (d = 0; d < field->ndimsd++)
#1868                dims[d] = field->dim_size[d];
#2058  int d;
#2075          for (d = 0; d < var->ndimsd++)
#2080                  if (!var->dimscale_attached[d])
#2083                      dim1 = var->dim[d];
#2084       assert(dim1 && dim1->dimid == var->dimids[d]);
#2087                           __func__var->dimids[d], var->name));
#2095                      if (H5DSattach_scale(var->hdf_datasetiddim_datasetidd) < 0)
#2097                      var->dimscale_attached[d] = NC_TRUE;
#2101   if (!var->dimscale_attached[d])
#2267          int d;
#2270          for (d = 0; d < var->ndimsd++)
#2271            if (var->dimscale_attached[d])
#2274                NC_DIM_INFO_T *dim1 = var->dim[d];
#2275 assert(dim1 && dim1->dimid == var->dimids[d]);
#2284                if (H5DSdetach_scale(var->hdf_datasetiddim_datasetidd) < 0)
#2286                var->dimscale_attached[d] = NC_FALSE;
#3648      int d;
#3649      for (d = 0; d < ndimsd++)
#3651   if (var->dim[d] == NULL) {
#3652     nc4_find_dim(grpvar->dimids[d], &var->dim[d], NULL);
#3660          int d;
#3665              for (d = 0; d < var->ndimsd++)
#3676                          if (var->dimscale_hdf5_objids[d].fileno[0] == dim->hdf5_objid.fileno[0] &&
#3677                              var->dimscale_hdf5_objids[d].objno[0] == dim->hdf5_objid.objno[0] &&
#3678                              var->dimscale_hdf5_objids[d].fileno[1] == dim->hdf5_objid.fileno[1] &&
#3679                              var->dimscale_hdf5_objids[d].objno[1] == dim->hdf5_objid.objno[1])
#3682                                   __func__ddim->name));
#3683                              var->dimids[d] = dim->dimid;
#3684                              var->dim[d] = dim;
#3749              for (d = 0; d < var->ndimsd++)
#3753                    if ((dim->len == h5dimlen[d]) &&
#3754                        ((h5dimlenmax[d] == H5S_UNLIMITED && dim->unlimited) ||
#3755                         (h5dimlenmax[d] != H5S_UNLIMITED && !dim->unlimited)))
#3777                      dim->len = h5dimlen[d];
#3779                      if (h5dimlenmax[d] == H5S_UNLIMITED)
#3784                  var->dimids[d] = dim->dimid;
#3785                  var->dim[d] = dim;
nc4internal.c#118   int ddataset_ndims = 0;
#167       for (d=0; d<dataset_ndimsd++) {
#168  if (var->dimids[d] == dimid) {
#169    *maxlen = *maxlen > h5dimlen[d] ? *maxlen : h5dimlen[d];
#1131   NC_DIM_INFO_T *d, *dim;
#1184      d = dim->l.next;
#1187      dim = d;
#1317      int d;
#1320      for (d = 0; d < var->ndims && !finishedd++)
#1322         if(var->dimscale_attached[d])
#1331                  if (var->dimids[d] == dim1->dimid)
#1341                     if (H5DSdetach_scale(var->hdf_datasetiddim_datasetidd) < 0)
#1343                     var->dimscale_attached[d] = NC_FALSE;
#1462   int tretvald;
#1485         for (d = 0; d < var->ndimsd++)
#1487             sprintf(temp_string, " %d", var->dimids[d]);
nc4type.c#443   int dretval;
#466     for (d = 0; d < field->ndimsd++)
#467        dim_sizesp[d] = field->dim_size[d];
nc4var.c#206   int d;
#215   for (d = 0; d < var->ndimsd++)
#217      if (chunksizes[d] < 1)
#219      dprod *= (double) chunksizes[d];
#233   int d;
#255   for (d = 0; d < var->ndimsd++)
#257      assert(var->dim[d]);
#258      if (! var->dim[d]->unlimited)
#259  num_values *= (float)var->dim[d]->len;
#262   var->chunksizes[d] = 1; /* overwritten below, if all dims are unlimited */
#278     "chunksize %ld", __func__var->namedDEFAULT_CHUNK_SIZEnum_valuestype_sizevar->chunksizes[0]));
#282       for (d = 0; d < var->ndimsd++)
#284    var->chunksizes[d] = suggested_size ? suggested_size : 1;
#286 "chunksize %ld", __func__var->namedDEFAULT_CHUNK_SIZEnum_valuestype_sizevar->chunksizes[d]));
#292   for (d = 0; d < var->ndimsd++)
#293      if (!var->chunksizes[d])
#296        1.0/(double)(var->ndims - num_unlim)) * var->dim[d]->len - .5);
#297  if (suggested_size > var->dim[d]->len)
#298     suggested_size = var->dim[d]->len;
#299  var->chunksizes[d] = suggested_size ? suggested_size : 1;
#301       "chunksize %ld", __func__var->namedDEFAULT_CHUNK_SIZEnum_valuestype_sizevar->chunksizes[d]));
#306   for (d = 0; d < var->ndimsd++)
#307       total_chunk_size *= (double) var->chunksizes[d];
#321      for (d = 0; d < var->ndimsd++)
#322     var->chunksizes[d] = var->chunksizes[d]/2 ? var->chunksizes[d]/2 : 1;
#328   for (d = 0; d < var->ndimsd++)
#332       assert(var->chunksizes[d] > 0);
#333       num_chunks = (var->dim[d]->len + var->chunksizes[d] - 1) / var->chunksizes[d];
#335    overhang = (num_chunks * var->chunksizes[d]) - var->dim[d]->len;
#336    var->chunksizes[d] -= overhang / num_chunks;
#355   int d;
#402   for (d = 0; d < ndimsd++)
#403      if ((retval = nc4_find_dim(grpdimidsp[d], &dimNULL)))
#504   for (d = 0; d < ndimsd++)
#509      if ((retval = nc4_find_dim(grpdimidsp[d], &dim, &dim_grp)))
#513      if (d == 0 && dim_grp == grp && dim->hash == var->hash && strcmp(dim->namenorm_name) == 0)
#522            if ((retval = rec_detach_scales(grpdimidsp[d], dim->hdf_dimscaleid)) < 0)
#545      var->dimids[d] = dimidsp[d];
#546      var->dim[d] = dim;
#647   int d;
#690      for (d = 0; d < var->ndimsd++)
#691         dimidsp[d] = var->dimids[d];
#701      for (d = 0; d < var->ndimsd++)
#703         chunksizesp[d] = var->chunksizes[d];
#704         LOG((4, "chunksizesp[%d]=%d", dchunksizesp[d]));
#802   int d;
#897      for (d = 0; d < var->ndimsd++)
#899  dim = var->dim[d];
#919  for (d = 0; d < var->ndimsd++) {
#920     if(var->dim[d]->len > 0 && chunksizes[d] > var->dim[d]->len)
#925  for (d = 0; d < var->ndimsd++)
#926     var->chunksizes[d] = chunksizes[d];
#1335   int retvald;
#1344   for (d = 0; d < var->ndimsd++)
#1346      start32[d] = startp[d];
#1347      edge32[d] = countp[d];
nccommon.h#195#define DIMFLAG(d,flag) ((d)->dim.dimflags & (flag))
#196#define DIMFLAGSET(d,flag) ((d)->dim.dimflags |= (flag))
#197#define DIMFLAGCLR(d,flag) ((d)->dim.dimflags &= ~(flag))
ncdump.c#1366     int d;
#1392 for (d = 0; d < field_ndims-1; d++)
#1393     printf("%d, ", field_dim_sizes[d]);
ncpdispatch.c#579    int d;
#593    for (d = 0; d < rankd++) {
#594  mpi_start[d] = startp[d];
#595  mpi_count[d] = countp[d];
#673    int d;
#687    for (d = 0; d < rankd++) {
#688  mpi_start[d] = startp[d];
#689  mpi_count[d] = countp[d];
#768    int d;
#782    for (d = 0; d < rankd++) {
#783  mpi_start[d] = startp[d];
#784  mpi_count[d] = countp[d];
#785  mpi_stride[d] = stridep[d];
#864    int d;
#878    for (d = 0; d < rankd++) {
#879  mpi_start[d] = startp[d];
#880  mpi_count[d] = countp[d];
#881  mpi_stride[d] = stridep[d];
#961    int d;
#975    for (d = 0; d < rankd++) {
#976  mpi_start[d] = startp[d];
#977  mpi_count[d] = countp[d];
#978  mpi_stride[d] = stridep[d];
#979  mpi_imap[d] = imapp[d];
#1059    int d;
#1073    for (d = 0; d < rankd++) {
#1074  mpi_start[d] = startp[d];
#1075  mpi_count[d] = countp[d];
#1076  mpi_stride[d] = stridep[d];
#1077  mpi_imap[d] = imapp[d];
#1324    int retval,d,ndims;
#1331        for (d = 0; d < ndimsd++)
#1332            dimids[d] = d;
ncx.c#2355 struct vax_double d;
#2387 *vdp = lim->d;
#2421 if ((vdp->mantissa4 > (dbl_limits[0].d.mantissa4 - 3)) &&
#2422 (vdp->mantissa3 == dbl_limits[0].d.mantissa3) &&
#2423 (vdp->mantissa2 == dbl_limits[0].d.mantissa2) &&
#2424 (vdp->mantissa1 == dbl_limits[0].d.mantissa1) &&
#2425 (vdp->exp == dbl_limits[0].d.exp))
#2430 if ((vdp->mantissa4 == dbl_limits[1].d.mantissa4) &&
#2431 (vdp->mantissa3 == dbl_limits[1].d.mantissa3) &&
#2432 (vdp->mantissa2 == dbl_limits[1].d.mantissa2) &&
#2433 (vdp->mantissa1 == dbl_limits[1].d.mantissa1) &&
#2434 (vdp->exp == dbl_limits[1].d.exp))
#9785  double d;               /* special case for ncx_putn_int_float */
#9806      d = tp[i];
#9807      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) d));
#13088 *vdp = lim->d;
#13747 if ((vdp->mantissa4 > (dbl_limits[0].d.mantissa4 - 3)) &&
#13748 (vdp->mantissa3 == dbl_limits[0].d.mantissa3) &&
#13749 (vdp->mantissa2 == dbl_limits[0].d.mantissa2) &&
#13750 (vdp->mantissa1 == dbl_limits[0].d.mantissa1) &&
#13751 (vdp->exp == dbl_limits[0].d.exp))
#13756 if ((vdp->mantissa4 == dbl_limits[1].d.mantissa4) &&
#13757 (vdp->mantissa3 == dbl_limits[1].d.mantissa3) &&
#13758 (vdp->mantissa2 == dbl_limits[1].d.mantissa2) &&
#13759 (vdp->mantissa1 == dbl_limits[1].d.mantissa1) &&
#13760 (vdp->exp == dbl_limits[1].d.exp))
ocdump.c#269        double d;
#319    if(isxdrxxdrntohdouble(dform.cv,&dform.d);
#320    sprintf(tmp,"%#g",dform.d);
ref_ctest.c#792    static double d = -10.;
#793    stat = nc_put_var_double(ncidd_id, &d);
ref_ctest64.c#792    static double d = -10.;
#793    stat = nc_put_var_double(ncidd_id, &d);
test_get.c#2042    int d;
#2137                for (d = 0; d < var_rank[i]; d++)
#2138                    index[d] += start[d];
#2198    int d;
#2293                for (d = 0; d < var_rank[i]; d++)
#2294                    index[d] += start[d];
#2354    int d;
#2449                for (d = 0; d < var_rank[i]; d++)
#2450                    index[d] += start[d];
#2510    int d;
#2605                for (d = 0; d < var_rank[i]; d++)
#2606                    index[d] += start[d];
#2666    int d;
#2761                for (d = 0; d < var_rank[i]; d++)
#2762                    index[d] += start[d];
#2822    int d;
#2917                for (d = 0; d < var_rank[i]; d++)
#2918                    index[d] += start[d];
#2978    int d;
#3073                for (d = 0; d < var_rank[i]; d++)
#3074                    index[d] += start[d];
#3134    int d;
#3229                for (d = 0; d < var_rank[i]; d++)
#3230                    index[d] += start[d];
#3290    int d;
#3385                for (d = 0; d < var_rank[i]; d++)
#3386                    index[d] += start[d];
#3446    int d;
#3541                for (d = 0; d < var_rank[i]; d++)
#3542                    index[d] += start[d];
#3602    int d;
#3697                for (d = 0; d < var_rank[i]; d++)
#3698                    index[d] += start[d];
#3758    int d;
#3853                for (d = 0; d < var_rank[i]; d++)
#3854                    index[d] += start[d];
#3917    int d;
#4027     for (d = 0; d < var_rank[i]; d++)
#4028 index2[d] = index[d] + index2[d] * stride[d];
#4091    int d;
#4201     for (d = 0; d < var_rank[i]; d++)
#4202 index2[d] = index[d] + index2[d] * stride[d];
#4265    int d;
#4375     for (d = 0; d < var_rank[i]; d++)
#4376 index2[d] = index[d] + index2[d] * stride[d];
#4439    int d;
#4549     for (d = 0; d < var_rank[i]; d++)
#4550 index2[d] = index[d] + index2[d] * stride[d];
#4613    int d;
#4723     for (d = 0; d < var_rank[i]; d++)
#4724 index2[d] = index[d] + index2[d] * stride[d];
#4787    int d;
#4897     for (d = 0; d < var_rank[i]; d++)
#4898 index2[d] = index[d] + index2[d] * stride[d];
#4961    int d;
#5071     for (d = 0; d < var_rank[i]; d++)
#5072 index2[d] = index[d] + index2[d] * stride[d];
#5135    int d;
#5245     for (d = 0; d < var_rank[i]; d++)
#5246 index2[d] = index[d] + index2[d] * stride[d];
#5309    int d;
#5419     for (d = 0; d < var_rank[i]; d++)
#5420 index2[d] = index[d] + index2[d] * stride[d];
#5483    int d;
#5593     for (d = 0; d < var_rank[i]; d++)
#5594 index2[d] = index[d] + index2[d] * stride[d];
#5657    int d;
#5767     for (d = 0; d < var_rank[i]; d++)
#5768 index2[d] = index[d] + index2[d] * stride[d];
#5831    int d;
#5941     for (d = 0; d < var_rank[i]; d++)
#5942 index2[d] = index[d] + index2[d] * stride[d];
#6008    int d;
#6126                    for (d = 0; d < var_rank[i]; d++)
#6127                        index2[d] = index[d] + index2[d] * stride[d];
#6190    int d;
#6308                    for (d = 0; d < var_rank[i]; d++)
#6309                        index2[d] = index[d] + index2[d] * stride[d];
#6372    int d;
#6490                    for (d = 0; d < var_rank[i]; d++)
#6491                        index2[d] = index[d] + index2[d] * stride[d];
#6554    int d;
#6672                    for (d = 0; d < var_rank[i]; d++)
#6673                        index2[d] = index[d] + index2[d] * stride[d];
#6736    int d;
#6854                    for (d = 0; d < var_rank[i]; d++)
#6855                        index2[d] = index[d] + index2[d] * stride[d];
#6918    int d;
#7036                    for (d = 0; d < var_rank[i]; d++)
#7037                        index2[d] = index[d] + index2[d] * stride[d];
#7100    int d;
#7218                    for (d = 0; d < var_rank[i]; d++)
#7219                        index2[d] = index[d] + index2[d] * stride[d];
#7282    int d;
#7400                    for (d = 0; d < var_rank[i]; d++)
#7401                        index2[d] = index[d] + index2[d] * stride[d];
#7464    int d;
#7582                    for (d = 0; d < var_rank[i]; d++)
#7583                        index2[d] = index[d] + index2[d] * stride[d];
#7646    int d;
#7764                    for (d = 0; d < var_rank[i]; d++)
#7765                        index2[d] = index[d] + index2[d] * stride[d];
#7828    int d;
#7946                    for (d = 0; d < var_rank[i]; d++)
#7947                        index2[d] = index[d] + index2[d] * stride[d];
#8010    int d;
#8128                    for (d = 0; d < var_rank[i]; d++)
#8129                        index2[d] = index[d] + index2[d] * stride[d];
test_put.c#233    int  d;
#287     for (d = 0; d < var_rank[i]; d++)
#288 error(" %d", index[d]);
#317    int  d;
#371     for (d = 0; d < var_rank[i]; d++)
#372 error(" %d", index[d]);
#401    int  d;
#455     for (d = 0; d < var_rank[i]; d++)
#456 error(" %d", index[d]);
#485    int  d;
#539     for (d = 0; d < var_rank[i]; d++)
#540 error(" %d", index[d]);
#569    int  d;
#623     for (d = 0; d < var_rank[i]; d++)
#624 error(" %d", index[d]);
#653    int  d;
#707     for (d = 0; d < var_rank[i]; d++)
#708 error(" %d", index[d]);
#737    int  d;
#791     for (d = 0; d < var_rank[i]; d++)
#792 error(" %d", index[d]);
#821    int  d;
#875     for (d = 0; d < var_rank[i]; d++)
#876 error(" %d", index[d]);
#905    int  d;
#959     for (d = 0; d < var_rank[i]; d++)
#960 error(" %d", index[d]);
#989    int  d;
#1043     for (d = 0; d < var_rank[i]; d++)
#1044 error(" %d", index[d]);
#1073    int  d;
#1127     for (d = 0; d < var_rank[i]; d++)
#1128 error(" %d", index[d]);
#1157    int  d;
#1211     for (d = 0; d < var_rank[i]; d++)
#1212 error(" %d", index[d]);
#4919    int d;
#5030 for (d = 0; d < var_rank[i]; d++)
#5031     index[d] += start[d];
#5070    int d;
#5181 for (d = 0; d < var_rank[i]; d++)
#5182     index[d] += start[d];
#5221    int d;
#5332 for (d = 0; d < var_rank[i]; d++)
#5333     index[d] += start[d];
#5372    int d;
#5483 for (d = 0; d < var_rank[i]; d++)
#5484     index[d] += start[d];
#5523    int d;
#5634 for (d = 0; d < var_rank[i]; d++)
#5635     index[d] += start[d];
#5674    int d;
#5785 for (d = 0; d < var_rank[i]; d++)
#5786     index[d] += start[d];
#5825    int d;
#5936 for (d = 0; d < var_rank[i]; d++)
#5937     index[d] += start[d];
#5976    int d;
#6087 for (d = 0; d < var_rank[i]; d++)
#6088     index[d] += start[d];
#6127    int d;
#6238 for (d = 0; d < var_rank[i]; d++)
#6239     index[d] += start[d];
#6278    int d;
#6389 for (d = 0; d < var_rank[i]; d++)
#6390     index[d] += start[d];
#6429    int d;
#6540 for (d = 0; d < var_rank[i]; d++)
#6541     index[d] += start[d];
#6580    int d;
#6691 for (d = 0; d < var_rank[i]; d++)
#6692     index[d] += start[d];
#6734    int d;
#6864     for (d = 0; d < var_rank[i]; d++)
#6865 index2[d] = index[d] + index2[d] * stride[d];
#6906    int d;
#7036     for (d = 0; d < var_rank[i]; d++)
#7037 index2[d] = index[d] + index2[d] * stride[d];
#7078    int d;
#7208     for (d = 0; d < var_rank[i]; d++)
#7209 index2[d] = index[d] + index2[d] * stride[d];
#7250    int d;
#7380     for (d = 0; d < var_rank[i]; d++)
#7381 index2[d] = index[d] + index2[d] * stride[d];
#7422    int d;
#7552     for (d = 0; d < var_rank[i]; d++)
#7553 index2[d] = index[d] + index2[d] * stride[d];
#7594    int d;
#7724     for (d = 0; d < var_rank[i]; d++)
#7725 index2[d] = index[d] + index2[d] * stride[d];
#7766    int d;
#7896     for (d = 0; d < var_rank[i]; d++)
#7897 index2[d] = index[d] + index2[d] * stride[d];
#7938    int d;
#8068     for (d = 0; d < var_rank[i]; d++)
#8069 index2[d] = index[d] + index2[d] * stride[d];
#8110    int d;
#8240     for (d = 0; d < var_rank[i]; d++)
#8241 index2[d] = index[d] + index2[d] * stride[d];
#8282    int d;
#8412     for (d = 0; d < var_rank[i]; d++)
#8413 index2[d] = index[d] + index2[d] * stride[d];
#8454    int d;
#8584     for (d = 0; d < var_rank[i]; d++)
#8585 index2[d] = index[d] + index2[d] * stride[d];
#8626    int d;
#8756     for (d = 0; d < var_rank[i]; d++)
#8757 index2[d] = index[d] + index2[d] * stride[d];
#8801    int d;
#8939                    for (d = 0; d < var_rank[i]; d++)
#8940                        index2[d] = index[d] + index2[d] * stride[d];
#8981    int d;
#9119                    for (d = 0; d < var_rank[i]; d++)
#9120                        index2[d] = index[d] + index2[d] * stride[d];
#9161    int d;
#9299                    for (d = 0; d < var_rank[i]; d++)
#9300                        index2[d] = index[d] + index2[d] * stride[d];
#9341    int d;
#9479                    for (d = 0; d < var_rank[i]; d++)
#9480                        index2[d] = index[d] + index2[d] * stride[d];
#9521    int d;
#9659                    for (d = 0; d < var_rank[i]; d++)
#9660                        index2[d] = index[d] + index2[d] * stride[d];
#9701    int d;
#9839                    for (d = 0; d < var_rank[i]; d++)
#9840                        index2[d] = index[d] + index2[d] * stride[d];
#9881    int d;
#10019                    for (d = 0; d < var_rank[i]; d++)
#10020                        index2[d] = index[d] + index2[d] * stride[d];
#10061    int d;
#10199                    for (d = 0; d < var_rank[i]; d++)
#10200                        index2[d] = index[d] + index2[d] * stride[d];
#10241    int d;
#10379                    for (d = 0; d < var_rank[i]; d++)
#10380                        index2[d] = index[d] + index2[d] * stride[d];
#10421    int d;
#10559                    for (d = 0; d < var_rank[i]; d++)
#10560                        index2[d] = index[d] + index2[d] * stride[d];
#10601    int d;
#10739                    for (d = 0; d < var_rank[i]; d++)
#10740                        index2[d] = index[d] + index2[d] * stride[d];
#10781    int d;
#10919                    for (d = 0; d < var_rank[i]; d++)
#10920                        index2[d] = index[d] + index2[d] * stride[d];
test_read.c#904    int d;
#985     for (d = 0; d < var_rank[i]; d++)
#986 index[d] += start[d];
#1024    int d;
#1140 for (d = 0; d < var_rank[i]; d++)
#1141     index2[d] = index[d] + index2[d] * stride[d];
test_write.c#790    int d;
#868 for (d = 0; d < var_rank[i]; d++)
#869     index[d] += start[d];
#911    int d;
#1022     for (d = 0; d < var_rank[i]; d++)
#1023 index2[d] = index[d] + index2[d] * stride[d];
tests.h#534int dbl2nc ( const double d, const nc_type datatype, void *p);
tst_atts1.c#91   double d[3] = {420.0, -420.0, 420.0};
#103   if (nc_put_att_double(ncidNC_GLOBALname[5], NC_DOUBLElen[5], d)) ERR;
tst_atts3.c#95   double d[3] = {420.0, -420.0, 420.0};
#111   if (nc_put_att_double(ncidNC_GLOBALname[5], NC_DOUBLElen[5], d)) ERR;
tst_chunk_hdf4.c#32   int d;
#58      for(d=0;d<rank;d++) {
#59 if(EXPECTED_CHUNKSIZES[d] != chunksizes[d]) {
#60     fprintf(stderr,"chunk size mismatch: [%d] %ld :: %ld\n",d,chunksizes[d],EXPECTED_CHUNKSIZES[d]);
tst_chunks.c#88      int dt;
#92      for (d = 0; d < NUM_DIMd++)
#94  sprintf(dim_name, "dim_%d", dim_len[d]);
#98  if (nc_def_dim(nciddim_namedim_len[d], &dimid[d])) ERR;
tst_chunks2.c#21   int d;
#33   for (d = 0; d < ndimsd++)
#36      for (num_chunks[d] = 0; (num_chunks[d] * chunksize[d]) < (dimlen[d] ? dimlen[d] : 1);
#37    num_chunks[d]++)
#39      chunked *= (num_chunks[d] * chunksize[d]);
#44   for (d = 0; d < ndimsd++)
#45      unchunked *= (dimlen[d] ? dimlen[d] : 1);
#58   for (d = 0; d < ndimsd++)
#61      printf("%ld\t%ld\t\t%ld\n", (long int)dimlen[d], (long int)chunksize[d],
#62      (long int)num_chunks[d]);
#64      chunk_size *= chunksize[d];
#155      int d;
#162      for (d = 0; d < NDIMS3d++)
#164  sprintf(dim_name, "dim_%d", d);
#165  if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
#193      int d;
#200      for (d = 0; d < NDIMS3d++)
#202  sprintf(dim_name, "dim_%d", d);
#203  if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
#231      int d;
#238      for (d = 0; d < NDIMS3d++)
#240  sprintf(dim_name, "dim_%d", d);
#241  if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
#272      int d;
#279      for (d = 0; d < NDIMS3d++)
#281  sprintf(dim_name, "dim_%d", d);
#282  if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
#312      int d;
#319      for (d = 0; d < NDIMS3d++)
#321  sprintf(dim_name, "dim_%d", d);
#322  if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
#351      int dt;
#360  for (d = 0; d < NDIMS3d++)
#362     dim_len[d] = rand();
#363     sprintf(dim_name, "dim_%d", d);
#364     if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
#388      int dt;
#400  for (d = 0; d < NDIMS3d++)
#402     sprintf(dim_name, "dim_%d", d);
#403     if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
#427      int dt;
#439  for (d = 0; d < NDIMS3d++)
#441     sprintf(dim_name, "dim_%d", d);
#442     if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR;
tst_coords2.c#52      int d;
#94      for (d = 0; d < NDIMSd++)
#95  if (dimids_in[d] != dimids[d]) ERR;
#122      for (d = 0; d < NDIMSd++)
#123  if (dimids_in[d] != dimids[d]) ERR;
tst_create_files.c#46       int di;
#77       for (d = 1; d < NDIMS3d++)
#79   start[d] = 0;
#80   count[d] = dim_len[d];
#156       int idt;
#178      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
#180 sprintf(dim_name, "dim_%d", d);
#181 if (nc_def_dim(nciddim_namelen, &dimids[d])) ERR;
#268       int idt;
#290      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
#292 sprintf(dim_name, "dim_%d", d);
#293 if (nc_def_dim(nciddim_namelen, &dimids[d])) ERR;
tst_files2.c#98   int idret;
#117   for (d = 0; d < ndimsd++)
#119      sprintf(dim_name, "dim_%d", d);
#120      if (nc_def_dim(nciddim_namedim_len[d], &dimids[d])) ERR_RET;
#136   for (d = 0; d < ndimsd++)
#138      if (d < ndims - 2)
#139  count[d] = 1;
#142  start[d] = 0;
#143  count[d] = dim_len[d];
#202      int dft;
#215  for (d = 0; d < ndims[t]; d++)
#216     dim_len[t][d] = dim_4d[d];
tst_h_dimscales.c#49   int ndimsd;
#96        for (d = 0; d < ndimsd++)
#97   if (H5DSiterate_scales(datasetiddNULLalien_visitor,
#567      int d;
#635   for (d = 0; d < NDIMSd++)
#636      if (H5DSiterate_scales(datasetiddNULLalien_visitor,
tst_h_dimscales2.c#265      int dndims;
#317   for (d = 0; d < ndimsd++)
#319      if (H5DSiterate_scales(datasetiddNULLalien_visitor2,
#320      &(vars_dimscale_obj[d])) < 0) ERR;
#325      if (vars_dimscale_obj[d].fileno[0] != dimscale_obj[d].fileno[0] ||
#326      vars_dimscale_obj[d].objno[0] != dimscale_obj[d].objno[0]) ERR;
#327      if (vars_dimscale_obj[d].fileno[1] != dimscale_obj[d].fileno[1] ||
#328      vars_dimscale_obj[d].objno[1] != dimscale_obj[d].objno[1]) ERR;
#369      int dndims;
#496   for (d = 0; d < ndimsd++)
#498      if (H5DSiterate_scales(datasetiddNULLalien_visitor2,
#499     &(vars_dimscale_obj[d])) < 0) ERR;
#504      if (vars_dimscale_obj[d].fileno[0] != dimscale_obj[d].fileno[0] ||
#505  vars_dimscale_obj[d].objno[0] != dimscale_obj[d].objno[0]) ERR;
#506      if (vars_dimscale_obj[d].fileno[1] != dimscale_obj[d].fileno[1] ||
#507  vars_dimscale_obj[d].objno[1] != dimscale_obj[d].objno[1]) ERR;
#672      int dndims;
#797   for (d = 0; d < ndimsd++)
#799      if (H5DSiterate_scales(datasetiddNULLalien_visitor2,
#800      &(vars_dimscale_obj[d])) < 0) ERR;
#805      if (vars_dimscale_obj[d].fileno[0] != dimscale_obj[d].fileno[0] ||
#806      vars_dimscale_obj[d].objno[0] != dimscale_obj[d].objno[0]) ERR;
#807      if (vars_dimscale_obj[d].fileno[1] != dimscale_obj[d].fileno[1] ||
#808      vars_dimscale_obj[d].objno[1] != dimscale_obj[d].objno[1]) ERR;
#857      int dndims;
#982   for (d = 0; d < ndimsd++)
#984      if (H5DSiterate_scales(datasetiddNULLalien_visitor2,
#985      &(vars_dimscale_obj[d])) < 0) ERR;
#990      if (vars_dimscale_obj[d].fileno[0] != dimscale_obj[d].fileno[0] ||
#991      vars_dimscale_obj[d].objno[0] != dimscale_obj[d].objno[0]) ERR;
#992      if (vars_dimscale_obj[d].fileno[1] != dimscale_obj[d].fileno[1] ||
#993      vars_dimscale_obj[d].objno[1] != dimscale_obj[d].objno[1]) ERR;
tst_h_rd_cmp.c#23  double d;
#54      if (data[i].c1 != 126 || data[i].d != -9999999) ERR;
tst_h_wrt_cmp.c#26      double d;
#40      data[i].d = -9999999;
#55   if (H5Tinsert(typeid, "d", HOFFSET(struct s1d), H5T_NATIVE_DOUBLE) < 0) ERR;
tst_interops2.c#125      int dt;
#139  for (d = 0; d < DIMS_3d++)
#142     if ((dimid = SDgetdimid(sds_idd)) == FAILERR;
#143     if (SDsetdimname(dimiddim_name[d])) ERR;
tst_unlim_vars.c#36   int d;
#56   for (d = 0; d < NDIMSd++)
#57      dimids[d] = d;
#67   for (d = 0; d < NDIMSd++)
#68      if (dimids_in[d] != dimids[d]) ERR;
#86   for (d = 0; d < NDIMSd++)
#87      if (dimids_in[d] != dimids[d]) ERR;
#106   for (d = 0; d < NDIMSd++)
#107      if (dimids_in[d] != dimids[d]) ERR;
#118   for (d = 0; d < NDIMSd++)
#119      start[d] = 0;
#132   for (d = 0; d < NDIMSd++)
#133      if (dimids_in[d] != dimids[d]) ERR;
tst_vars2.c#667      int id;
#692      for (d = 0; d < NDIMS5d++)
#693  if (chunksize[d] != chunksize_in[d]) ERR;
#719      for (d = 0; d < NDIMS5d++)
#720  if (chunksize[d] != chunksize_in[d]) ERR;
#948      int d;
#970      for (d = 0; d < NDIMS17d++)
#971  if (chunksize[d] != chunksize_in[d]) ERR;
#989      for (d = 0; d < NDIMS17d++)
#990  if (chunksize[d] != chunksize_in[d]) ERR;
util.c#293int dbl2nc ( const double d, const nc_type datatype, void *p)
#300                r = floor(0.5+d);
#305              r = floor(0.5+d);
#314                r = floor(0.5+d);
#319                r = floor(0.5+d);
#328                if ( fabs(d) > float_max )  return 2;
#329                *((float  *) p) = d;
#332                *((double *) p) = d;
#335            r = floor(0.5+d);
#340            r = floor(0.5+d);
#345            r = floor(0.5+d);
#354            r = floor(0.5+d);
#359            r = floor(0.5+d);
#381    int  d;       /* index of dimension */
#469 for (d = 0; d < abs(rank); d++)
#470     result = base * (result + index[d]);
#486    int  d;       /* index of dimension */
#574 for (d = 0; d < abs(rank); d++)
#575     result = base * (result + index[d]);


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