cache.c#419            CDFnodedim = (CDFnode*)nclistget(var->array.dimsettrans,j);
#420            nelems *= dim->dim.declsize;
cdf.c#261             if(vdim->dim.declsize != tdim->dim.declsize) {
#701     CDFnodedim = (CDFnode*)nclistget(node->array.dimset0,j);
#703     dim->dim.declsize0 = basedim->dim.declsize;
#705fprintf(stderr,"dimimprint: %d: %lu -> %lu\n",i,basedim->dim.declsize,dim->dim.declsize0);
#713clonedim(NCDAPCOMMONnccommCDFnodedimCDFnodevar)
#716    clone = makecdfnode(nccomm,dim->ocname,OC_Dimension,
#717   NULL,dim->container);
#719    nclistpush(dim->container->root->tree->nodes,(void*)clone);
#720    clone->dim = dim->dim; /* copy most everything */
#721    clone->dim.dimflags |= CDFDIMCLONE;
#722    clone->dim.array = var;
#733        CDFnode *dim = NULL;
#737        dim = (CDFnode*)nclistget(dimset,i);
#738        nclistpush(result,(void*)clonedim(nccomm,dim,var));
#1219 cdfdim->dim.declsize = declsize;
#1220 cdfdim->dim.array = cdfnode;
constraints.c#156     CDFnodedim = (CDFnode*)nclistget(dimset,j);
#157     if(dim->dim.basedim != NULLdim = dim->dim.basedim;
#158            ASSERT(dim != null);
#160         seg->slices[j].declsize = dim->dim.declsize;
#162         dcemakewholeslice(seg->slices+j,dim->dim.declsize);
#447dapiswholeslice(DCEslicesliceCDFnodedim)
#450    if(dim != NULL) {
#451 if(slice->length != dim->dim.declsize) return 0;
#452    } else if(dim == NULL) {
#474 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#475 if(!dapiswholeslice(&seg->slices[i],dim)) {whole = 0; break;}
#718     CDFnodedim;
#720     dim = (CDFnode*)nclistget(dimset,j);
#721     ASSERT(dim->dim.declsize0 > 0);
#722     dcemakewholeslice(slice,dim->dim.declsize0);
constraints.h#16extern int dapiswholeslice(DCEslice*, struct CDFnodedim);
#22extern void dapmakewholeslice(DCEsliceslice, struct CDFnodedim);
dapdump.c#356     CDFnodedim = (CDFnode*)nclistget(dimset,i);
#359     if(dim->ncbasename != NULL) {
#360 ncbytescat(buf,dim->ncbasename);
#363     snprintf(tmp,sizeof(tmp),"%lu",(unsigned long)dim->dim.declsize);
#465 CDFnodedim = (CDFnode*)nclistget(node->array.dimset0,i);
#468 snprintf(tmp,sizeof(tmp),"    ocname=%s\n",dim->ocname);
#470 snprintf(tmp,sizeof(tmp),"    ncbasename=%s\n",dim->ncbasename);
#473 (unsigned int)dim->dim.dimflags);
#476     (unsigned long)dim->dim.declsize);
dapparse.c#141    OCnodedim;
#147 dim = newocnode((char*)name,OC_Dimension,state);
#149 dim = newocnode(NULL,OC_Dimension,state);
#150    dim->dim.declsize = value;
#151    return dim;
#243        OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#244        dim->dim.array = node;
#245 dim->dim.arrayindex = i;
#247 if(dim->name == NULL) {
#248     dim->dim.anonymous = 1;
#249     dim->name = dimnameanon(node->name,i);
daputil.c#261 CDFnodedim = (CDFnode*)nclistget(dimensions,i);
#262 size *= dim->dim.declsize;
dimtests.c#216    struct cdfdim dim; /* dimension */
#225    dim.name = (char *) emalloc(MAX_NC_NAME);
#227 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#233 if (strcmp(dim.nametest.dims[dimid].name) != 0) {
#235 pnamedim.nametest.dims[dimid].namedimid);
#238 if (dim.size != test.dims[dimid].size) {
#240 pnamedim.sizetest.dims[dimid].sizedimid);
#250 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#256 if (strcmp(dim.nametest.dims[dimid].name) != 0) {
#258 pnamedim.nametest.dims[dimid].namedimid);
#261 if (dim.size != test.dims[dimid].size) {
#263 pnamedim.sizetest.dims[dimid].sizedimid);
#268    if (ncdiminq(cdfid, -1, dim.name, &dim.size) != -1 ||
#269 ncdiminq(cdfidtest.ndimsdim.name, &dim.size) != -1) {
#284 if (ncdiminq (cdfid, 0, dim.name, &dim.size) != -1) {
#289    free(dim.name);
#317    struct cdfdim dim; /* dimension */
#349    dim.name = (char *) emalloc(MAX_NC_NAME);
#350    if (ncdiminq(cdfidpp_dimdim.name, &dim.size) == -1) {
#354    if (strcmp(dim.name,pp.name) == 0) {
#358    if (strcmp(dim.name,newname) != 0) {
#360       pnamedim.namenewname);
#372    if (ncdimrename(cdfid, -1, dim.name) != -1 ||
#373 ncdimrename(cdfidtest.ndimsdim.name) != -1) {
#410    if (ncdimrename (cdfid, 0, dim.name) != -1) {
#414    free (dim.name);
dv2i.c#614    const int* dim
#618 const int status = nc_def_var(ncidnamedatatypendimsdim, &varid);
#652    int* dim,
#658  &nddim, &na);
dvar.c#337   int dim;
#343   for(dim = 0; dim < nvardimsdim++)
#344     is_recdim[dim] = 0;
#369     for (dim = 0; dim < nvardimsdim++) { /* netCDF-4 rec dims need not be first dim for a rec var */
#371  if(dimset[dim] == unlimids[recdim]) {
#372    is_recdim[dim] = 1;
genbin.c#96       (dsym->dim.isunlimited?NC_UNLIMITED:dsym->dim.declsize),
#333      unsigned int size = efield->typ.dimset.dimsyms[j]->dim.declsize;
genc.c#179     if(dsym->dim.isunlimited) {
#186 (unsigned long) dsym->dim.declsize);
#750     Symboldim;
#753     dim = efield->typ.dimset.dimsyms[j];
#754     ASSERT(dim->dim.isconstant);
#756 (unsigned int)dim->dim.declsize);
#863 ASSERT(e->dim.isconstant);
#864 snprintf(tmp,sizeof(tmp),"%u",(unsigned int)e->dim.declsize);
genf77.c#80     if(dsym->dim.declsize == NC_UNLIMITED) {
#86 (unsigned long) dsym->dim.declsize);
#146     } else if(vsym->typ.dimset.dimsyms[0]->dim.declsize != NC_UNLIMITED) {
#155 (unsigned long)dsym->dim.declsize);
genj.c#75     if(dsym->dim.declsize == NC_UNLIMITED) {
#82 (unsigned long) dsym->dim.declsize);
#117     if(dsym->dim.declsize == NC_UNLIMITED) {
#464     nprintf(tmp,sizeof(tmp),"%lu",dsym->dim.declsize);
getfill.c#121    Symboldim = dimset->dimsyms[index];
#122    unsigned int size = dim->dim.declsize;
getvara.c#181     CDFnodedim = (CDFnode*)nclistget(ncdimsall,i);
#182     localcount[i] = dim->dim.declsize;
#192      CDFnodedim = (CDFnode*)nclistget(ncdimsall,i);
#198      if(startp[i] >= dim->dim.declsize
#199  || startp[i]+(stridep[i]*(countp[i]-1)) >= dim->dim.declsize) {
#1291 CDFnodedim = (CDFnode*)nclistget(ncdims,i);
#1292 dimsizes[i] = dim->dim.declsize;
nc4dim.c#26   NC_DIM_INFO_T *dim;
#41      for (dim = g->dimdimdim = dim->l.next)
#43  if (dim->unlimited)
#45     *unlimdimidp = dim->dimid;
#63   NC_DIM_INFO_T *dim;
#86  for (dim = grp->dimdimdim = dim->l.next)
#87     if (dim->unlimited)
#113   for (dim = grp->dimdimdim = dim->l.next)
#114      if (nn_hash == dim->hash && !strncmp(dim->namenorm_nameNC_MAX_NAME))
#119   nc4_dim_list_add(&grp->dim, &dim);
#120   dim->dimid = grp->nc4_info->next_dimid++;
#123   if (!(dim->name = strdup(norm_name)))
#125   dim->len = len;
#127      dim->unlimited = NC_TRUE;
#129   dim->hash = nn_hash;
#133      *idp = dim->dimid;
#145   NC_DIM_INFO_T *dim;
#168      for (dim = g->dimdimdim = dim->l.next)
#169  if (dim->hash == shash && !strncmp(dim->namenorm_nameNC_MAX_NAME))
#172        *idp = dim->dimid;
#188   NC_DIM_INFO_T *dim;
#201   if ((ret = nc4_find_dim(grpdimid, &dim, &dim_grp)))
#203   assert(dim);
#206   if (name && dim->name)
#207      strcpy(namedim->name);
#212      if (dim->unlimited)
#224  if (dim->too_long)
#230     *lenp = dim->len;
#244   NC_DIM_INFO_T *dim, *tmp_dim;
#271   for (dim = grp->dimdimdim = dim->l.next)
#273      if (!strncmp(dim->namenorm_nameNC_MAX_NAME))
#275      if (dim->dimid == dimid)
#276  tmp_dim = dim;
#280   dim = tmp_dim;
#283   if (dim->hdf_dimscaleid)
#286      assert(!dim->coord_var);
#289      if (H5Dclose(dim->hdf_dimscaleid) < 0)
#291      dim->hdf_dimscaleid = 0;
#294      if (H5Gunlink(grp->hdf_grpiddim->name) < 0)
#300   if(dim->name)
#301      free(dim->name);
#302   if (!(dim->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
#304   strcpy(dim->namenorm_name);
#306   dim->hash = hash_fast(norm_name, strlen(norm_name));
#309   if (dim->coord_var && strcmp(dim->namedim->coord_var->name))
#312      if ((retval = nc4_break_coord_var(grpdim->coord_vardim)))
#317   if (!dim->coord_var)
#323      if ((retval = nc4_find_var(grpdim->name, &var)))
#328      if (var && var->dim[0] == dim)
#331          assert(var->dimids[0] == dim->dimid);
#334          if ((retval = nc4_reform_coord_var(grpvardim)))
#349  NC_DIM_INFO_T *dim;
#365      for (dim=grp->dimdimdim=dim->l.next)
#367  if (dim->unlimited)
#370        unlimdimidsp[num_unlim] = dim->dimid;
nc4file.c#577        NC_DIM_INFO_T **dim)
#589   if ((retval = nc4_dim_list_add(&grp->dim, &new_dim)))
#662   *dim = new_dim;
#673       if ((retval = nc4_dim_list_del(&grp->dimnew_dim)))
#717     nc4_find_dim(grpvar->dimids[d], &var->dim[d], NULL);
#733dimscale_visitor(hid_t did, unsigned dimhid_t dsid,
#1507         size_t ndimsNC_DIM_INFO_T *dim)
#1552      if (!(var->dim = calloc(var->ndims, sizeof(NC_DIM_INFO_T *))))
#1708   if (dim)
#1720         assert(0 == strcmp(var->namedim->name));
#1722         var->dimids[0] = dim->dimid;
#1723  var->dim[0] = dim;
#1725      dim->coord_var = var;
#1925   NC_DIM_INFO_T *dim = NULL;   /* Dimension created for scales */
#1954                               max_dims[0], &dim)))
#1961   if (NULL == dim || (dim && !dim->hdf_dimscaleid))
#1962      if ((retval = read_var(grpdatasetidobj_namendimsdim)))
#2665 if (!(var->dim = malloc(sizeof(NC_DIM_INFO_T *) * var->ndims))) {
#2682  NC_DIM_INFO_T *dim;
#2697  for (dim = grp->dimdimdim = dim->l.next)
#2698     if (!strcmp(dim->namedim_name))
#2702  if (!dim)
#2706     if ((retval = nc4_dim_list_add(&grp->dim, &dim)))
#2709     dim->dimid = grp->nc4_info->next_dimid++;
#2712     if (!(dim->name = strdup(dim_name)))
#2715        dim->len = dim_len;
#2717        dim->len = *dimsize;
#2718     dim->hash = hash_fast(dim_name, strlen(dim_name));
#2722  var->dimids[d] = dim->dimid;
#2723  var->dim[d] = dim;
#3206   NC_DIM_INFO_T *dim;
#3223      for (dim = grp->dimdimdim = dim->l.next)
#3248      for (dim = grp->dimdimdim = dim->l.next)
#3249  if (dim->unlimited)
#3251     *unlimdimidp = dim->dimid;
nc4grp.c#452   NC_DIM_INFO_T *dim;
#476      for (dim = grp->dimdimdim = dim->l.next)
#480     for (dim = g->dimdimdim = dim->l.next)
#489  for (dim = grp->dimdimdim = dim->l.next)
#490     dimids[n++] = dim->dimid;
#495        for (dim = g->dimdimdim = dim->l.next)
#496   dimids[n++] = dim->dimid;
nc4hdf.c#551  NC_DIM_INFO_T *dim;
#624      dim = var->dim[d2];
#625      assert(dim && dim->dimid == var->dimids[d2]);
#626      if (!dim->unlimited)
#731          dim = var->dim[d2];
#732   assert(dim && dim->dimid == var->dimids[d2]);
#733          if (dim->unlimited)
#743              if (start[d2] + count[d2] > dim->len)
#745                  dim->len = start[d2] + count[d2];
#746                  dim->extended = NC_TRUE;
#751              xtend_size[d2] = (long long unsigned)dim->len;
#873  NC_DIM_INFO_T *dim;
#948    dim = var->dim[d2];
#949    assert(dim && dim->dimid == var->dimids[d2]);
#950    if (dim->unlimited)
#956 if ((retval = NC4_inq_dim(nciddim->dimidNULL, &ulen)))
#1528  NC_DIM_INFO_T *dim = NULL;
#1631 dim = var->dim[d];
#1632 assert(dim && dim->dimid == var->dimids[d]);
#1633 if (dim->unlimited)
#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;
#1671                if (dim->unlimited)
#1679                if (!dim->unlimited && chunksize[d] > dim->len)
#1680                  chunksize[d] = dim->len;
#2083                      dim1 = var->dim[d];
#2178      for (d1 = grp->dimd1d1 = d1->l.next)
#2206      for (d1 = grp->dimd1d1 = d1->l.next)
#2274                NC_DIM_INFO_T *dim1 = var->dim[d];
#2355write_dim(NC_DIM_INFO_T *dimNC_GRP_INFO_T *grpnc_bool_t write_dimid)
#2363  if (0 == dim->hdf_dimscaleid)
#2369      LOG((4, "%s: creating dim %s", __func__dim->name));
#2372      assert(NULL == dim->coord_var);
#2387      dims[0] = dim->len;
#2388      max_dims[0] = dim->len;
#2389      if (dim->unlimited)
#2408      LOG((4, "%s: about to H5Dcreate1 a dimscale dataset %s", __func__dim->name));
#2409      if ((dim->hdf_dimscaleid = H5Dcreate1(grp->hdf_grpiddim->nameH5T_IEEE_F32BE,
#2428      sprintf(dimscale_wo_var, "%s%10d", DIM_WITHOUT_VARIABLE, (int)dim->len);
#2429      if (H5DSset_scale(dim->hdf_dimscaleiddimscale_wo_var) < 0)
#2434  if (dim->extended)
#2438      assert(dim->unlimited);
#2443        if (!strcmp(v1->namedim->name))
#2458       assert(v1->dim[d1] && v1->dim[d1]->dimid == v1->dimids[d1]);
#2459       new_size[d1] = v1->dim[d1]->len;
#2473  if (write_dimid && dim->hdf_dimscaleid)
#2474    if ((retval = write_netcdf4_dimid(dim->hdf_dimscaleiddim->dimid)))
#2552  NC_DIM_INFO_T *dim;
#2566  dim = grp->dim;
#2572  while (dim || var)
#2578      for (found_coord = NC_FALSEdim && !found_coorddim = dim->l.next)
#2580          if (!dim->coord_var)
#2582              if ((retval = write_dim(dimgrpbad_coord_order)))
#2587              coord_varid = dim->coord_var->varid;
#3631  NC_DIM_INFO_T *dim;
#3651   if (var->dim[d] == NULL) {
#3652     nc4_find_dim(grpvar->dimids[d], &var->dim[d], NULL);
#3674                      for (dim = g->dimdimdim = dim->l.next)
#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;
#3752                  for (dim = grp->dimdimdim = dim->l.next)
#3753                    if ((dim->len == h5dimlen[d]) &&
#3754                        ((h5dimlenmax[d] == H5S_UNLIMITED && dim->unlimited) ||
#3755                         (h5dimlenmax[d] != H5S_UNLIMITED && !dim->unlimited)))
#3759                  if (!dim)
#3764                      if ((retval = nc4_dim_list_add(&grp->dim, &dim))) {
#3770                      dim->dimid = grp->nc4_info->next_dimid++;
#3771                      sprintf(phony_dim_name, "phony_dim_%d", dim->dimid);
#3772                      if (!(dim->name = strdup(phony_dim_name))) {
#3777                      dim->len = h5dimlen[d];
#3778                      dim->hash = hash_fast(phony_dim_name, strlen(phony_dim_name));
#3780                        dim->unlimited = NC_TRUE;
#3784                  var->dimids[d] = dim->dimid;
#3785                  var->dim[d] = dim;
nc4internal.c#345nc4_find_dim(NC_GRP_INFO_T *grp, int dimidNC_DIM_INFO_T **dim,
#351   assert(grp && dim);
#355      for ((*dim) = g->dim; (*dim); (*dim) = (*dim)->l.next)
#356  if ((*dim)->dimid == dimid)
#364   if (!(*dim))
#698nc4_dim_list_add(NC_DIM_INFO_T **listNC_DIM_INFO_T **dim)
#709   if (dim)
#710      *dim = new_dim;
#1041   if (var->dim)
#1042     {free(var->dim); var->dim = NULL;}
#1099nc4_dim_list_del(NC_DIM_INFO_T **listNC_DIM_INFO_T *dim)
#1102   obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)dim);
#1105   if (dim->name)
#1106      free(dim->name);
#1108   free(dim);
#1131   NC_DIM_INFO_T *d, *dim;
#1177   dim = grp->dim;
#1178   while (dim)
#1180      LOG((4, "%s: deleting dim %s", __func__dim->name));
#1182      if (dim->hdf_dimscaleid && H5Dclose(dim->hdf_dimscaleid) < 0)
#1184      d = dim->l.next;
#1185      if ((retval = nc4_dim_list_del(&grp->dimdim)))
#1187      dim = d;
#1268nc4_break_coord_var(NC_GRP_INFO_T *grpNC_VAR_INFO_T *coord_varNC_DIM_INFO_T *dim)
#1273   assert(dim->coord_var == coord_var);
#1274   assert(coord_var->dim[0] == dim);
#1275   assert(coord_var->dimids[0] == dim->dimid);
#1276   assert(0 == dim->hdf_dimscaleid);
#1281                                   dim->dimidcoord_var->hdf_datasetid)))
#1297   dim->coord_var = NULL;
#1308nc4_reform_coord_var(NC_GRP_INFO_T *grpNC_VAR_INFO_T *varNC_DIM_INFO_T *dim)
#1330               for (dim1 = g->dimdim1 && !finisheddim1 = dim1->l.next)
#1356   if (dim->hdf_dimscaleid && grp != NULL)
#1358      if (H5Dclose(dim->hdf_dimscaleid) < 0)
#1360      dim->hdf_dimscaleid = 0;
#1364      if (H5Gunlink(grp->hdf_grpiddim->name) < 0)
#1370   dim->coord_var = var;
#1456   NC_DIM_INFO_T *dim;
#1475   for(dim = grp->dimdimdim = dim->l.next)
#1477    tabsdim->dimiddim->namedim->lendim->unlimited));
nc4internal.h#154   NC_DIM_INFO_T **dim;
#277   NC_DIM_INFO_T *dim;
#364int nc4_find_dim(NC_GRP_INFO_T *grp, int dimidNC_DIM_INFO_T **dimNC_GRP_INFO_T **dim_grp);
#390int nc4_dim_list_add(NC_DIM_INFO_T **listNC_DIM_INFO_T **dim);
#391int nc4_dim_list_del(NC_DIM_INFO_T **listNC_DIM_INFO_T *dim);
#407int nc4_break_coord_var(NC_GRP_INFO_T *grpNC_VAR_INFO_T *coord_varNC_DIM_INFO_T *dim);
#408int nc4_reform_coord_var(NC_GRP_INFO_T *grpNC_VAR_INFO_T *coord_varNC_DIM_INFO_T *dim);
nc4var.c#257      assert(var->dim[d]);
#258      if (! var->dim[d]->unlimited)
#259  num_values *= (float)var->dim[d]->len;
#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;
#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;
#351   NC_DIM_INFO_T *dim;
#403      if ((retval = nc4_find_dim(grpdimidsp[d], &dimNULL)))
#491      if (!(var->dim = calloc(ndims, sizeof(NC_DIM_INFO_T *))))
#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)
#516         dim->coord_var = var;
#519         if (dim->hdf_dimscaleid)
#522            if ((retval = rec_detach_scales(grpdimidsp[d], dim->hdf_dimscaleid)) < 0)
#525            if (H5Dclose(dim->hdf_dimscaleid) < 0)
#527            dim->hdf_dimscaleid = 0;
#530            if (H5Gunlink(grp->hdf_grpiddim->name) < 0)
#538      if (dim->unlimited && !h5->hdf4)
#540      if (dim->unlimited)
#546      var->dim[d] = dim;
#570   for (dim = grp->dimdimdim = dim->l.next)
#571      if (dim->hash == var->hash && !strcmp(dim->namenorm_name) &&
#572   (!var->ndims || dimidsp[0] != dim->dimid))
#801   NC_DIM_INFO_T *dim;
#899  dim = var->dim[d];
#900  if (dim->unlimited)
#920     if(var->dim[d]->len > 0 && chunksizes[d] > var->dim[d]->len)
#1233   if (var->dimscale && strcmp(var->namevar->dim[0]->name))
#1236      if ((retval = nc4_break_coord_var(grpvarvar->dim[0])))
#1247         NC_DIM_INFO_T *dim;
#1253         if ((retval = nc4_find_dim(grpvar->dimids[0], &dim, &dim_grp)))
#1255         if (strcmp(dim->namename) == 0 && dim_grp == grp)
#1258             if ((retval = nc4_reform_coord_var(grpvardim)))
nc_iter.c#54    int dim;
#64    for(dim = 0; dim < ndimsdim++) {
#65 nvalues *= dimsizes[dim];
#219 Symboldim = sym->typ.dimset.dimsyms[i];
#220 dimlens[i] = dim->dim.declsize;
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))
#258    CDFdim           dim;        /* nctype == dimension */
nccopy.c#137    int dim;
#156 for(dim = 0; dim < ndimsdim++) {
#157     prod *= chunksizes[dim];
#178    int dim;
#215 for(dim = 1; dim < ndimsdim++) {
#216     ichunksizes[dim] = dim;
#228    for(dim = 0; dim < ndimsdim++) {
#229 nelems += 1 + (ichunksizes[dim] - 1) / ochunksizes[dim];
#230 iprod *= ichunksizes[dim];
#231 oprod *= ochunksizes[dim];
#936    int dim;
#942    for(dim = 0; dim < ndimsdim++) {
#944 NC_CHECK(nc_inq_dimlen(igrpdimids[dim], &len));
ncd2dispatch.c#40static void computedimindexanon(CDFnodedimCDFnodevar);
#585                NC_set_numrecs(nc3i,unlimited->dim.declsize);
#702        NC_set_numrecs(nc3sub,unlimited->dim.declsize);
#708 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#709        if(dim->dim.basedim != NULL) continue; /* handle below */
#710 if(DIMFLAG(dim,CDFDIMRECORD)) continue; /* defined above */
#712fprintf(stderr,"define: dim: %s=%ld\n",dim->ncfullname,(long)dim->dim.declsize);
#714 definename = getdefinename(dim);
#715        ncstat = nc_def_dim(dapcomm->nc3id,definename,dim->dim.declsize,&dimid);
#720        dim->ncid = dimid;
#726 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#727        if(dim->dim.basedim != NULL) {
#728     dim->ncid = dim->dim.basedim->ncid;
#766                CDFnodedim = (CDFnode*)nclistget(vardims,j);
#767                dimids[j] = dim->ncid;
#781CDFnodedim = (CDFnode*)nclistget(vardims,k);
#782fprintf(stderr,"[%ld]",dim->dim.declsize);
#838     CDFnodedim = (CDFnode*)nclistget(cdfnodes,i);
#839     if(dim->nctype != NC_Dimension) continue;
#840     if(DIMFLAG(dim,CDFDIMSEQ)) {
#841         char* cname = cdflegalname(dim->ocname);
#1042     CDFnodedim = (CDFnode*)nclistget(var->array.dimsetall,j);
#1043     if(dim->ocname != NULL) continue; /* not anonymous */
#1044      computedimindexanon(dim,var);
#1058 if(basedim->dim.basedim != NULL) continue; /* already processed*/
#1063     if(dupdim->dim.basedim != NULL) continue; /* already processed */
#1066            dupdim->dim.basedim = basedim; /* equate */
#1069basedim->dim.array->ocname,basedim->ocname,
#1070dupdim->dim.array->ocname,dupdim->ocname
#1081 if(basedim->dim.basedim != NULL) continue;
#1085     CDFnodedim = (CDFnode*)nclistget(alldims,j);
#1086     if(dim->dim.basedim != NULL) continue;
#1087     if(dim->ocname == NULL && basedim->ocname == NULL) continue;
#1088     if(dim->ocname == NULL || basedim->ocname == NULL) continue;
#1089     if(strcmp(dim->ocname,basedim->ocname)!=0) continue;
#1090     if(dim->dim.declsize == basedim->dim.declsize) continue;
#1093 basedim->ncfullname,(unsigned long)basedim->dim.declsize,
#1094 dim->ncfullname,(unsigned long)dim->dim.declsize);
#1096     nclistpush(conflicts,(void*)dim);
#1100     CDFnodedim = (CDFnode*)nclistget(conflicts,j);
#1101     dim->dim.index1 = j+1;
#1117 CDFnodedim = (CDFnode*)nclistget(alldims,i);
#1118 if(dim->dim.basedim == NULL) {
#1119     if(!nclistcontains(basedims,(void*)dim)) {
#1120 nclistpush(basedims,(void*)dim);
#1132 CDFnodedim = (CDFnode*)nclistget(basedims,i);
#1133 CDFnodevar = dim->dim.array;
#1134 if(dim->dim.basedim != NULLPANIC1("nonbase basedim: %s\n",dim->ocname);
#1136 if(dim->ocname == NULL) { /* anonymous: use the index to compute the name */
#1138                            var->ncfullname,dim->dim.index1-1);
#1139            nullfree(dim->ncbasename);
#1140            dim->ncbasename = cdflegalname(tmp);
#1141            nullfree(dim->ncfullname);
#1142            dim->ncfullname = nulldup(dim->ncbasename);
#1144        char* legalname = cdflegalname(dim->ocname);
#1145     nullfree(dim->ncbasename);
#1146     if(dim->dim.index1 > 0) {/* need to fix conflicting names (see above) */
#1148 snprintf(sindex,sizeof(sindex),"_%d",dim->dim.index1);
#1149 dim->ncbasename = (char*)malloc(strlen(sindex)+strlen(legalname)+1);
#1150 if(dim->ncbasename == NULL) {nullfree(legalname); return NC_ENOMEM;}
#1151 strcpy(dim->ncbasename,legalname);
#1152 strcat(dim->ncbasename,sindex);
#1155         dim->ncbasename = legalname;
#1157         nullfree(dim->ncfullname);
#1158     dim->ncfullname = nulldup(dim->ncbasename);
#1166 if(dim1->dim.basedim != NULLPANIC1("nonbase basedim: %s\n",dim1->ncbasename);
#1176                dim1->ncfullname,(unsigned long)dim1->dim.declsize,
#1177                dim2->ncfullname,(unsigned long)dim2->dim.declsize);
#1185CDFnodedim = (CDFnode*)nclistget(basedims,i);
#1186fprintf(stderr,"basedim: %s=%ld\n",dim->ncfullname,(long)dim->dim.declsize);
#1326computedimindexanon(CDFnodedimCDFnodevar)
#1332        if(dim == candidate) {
#1333    dim->dim.index1=i+1;
#1345        CDFnodedim = (CDFnode*)nclistget(dims,i);
#1346 CDFnodebasedim = dim->dim.basedim;
#1361    if(dupdim->dim.declsize != basedim->dim.declsize) return 0;
#1373 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#1374 if(!nclistcontains(alldims,(void*)dim)) {
#1377 dim->ncfullname,(unsigned long)dim->dim.declsize);
#1379     nclistpush(alldims,(void*)dim);
#1427    globalsdim->dim.declsize = dapcomm->cdf.defaultstringlength;
#1428    globalsdim->dim.declsize0 = globalsdim->dim.declsize;
#1429    globalsdim->dim.array = dapcomm->cdf.ddsroot;
#1463     sdim->dim.declsize = dimsize;
#1464     sdim->dim.declsize0 = dimsize;
#1465     sdim->dim.array = var;
#1486        CDFnodedim = (CDFnode*)nclistget(basedims,i);
#1487 if(strcmp(dim->ocname,dapcomm->cdf.recorddimname) != 0) continue;
#1488        DIMFLAGSET(dim,CDFDIMRECORD);
#1489 dapcomm->cdf.recorddim = dim;
#1571 CDFnodedim = (CDFnode*)nclistget(var->array.dimset0,i);
#1574 snprintf(tmp,sizeof(tmp),"%lu",(unsigned long)dim->dim.declsize);
#1672    sqdim->dim.declsize = count;
#1673    sqdim->dim.declsize0 = count;
#1674    sqdim->dim.array = seq;
#1837 CDFnodedim = (CDFnode*)nclistget(node->array.dimset0,j);
#1838 if(DIMFLAG(dim,CDFDIMSTRING)) {
#1933     CDFnodedim = (CDFnode*)nclistget(dimensions,i);
#1934     total *= dim->dim.declsize;
#2150     CDFnodedim = (CDFnode*)nclistget(ncdims,j);
#2151     if(dim->dim.declsize == 0) {
ncgen.h#213        Diminfo   dim;
ncgeny.c#2113 (yyvsp[(1) - (3)].sym)->dim.declsize = (size_t)extractint((yyvsp[(3) - (3)].constant));
#2115fprintf(stderr,"dimension: %s = %llu\n",(yyvsp[(1) - (3)].sym)->name,(unsigned long long)(yyvsp[(1) - (3)].sym)->dim.declsize);
#2123         (yyvsp[(1) - (3)].sym)->dim.declsize = NC_UNLIMITED;
#2124         (yyvsp[(1) - (3)].sym)->dim.isunlimited = 1;
#2331      (yyval.sym)->dim.isconstant = 1;
#2332      (yyval.sym)->dim.declsize = uint32_val;
#2348      (yyval.sym)->dim.isconstant = 1;
#2349      (yyval.sym)->dim.declsize = int32_val;
nciter.c#187    int dim;
#202    for(dim = 0; dim < ndimsdim++) {
#204 NC_CHECK(nc_inq_dimlen(nciddimids[dim], &len));
#206 iterp->dimsizes[dim] = len;
oc.c#600            OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#601     dims[i] = (OCobject)dim;
#654    OCnodedim;
#656    OCDEREF(OCnode*,dim,ddsnode);
#658    if(dim->octype != OC_Dimension) return OCTHROW(OCTHROW(OC_EBADTYPE));
#659    if(sizep) *sizep = dim->dim.declsize;
#660    if(namep) *namep = nulldup(dim->name);
#690            OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#691     dimsizes[i] = dim->dim.declsize;
ocdump.c#193        OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#195 (dim->name?dim->name:"?"),
#196 (unsigned long)dim->dim.declsize);
ocnode.c#26 if(node->octype == OC_Dimension && node->dim.array != NULL) {
#27     node->container = node->dim.array->container;
#36 OCnodedim = (OCnode*)oclistget(node->array.dimensions,j);
#37 node->array.sizes[j] = dim->dim.declsize;
ocnode.h#53    OCdiminfo       dim;       /* octype == OC_Dimension*/
ocutil.c#67     OCnodedim = (OCnode*)oclistget(node->array.dimensions,j);
#68     oclistpush(dims,(void*)dim);
odom.c#28 odom->declsize[i] = dimset->dimsyms[i]->dim.declsize;
semantics.c#697     if(vsym->typ.dimset.dimsyms[j]->dim.declsize == NC_UNLIMITED) {
#1090    ASSERT(thisunlim->dim.isunlimited);
#1105(unsigned long)thisunlim->dim.declsize,
#1109 if(thisunlim->dim.declsize < unlimsize) /* want max length of the unlimited*/
#1110            thisunlim->dim.declsize = unlimsize;
#1149(unsigned long)thisunlim->dim.declsize,
#1153 if(thisunlim->dim.declsize < unlimsize) /* want max length of the unlimited*/
#1154            thisunlim->dim.declsize = unlimsize;
#1164 Symboldim = (Symbol*)listget(dimdefs,i);
#1165 if(dim->dim.isunlimited)
#1166     dim->dim.declsize = 0;
#1196 Symboldim = (Symbol*)listget(dimdefs,i);
#1197 if(dim->dim.isunlimited)
#1199     dim->name,
#1200             (unsigned long)dim->dim.declsize);
tst_fillbug.c#126     int dimrecdim;
#130     for (dim = 0; dim < ndims && is_recvar == 0; dim++) {
#132     if(dimids[dim] == recdimids[recdim]) {
tst_h_dimscales.c#19herr_t alien_visitor(hid_t did, unsigned dimhid_t dsid,
tst_h_dimscales2.c#23herr_t alien_visitor(hid_t did, unsigned dimhid_t dsid,
#45herr_t alien_visitor2(hid_t did, unsigned dimhid_t dsid, void *visitor_data)
tst_h_dimscales3.c#26herr_t alien_visitor(hid_t did, unsigned dimhid_t dsid,
#48herr_t alien_visitor2(hid_t did, unsigned dimhid_t dsid, void *visitor_data)
tst_h_dimscales4.c#36herr_t alien_visitor(hid_t did, unsigned dimhid_t dsid,
tst_nofill.c#418    int ndims, *dimidsdim;
#428    for(dim = 0; dim < ndimsdim++) {
#430        if (nc_inq_dimlen(ncid1dimids[dim], &len)) ERR;
util.c#217 Symboldim = dimset->dimsyms[i];
#218 if(dim->dim.declsize == NC_UNLIMITED) return 1;
#227   return (dimset->ndims > 0 && dimset->dimsyms[0]->dim.declsize == NC_UNLIMITED);
#239 Symboldim = dimset->dimsyms[i];
#240 if(dim->dim.declsize == NC_UNLIMITEDlast = i;
#251 Symboldim = dimset->dimsyms[i];
#252 if(dim->dim.declsize == NC_UNLIMITED) return 0;
#596 totalsize = totalsize * dimset->dimsyms[i]->dim.declsize;
#648 if(dimset->dimsyms[start]->dim.isunlimited)
#664 if(dimset->dimsyms[i]->dim.isunlimited)
#678 if(dimset->dimsyms[i]->dim.isunlimited)
util.h#67#define isunlimited(dimset,i) ((dimset)->dimsyms[i]->dim.isunlimited)
#68#define declsizefor(dimset,i) ((dimset)->dimsyms[i]->dim.declsize)
utils.c#192 int dimrecdim;
#198 for (dim = 0; dim < ndims && is_recvar == 0; dim++) {
#200 if(dimids[dim] == recdimids[recdim]) {
varget.c#85 int dim = test.vars[iv].dims[mqv] ;
#88 hc.cor[mqv] = test.dims[dim].size; /* try big coordinate, should fail */
#95 hc.edg[mqv] = test.dims[dim].size + 1; /* try big edge, should fail */
varput.c#89 int dim = test.vars[iv].dims[mqv] ;
#92 hc.cor[mqv] = test.dims[dim].size; /* try big coordinate, should fail */
#100 hc.edg[mqv] = test.dims[dim].size + 1; /* try big edge, should fail */


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