add.c#87 if (test->atts[ia].var == varid &&
#96    test->atts[test->natts].var = varid;
#132 if (test->atts[ia].var == varid &&
#136 test->atts[ib-1].var =   test->atts[ib].var;
atttests.c#196 tmp.var = atts[ia].var;
#276 tmp.var = atts[ia].var;
#365 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#411 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#508 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#524 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#533   cdfidtest.vars[test.atts[ia].var].name,
#551 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#569 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#578   cdfidtest.vars[test.atts[ia].var].name,
#944 while (ib < test.natts && test.atts[ib].var != NC_GLOBAL)
#967     while (ib < test.natts && test.atts[ib].var != iv)
#1014 while (ib < test.natts && test.atts[ib].var != NC_GLOBAL)
#1037     while (ib < test.natts && test.atts[ib].var != iv)
bm_many_objs.c#30    int vvarnumvarvnvleftnvars;
#51 if (nc_def_var(grp, "var", NC_INT, 0, NULL, &var)) ERR;
#53 if(nc_put_var(grpvardata)) ERR;
#81     int var;
#84     if(nc_def_var(grpvnameNC_INT, 0, NULL, &var)) ERR;
#85     if(nc_put_var(grpvardata)) ERR;
bm_netcdf4_recs.c#31    int vvarnumvarvnvleftnvars;
cache.c#40            CDFnodevar = (CDFnode*)nclistget(cachenode->vars,i);
#41     if(var == target) {
#59            CDFnodevar = (CDFnode*)nclistget(cachenode->vars,j);
#60            if(var == target) {found=1;index=i;break;}
#118            CDFnodevar = (CDFnode*)nclistget(allvars,i);
#121     if(!var->basenode->prefetchable)
#127     if(nclistcontains(nccomm->cdf.projectedvars,(void*)var))
#131     nclistpush(vars,(void*)var);
#133nclog(NCLOGDBG,"prefetch: %s",var->ncfullname);
#154        CDFnodevar = (CDFnode*)nclistget(vars,i);
#157 ncstat = dapvar2projection(var,&varprojection);
#189CDFnodevar = (CDFnode*)nclistget(vars,i);
#191s = makecdfpathstring(var,".");
#371    for(i=0;i<nclistlength(proj->var->segments);i++) {
#372        DCEsegmentsegment = (DCEsegment*)nclistget(proj->var->segments,i);
#406 CDFnodevar = (CDFnode*)nclistget(allvars,i);
#410 if(var->nctype != NC_Atomic)
#414        if(dapinsequence(var))
#418        for(nelems=1,j=0;j<nclistlength(var->array.dimsettrans);j++) {
#419            CDFnodedim = (CDFnode*)nclistget(var->array.dimsettrans,j);
#424          var->prefetchable = 1;
#428              char *tmp = ocfqn(var->ocnode);
cdf.c#231 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#232 nullfree(var->ncfullname);
#233 var->ncfullname = makecdfpathstring(var,nccomm->cdf.separator);
#236 var->ocname,var->ncbasename,var->ncfullname);
#247     CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#253         if(strcmp(var->ncfullname,testnode->ncfullname) != 0)
#256 != nclistlength(var->array.dimsetall))
#259     CDFnodevdim = (CDFnode*)nclistget(var->array.dimsetall,d);
#267     testnode->array.basevar = var;
#268fprintf(stderr,"basevar invoked: %s\n",var->ncfullname);
#713clonedim(NCDAPCOMMONnccommCDFnodedimCDFnodevar)
#722    clone->dim.array = var;
#727clonedimset(NCDAPCOMMONnccommNClistdimsetCDFnodevar)
#738        nclistpush(result,(void*)clonedim(nccomm,dim,var));
cdftests.c#287    aa_units.var = aa_id;
#288    if (ncattput(ncidaa_units.varaa_units.name,
constraints.c#68 ncstat = matchpartialname(nodes,proj->var->segments,&cdfmatch);
#72 proj->var->annotation = (void*)cdfmatch;
#118            && proj->var->annotation != NULL
#119            && ((CDFnode*)proj->var->annotation)->ocnode != NULL));
#120    collectnodepath((CDFnode*)proj->var->annotation,fullpath,!WITHDATASET);
#126    completesegments(fullpath,proj->var->segments);
#146    for(i=0;i<nclistlength(proj->var->segments);i++) {
#147        DCEsegmentseg = (DCEsegment*)nclistget(proj->var->segments,i);
#382dapbuildvaraprojection(CDFnodevar,
#398    ncstat = dapvar2projection(var,&projection);
#407    segments = projection->var->segments;
#488    for(i=0;i<nclistlength(proj->var->segments);i++) {
#489        DCEsegmentsegment = (DCEsegment*)nclistget(proj->var->segments,i);
#548     if(p1->var->annotation != p2->var->annotation) continue;
#550     if(!slicematch(p1->var->segments,p2->var->segments)) {
#565 if(!iscontainer((CDFnode*)p1->var->annotation))
#572     collectnodepath((CDFnode*)p2->var->annotation,tmp,WITHDATASET);
#575         if(candidate == p1->var->annotation) {
#594            leaf = (CDFnode*)target->var->annotation;
#606     CDFnodeleaf = (CDFnode*)container->var->annotation;
#646    DCEvarvar  = (DCEvar*)dcecreate(CES_VAR);
#649    proj->var = var;
#650    var->annotation = (void*)field;
#652    var->segments = dceclonelist(container->var->segments);
#654    nclistpush(var->segments,(void*)seg);
#689dapvar2projection(CDFnodevarDCEprojection** projectionp)
#699    collectnodepath(var,path,!WITHDATASET);
#732    projection->var = (DCEvar*)dcecreate(CES_VAR);
#733    projection->var->annotation = (void*)var;
#734    projection->var->segments = segments;
#754daprestrictprojection(NClistprojectionsDCEprojectionvarDCEprojection** resultp)
#762 dumpprojection(var));
#765    ASSERT(var != NULL);
#771 if(p1->var->annotation == var->var->annotation) {
#777 result = (DCEprojection*)dceclone((DCEnode*)var); /* use only the var projection */
#784 dumpprojection(result),dumpprojection(var));
#789    ncstat = dcemergeprojections(result,var); /* result will be modified */
#825    segments = projection->var->segments;
#864 node = (CDFnode*)proj->var->annotation;
constraints.h#26extern int dapvar2projection(CDFnodevarDCEprojection** projectionp);
#27extern int daprestrictprojection(NClistprojectionsDCEprojectionvarDCEprojection** resultp);
dapdebug.h#50#define MEMCHECK(var,throw) {if((var)==NULL) return (throw);}
dapdump.c#96 Varvar = &hdr->vars[i];
#98 var->varid = i;
#100                   var->varid,
#101                   var->name,
#103   &var->ndims,
#104   var->dimids,
#105                   &var->natts);
#107 var->nctype = (nctype);
#110 var->name,
#111 nctypetostring(var->nctype),
#112 var->ndims);
#114 for(j=0;j<var->ndims;j++) {
#115     fprintf(stdout," %d",var->dimids[j]);
#118 var->atts = (NCattribute*)malloc(var->natts*sizeof(NCattribute));
#119        MEMCHECK(var->atts,NC_ENOMEM);
#120        for(j=0;j<var->natts;j++) {
#121     NCattributeatt = &var->atts[j];
#127            stat = nc_inq_attname(hdr->ncid,var->varid,j,attname);
#130     stat = nc_inq_att(hdr->ncid,var->varid,att->name,&nctype,&nvalues);
#136     stat = nc_get_att(hdr->ncid,var->varid,att->name,values);
#522 CDFnodevar = (CDFnode*)nclistget(node->vars,i);
#524 ncbytescat(buf,makecdfpathstring(var,"."));
daputil.c#448makecdfpathstring(CDFnodevar, const char* separator)
#452    collectnodepath(var,path,WITHDATASET); /* <= note */
dceconstraints.c#266     if(dcesamepath(target->var->segments,
#267    p2->var->segments)!=0) continue;
#289    ASSERT((nclistlength(merged->var->segments) == nclistlength(addition->var->segments)));
#290    for(i=0;i<nclistlength(merged->var->segments);i++) {
#291 DCEsegmentmergedseg = (DCEsegment*)nclistget(merged->var->segments,i);
#292 DCEsegmentaddedseg = (DCEsegment*)nclistget(addition->var->segments,i);
#399     clone->var = (DCEvar*)dceclone((DCEnode*)orig->var); break;
#412            clone->var = (DCEvar*)dceclone((DCEnode*)orig->var); break;
#486        case CES_VARdcefree((DCEnode*)target->var); break;
#495 case CES_VARdcefree((DCEnode*)target->var); break;
#651 DCEvarvar = (DCEvar*)node;
#652 dcelisttobuffer(var->segments,buf,".");
#688         dcetobuffer((DCEnode*)value->var,buf);
#701     dcetobuffer((DCEnode*)target->var,buf);
#791 DCEvarvar = (DCEvar*)node;
#792 for(i=0;i<nclistlength(var->segments);i++) {
#793     ceallnodesr((DCEnode*)nclistget(var->segments,i),allnodes,which);
#799     ceallnodesr((DCEnode*)value->var,allnodes,which);
#814     ceallnodesr((DCEnode*)projection->var,allnodes,which);
#947    if(p->discrim == CES_VAR && p->var != NULL && p->var->segments != NULL) {
#948        int lastindex = nclistlength(p->var->segments) - 1;
#949        DCEsegmentlastseg = (DCEsegment*)nclistget(p->var->segments,lastindex);
#1092 DCEvarvar = (DCEvar*)node;
#1094 dcedumprawlist(var->segments,buf);
#1137         dcedumpraw((DCEnode*)value->var,buf);
#1152     dcedumpraw((DCEnode*)target->var,buf);
dceconstraints.h#66    DCEvarvar;
#81    DCEvarvar;
dceparse.c#68 p->var = varorfcn;
#261    case CES_VARncvalue->var = (DCEvar*)val; break;
#271var(DCEparsestatestateObject indexpath)
dceparselex.h#82extern Object var(DCEparsestatestateObject indexpath);
dcetab.c#1458    {(yyval)=var(parsestate,(yyvsp[0]));}
debug.h#58#define MEMCHECK(var,throw) {if((var)==NULL) return (throw);}
genbin.c#22static void genbin_definespecialattributes(Symbolvar);
#133            Symbolvar = (Symbol*)listget(vardefs,ivar);
#134     genbin_definespecialattributes(var);
#199genbin_definespecialattributes(Symbolvar)
#202    Specialdataspecial = &var->var.special;
#207        stat = nc_def_var_chunking(var->container->ncid,
#208                                   var->ncid,
#215        stat = nc_def_var_fletcher32(var->container->ncid,
#216                                     var->ncid,
#221        stat = nc_def_var_deflate(var->container->ncid,
#222                                  var->ncid,
#230        stat = nc_def_var_endian(var->container->ncid,
#231                                 var->ncid,
#238        stat = nc_def_var_fill(var->container->ncid,
#239                                 var->ncid,
#440    varid = (asym->att.var == NULL?NC_GLOBAL : asym->att.var->ncid);
genc.c#97            Symbolvar = (Symbol*)listget(vardefs,ivar);
#98            Specialdataspecial = &var->var.special;
#109                            cname(var),special->nchunks);
#436    Specialdataspecial = &vsym->var.special;
#1128 (asym->att.var == NULL?"NC_GLOBAL"
#1129               :varncid(asym->att.var)),
#1143 (asym->att.var == NULL?"NC_GLOBAL"
#1144               :varncid(asym->att.var)),
#1165 (asym->att.var == NULL?"NC_GLOBAL"
#1166               :varncid(asym->att.var)),
#1184 (asym->att.var == NULL?"NC_GLOBAL"
#1185               :varncid(asym->att.var)),
#1203 (asym->att.var == NULL?"NC_GLOBAL"
#1204               :varncid(asym->att.var)),
genf77.c#874 (asym->att.var == NULL?"NF_GLOBAL"
#875       :f77varncid(asym->att.var)),
#888 (asym->att.var == NULL?"NF_GLOBAL"
#889       :f77varncid(asym->att.var)),
genj.c#567 if(asym->att.var == NULL) {
#573 jescapifyname(asym->att.var->name),
#582 if(asym->att.var == NULL) {
#590 jescapifyname(asym->att.var->name),
genlib.c#67 varid = (atts[iatt].var == -1) ? NC_GLOBAL : atts[iatt].var;
#308     atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname,
#401 atts[iatt].var == -1 ? "NC_GLOBAL" : vars[atts[iatt].var].lname,
#402 atts[iatt].var == -1 ? "" : "_id",
#413     atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname,
#424 atts[iatt].var == -1 ? "NC_GLOBAL" : vars[atts[iatt].var].lname,
#425 atts[iatt].var == -1 ? "" : "_id",
#429 atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname,
#803 atts[iatt].var == -1 ? "NF_GLOBAL" : vars[atts[iatt].var].lname,
#804 atts[iatt].var == -1 ? "" : "_id",
#825 atts[iatt].var == -1 ? "NCGLOBAL" : vars[atts[iatt].var].lname,
#826 atts[iatt].var == -1 ? "" : "_id",
getfill.c#30        filler = tvsym->var.special._Fillvalue; /* get cached value (if any)*/
#43        tvsym->var.special._Fillvalue = filler;
getvara.c#436    for(i=0;i<nclistlength(proj->var->segments);i++) {
#437 DCEsegmentseg = (DCEsegment*)nclistget(proj->var->segments,i);
#472                     xgetvar->varaprojection->var->segments);
#993makegetvar(NCDAPCOMMONnccommCDFnodevar, void* datanc_type dsttypeGetvara** getvarp)
#1004       getvar->target = var;
#1216    NC_varvar;
#1238    var = NC_lookupvar(substrate3,varid);
#1239    if(var == NULL) {ncstat = NC_ENOTVAR; goto done;}
#1254    ASSERT((strcmp(cdfvar->ncfullname,var->name->cp)==0));
nc4attr.c#216   NC_VAR_INFO_T *var = NULL;
#264     for (var = grp->varvarvar = var->l.next)
#265       if (var->varid == varid)
#267           attlist = &var->att;
#270     if (!var)
#371      if (att->nc_typeid != var->type_info->nc_typeid)
#377      if (var->written_to)
#382      if ((retval = nc4_get_typelen_mem(grp->nc4_infovar->type_info->nc_typeid, 0,
#388      if (var->fill_value)
#390          if (var->type_info->nc_type_class == NC_VLEN)
#392              if ((retval = nc_free_vlen(var->fill_value)))
#395          else if (var->type_info->nc_type_class == NC_STRING)
#397              if (*(char **)var->fill_value)
#398                free(*(char **)var->fill_value);
#400          free(var->fill_value);
#404      if (var->type_info->nc_type_class == NC_VLEN)
#406      else if (var->type_info->nc_type_class == NC_STRING)
#411      if (!(var->fill_value = calloc(1, size)))
#415      LOG((4, "Copying fill value into metadata for variable %s", var->name));
#416      if (var->type_info->nc_type_class == NC_VLEN)
#418          nc_vlen_t *in_vlen = (nc_vlen_t *)data, *fv_vlen = (nc_vlen_t *)(var->fill_value);
#425      else if (var->type_info->nc_type_class == NC_STRING)
#429              if (!(*(char **)(var->fill_value) = malloc(strlen(*(char **)data) + 1)))
#431              strcpy(*(char **)var->fill_value, *(char **)data);
#434            *(char **)var->fill_value = NULL;
#437        memcpy(var->fill_valuedatatype_size);
#441      if (var->created)
#442         var->fill_val_changed = NC_TRUE;
#532   if(var)
#533       var->attr_dirty = NC_TRUE;
#632   NC_VAR_INFO_T *var = NULL;
#669      for (var = grp->varvarvar = var->l.next)
#670  if (var->varid == varid)
#672     list = var->att;
#675      if (!var)
#723   if(var)
#724       var->attr_dirty = NC_TRUE;
#741   NC_VAR_INFO_T *var;
#780      for(var = grp->varvarvar = var->l.next)
#782  if (var->varid == varid)
#784     attlist = &var->att;
#788      if (!var)
#790      if (var->created)
#791  locid = var->hdf_datasetid;
nc4dim.c#319      NC_VAR_INFO_T *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)))
nc4file.c#687read_coord_dimids(NC_GRP_INFO_T *grpNC_VAR_INFO_T *var)
#697   if ((coord_attid = H5Aopen_name(var->hdf_datasetidCOORDINATES)) < 0) ret++;
#709   if (!ret && npoints != var->ndimsret++;
#711   if (!ret && H5Aread(coord_attidcoord_att_typeidvar->dimids) < 0) ret++;
#712   LOG((4, "dimscale %s is multidimensional and has coords", var->name));
#715   for (d = 0; d < var->ndimsd++) {
#717     nc4_find_dim(grpvar->dimids[d], &var->dim[d], NULL);
#1509   NC_VAR_INFO_T *var = NULL;
#1537   if ((retval = nc4_var_list_add(&grp->var, &var)))
#1541   var->hdf_datasetid = datasetid;
#1542   H5Iinc_ref(var->hdf_datasetid);      /* Increment number of objects using ID */
#1544   var->varid = grp->nvars++;
#1545   var->created = NC_TRUE;
#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))))
#1566   if ((H5Pget_chunk_cache(access_pid, &(var->chunk_cache_nelems),
#1567    &(var->chunk_cache_size), &rdcc_w0)) < 0)
#1569   var->chunk_cache_preemption = rdcc_w0;
#1578      if (!(var->name = malloc(((strlen(obj_name) - strlen(NON_COORD_PREPEND))+ 1) * sizeof(char))))
#1581      strcpy(var->name, &obj_name[strlen(NON_COORD_PREPEND)]);
#1584      if (!(var->hdf5_name = malloc((strlen(obj_name) + 1) * sizeof(char))))
#1587      strcpy(var->hdf5_nameobj_name);
#1592      if (!(var->name = malloc((strlen(obj_name) + 1) * sizeof(char))))
#1595      strcpy(var->nameobj_name);
#1598   var->hash = hash_fast(var->name, strlen(var->name));
#1615      if (!(var->chunksizes = malloc(var->ndims * sizeof(size_t))))
#1617      for (d = 0; d < var->ndimsd++)
#1618         var->chunksizes[d] = chunksize[d];
#1621      var->contiguous = NC_TRUE;
#1635            var->shuffle = NC_TRUE;
#1639            var->fletcher32 = NC_TRUE;
#1643            var->deflate = NC_TRUE;
#1646            var->deflate_level = cd_values[0];
#1650            var->szip = NC_TRUE;
#1653     var->options_mask = cd_values[0];
#1654            var->pixels_per_block = cd_values[1];
#1665 &var->type_info)))
#1669   var->type_info->rc++;
#1679      if (!var->fill_value)
#1681  if (var->type_info->nc_type_class == NC_VLEN)
#1683     if (!(var->fill_value = malloc(sizeof(nc_vlen_t))))
#1686  else if (var->type_info->nc_type_class == NC_STRING)
#1688     if (!(var->fill_value = malloc(sizeof(char *))))
#1693            assert(var->type_info->size);
#1694     if (!(var->fill_value = malloc(var->type_info->size)))
#1700      if (H5Pget_fill_value(propidvar->type_info->native_hdf_typeid,
#1701     var->fill_value) < 0)
#1705      var->no_fill = NC_TRUE;
#1711      var->dimscale = NC_TRUE;
#1712      if (var->ndims > 1)
#1714  if ((retval = read_coord_dimids(grpvar)))
#1720         assert(0 == strcmp(var->namedim->name));
#1722         var->dimids[0] = dim->dimid;
#1723  var->dim[0] = dim;
#1725      dim->coord_var = var;
#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++)
#1754            if (H5DSiterate_scales(var->hdf_datasetiddNULLdimscale_visitor,
#1755                                   &(var->dimscale_hdf5_objids[d])) < 0)
#1757            var->dimscale_attached[d] = NC_TRUE;
#1764   if ((natts = H5Aget_num_attrs(var->hdf_datasetid)) < 0)
#1775      if ((attid = H5Aopen_idx(var->hdf_datasetid, (unsigned int)a)) < 0)
#1787  if ((retval = nc4_att_list_add(&var->att, &att)))
#1791  att->attnum = var->natts++;
#1801                if ((retval = nc4_att_list_del(&var->attatt)))
#1815   if ((retval = nc4_adjust_var_cache(grpvar)))
#1823       if (var && nc4_var_list_del(&grp->varvar))
#2579      NC_VAR_INFO_T *var;
#2594      if ((retval = nc4_var_list_add(&grp->var, &var)))
#2597      var->varid = grp->nvars++;
#2598      var->created = NC_TRUE;
#2599      var->written_to = NC_TRUE;
#2602      if ((var->sdsid = SDselect(h5->sdidv)) == FAIL)
#2606      if (!(var->name = malloc(NC_MAX_HDF4_NAME + 1)))
#2610      if (SDgetinfo(var->sdsidvar->name, &rankNULL, &data_type, &num_atts))
#2613      var->hash = hash_fast(var->name, strlen(var->name));
#2618      if (SDgetinfo(var->sdsidvar->name, &rankdimsize, &data_type, &num_atts)) {
#2623      var->ndims = rank;
#2624      var->hdf4_data_type = data_type;
#2627      if (!(var->type_info = calloc(1, sizeof(NC_TYPE_INFO_T)))) {
#2632      if ((retval = get_netcdf_type_from_hdf4(h5data_type, &var->type_info->nc_typeidvar->type_info))) {
#2638      var->type_info->rc++;
#2640      if ((retval = nc4_get_typelen_mem(h5var->type_info->nc_typeid, 0, &var_type_size))) {
#2645      var->type_info->size = var_type_size;
#2646      LOG((3, "reading HDF4 dataset %s, rank %d netCDF type %d", var->name,
#2647    rankvar->type_info->nc_typeid));
#2650      if (!(var->fill_value = malloc(var_type_size))) {
#2655      if (SDgetfillvalue(var->sdsidvar->fill_value))
#2658  free(var->fill_value);
#2659  var->fill_value = NULL;
#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++)
#2684  if ((dimid = SDgetdimid(var->sdsidd)) == FAIL) {
#2705  dim_namevar->name));
#2722  var->dimids[d] = dim->dimid;
#2723  var->dim[d] = dim;
#2733         if ((retval = nc4_att_list_add(&var->att, &att))) {
#2737  att->attnum = var->natts++;
#2745  if (SDattrinfo(var->sdsidaatt->name, &att_data_type, &att_count)) {
#2768  if (SDreadattr(var->sdsidaatt->data)) {
#2779        if(!SDgetchunkinfo(var->sdsid, &chunkdefs, &flag)) {
#2781 var->contiguous = NC_TRUE;
#2783 var->contiguous = NC_FALSE;
#2784 if (!(var->chunksizes = malloc(var->ndims * sizeof(size_t))))
#2786         for (d = 0; d < var->ndimsd++) {
#2787     var->chunksizes[d] = chunkdefs.chunk_lengths[d];
#3208   NC_VAR_INFO_T *var;
#3229      for (var = grp->varvarvarvar->l.next)
nc4grp.c#392   NC_VAR_INFO_T *var;
#416      if (grp->var)
#418  for (var = grp->varvarvar = var->l.next)
#421        varids[num_vars] = var->varid;
nc4hdf.c#70  NC_VAR_INFO_T *var;
#84  for (var = grp->varvarvar = var->l.next)
#85    for (d = 0; d < var->ndimsd++)
#86      if (var->dimids[d] == dimid && !var->dimscale)
#89               __func__var->dimids[d], var->name));
#90          if (var->created)
#92              if (H5DSattach_scale(var->hdf_datasetiddimscaleidd) < 0)
#94              var->dimscale_attached[d] = NC_TRUE;
#110  NC_VAR_INFO_T *var;
#124  for (var = grp->varvarvar = var->l.next)
#125    for (d = 0; d < var->ndimsd++)
#126      if (var->dimids[d] == dimid && !var->dimscale)
#129               __func__var->dimids[d], var->name));
#130          if (var->created)
#131            if (var->dimscale_attached && var->dimscale_attached[d])
#133                if (H5DSdetach_scale(var->hdf_datasetiddimscaleidd) < 0)
#135                var->dimscale_attached[d] = NC_FALSE;
#146  NC_VAR_INFO_T *var;
#149  for (var = grp->varvarvar = var->l.next)
#150    if (var->varid == varid)
#152  if (!var)
#156  if (!var->hdf_datasetid)
#157    if ((var->hdf_datasetid = H5Dopen2(grp->hdf_grpidvar->name,
#161  *dataset = var->hdf_datasetid;
#230get_fill_value(NC_HDF5_FILE_INFO_T *h5NC_VAR_INFO_T *var, void **fillp)
#236  if (var->type_info->nc_type_class == NC_VLEN)
#238  else if (var->type_info->nc_type_class == NC_STRING)
#242      if ((retval = nc4_get_typelen_mem(h5var->type_info->nc_typeid, 0, &size)))
#253  if (var->fill_value)
#255      LOG((4, "Found a fill value for var %s", var->name));
#256      if (var->type_info->nc_type_class == NC_VLEN)
#258          nc_vlen_t *in_vlen = (nc_vlen_t *)(var->fill_value), *fv_vlen = (nc_vlen_t *)(*fillp);
#269      else if (var->type_info->nc_type_class == NC_STRING)
#271          if (*(char **)var->fill_value)
#272            if (!(**(char ***)fillp = strdup(*(char **)var->fill_value)))
#280        memcpy((*fillp), var->fill_valuesize);
#284      if (nc4_get_default_fill_value(var->type_info, *fillp))
#465check_for_vara(nc_type *mem_nc_typeNC_VAR_INFO_T *varNC_HDF5_FILE_INFO_T *h5)
#473    *mem_nc_type = var->type_info->nc_typeid;
#477  if (var->type_info->nc_typeid != *mem_nc_type &&
#478      (var->type_info->nc_typeid == NC_CHAR || *mem_nc_type == NC_CHAR))
#496log_dim_info(NC_VAR_INFO_T *varhsize_t *fdimshsize_t *fmaxdims,
#502  LOG((4, "%s: var name %s ndims %d", __func__var->namevar->ndims));
#504  for (d2 = 0; d2 < var->ndimsd2++)
#515set_par_access(NC_HDF5_FILE_INFO_T *h5NC_VAR_INFO_T *varhid_t xfer_plistid)
#525      hdf5_xfer_mode = (var->parallel_access != NC_INDEPENDENT) ?
#550  NC_VAR_INFO_T *var;
#570  if ((retval = nc4_find_g_var_nc(ncncidvarid, &grp, &var)))
#573  assert(grp && h5 && var && var->name);
#576       __func__var->namemem_nc_typeis_long));
#580  if ((retval = check_for_vara(&mem_nc_typevarh5)))
#584  for (i = 0; i < var->ndimsi++)
#593  if (var->hdf5_name && strlen(var->hdf5_name) >= strlen(NON_COORD_PREPEND) &&
#594      strncmp(var->hdf5_nameNON_COORD_PREPEND, strlen(NON_COORD_PREPEND)) == 0 &&
#595      var->ndims)
#596    name_to_use = var->hdf5_name;
#598    name_to_use = var->name;
#599  if (!var->hdf_datasetid)
#600    if ((var->hdf_datasetid = H5Dopen2(grp->hdf_grpidname_to_useH5P_DEFAULT)) < 0)
#604  if ((file_spaceid = H5Dget_space(var->hdf_datasetid)) < 0)
#617  log_dim_info(varfdimsfmaxdimsstartcount);
#622  for (d2 = 0; d2 < var->ndimsd2++)
#624      dim = var->dim[d2];
#625      assert(dim && dim->dimid == var->dimids[d2]);
#656      if ((mem_spaceid = H5Screate_simple(var->ndimscountNULL)) < 0)
#666  if ((mem_nc_type != var->type_info->nc_typeid || (var->type_info->nc_typeid == NC_INT && is_long)) &&
#673      if (var->ndims)
#674        for (d2=0; d2<var->ndimsd2++)
#676      LOG((4, "converting data for var %s type=%d len=%d", var->name,
#677           var->type_info->nc_typeidlen));
#681      assert(var->type_info->size);
#682      file_type_size = var->type_info->size;
#698                                   var->type_info->endianness)))
#719  if ((retval = set_par_access(h5varxfer_plistid)))
#727  if (var->ndims)
#729      for (d2 = 0; d2 < var->ndimsd2++)
#731          dim = var->dim[d2];
#732   assert(dim && dim->dimid == var->dimids[d2]);
#757      if (h5->parallel && NC_COLLECTIVE == var->parallel_access)
#775              if(NC_COLLECTIVE != var->parallel_access)
#779              if(MPI_SUCCESS != MPI_Allreduce(MPI_IN_PLACExtend_sizevar->ndimsMPI_UNSIGNED_LONG_LONGMPI_MAXh5->comm))
#784          for (d2 = 0; d2 < var->ndimsd2++)
#787          if (H5Dset_extent(var->hdf_datasetidfdims) < 0)
#791          if ((file_spaceid = H5Dget_space(var->hdf_datasetid)) < 0)
#806      if ((retval = nc4_convert_type(databufrmem_nc_typevar->type_info->nc_typeid,
#807                                     len, &range_errorvar->fill_value,
#815       "file_spaceid 0x%x", var->hdf_datasetidmem_spaceidfile_spaceid));
#816  if (H5Dwrite(var->hdf_datasetidvar->type_info->hdf_typeid,
#822  if (!var->written_to)
#823    var->written_to = NC_TRUE;
#828      (var->type_info->nc_typeid == NC_UBYTE || var->type_info->nc_typeid == NC_BYTE) &&
#872  NC_VAR_INFO_T *var;
#896  if ((retval = nc4_find_g_var_nc(ncncidvarid, &grp, &var)))
#899  assert(grp && h5 && var && var->name);
#902       __func__var->namemem_nc_typeis_long));
#905  if ((retval = check_for_vara(&mem_nc_typevarh5)))
#909  for (i = 0; i < var->ndimsi++)
#918  if (var->hdf5_name && strlen(var->hdf5_name) >= strlen(NON_COORD_PREPEND) &&
#919      strncmp(var->hdf5_nameNON_COORD_PREPEND, strlen(NON_COORD_PREPEND)) == 0 &&
#920      var->ndims)
#921    name_to_use = var->hdf5_name;
#923    name_to_use = var->name;
#924  if (!var->hdf_datasetid)
#925    if ((var->hdf_datasetid = H5Dopen2(grp->hdf_grpidname_to_useH5P_DEFAULT)) < 0)
#929  if ((file_spaceid = H5Dget_space(var->hdf_datasetid)) < 0)
#942  log_dim_info(varfdimsfmaxdimsstartcount);
#947  for (d2 = 0; d2 < var->ndimsd2++) {
#948    dim = var->dim[d2];
#949    assert(dim && dim->dimid == var->dimids[d2]);
#997  for (d2 = 0; d2 < var->ndimsd2++)
#1003  assert(var->type_info->size);
#1004  file_type_size = var->type_info->size;
#1028          if ((mem_spaceid = H5Screate_simple(var->ndimscountNULL)) < 0)
#1041      if(var->type_info->nc_type_class == NC_STRING &&
#1042         H5Tget_size(var->type_info->hdf_typeid) > 1 &&
#1043         !H5Tis_variable_str(var->type_info->hdf_typeid)) {
#1046        if ((fstring_len = H5Tget_size(var->type_info->hdf_typeid)) == 0)
#1056      if ((mem_nc_type != var->type_info->nc_typeid || (var->type_info->nc_typeid == NC_INT && is_long)) &&
#1061          if (var->ndims)
#1062            for (d2 = 0; d2 < var->ndimsd2++)
#1064          LOG((4, "converting data for var %s type=%d len=%d", var->name,
#1065               var->type_info->nc_typeidlen));
#1082                                       var->type_info->endianness)))
#1103      if ((retval = set_par_access(h5varxfer_plistid)))
#1109      if (H5Dread(var->hdf_datasetidvar->type_info->native_hdf_typeid,
#1121          if ((retval = nc4_convert_type(bufrdatavar->type_info->nc_typeidmem_nc_type,
#1122                                         len, &range_errorvar->fill_value,
#1129              (var->type_info->nc_typeid == NC_UBYTE || var->type_info->nc_typeid == NC_BYTE) &&
#1139          (var->type_info->nc_typeid == NC_UBYTE || var->type_info->nc_typeid == NC_BYTE) &&
#1151        if(var->parallel_access == NC_COLLECTIVE) {
#1160           if ((retval = set_par_access(h5varxfer_plistid)))
#1168           if((mem_spaceid = H5Dget_space(var->hdf_datasetid))<0)
#1178            if (H5Dread(var->hdf_datasetidvar->type_info->native_hdf_typeid,
#1195        for (real_data_size = file_type_sized2 = 0; d2 < var->ndimsd2++)
#1200      if (get_fill_value(h5var, &fillvalue) < 0)
#1204      for (fill_len = 1, d2 = 0; d2 < var->ndimsd2++)
#1212          if (var->type_info->nc_type_class == NC_STRING)
#1222          else if(var->type_info->nc_type_class == NC_VLEN) {
#1271      if (var->type_info->nc_type_class == NC_VLEN)
#1273      else if (var->type_info->nc_type_class == NC_STRING && *(char **)fillvalue)
#1449write_coord_dimids(NC_VAR_INFO_T *var)
#1456  coords_len[0] = var->ndims;
#1461  if (!ret && (c_attid = H5Acreate(var->hdf_datasetidCOORDINATESH5T_NATIVE_INT,
#1463  if (!ret && H5Awrite(c_attidH5T_NATIVE_INTvar->dimids) < 0) ret++;
#1521var_create_dataset(NC_GRP_INFO_T *grpNC_VAR_INFO_T *varnc_bool_t write_dimid)
#1533  LOG((3, "%s:: name %s", __func__var->name));
#1552  if ((retval = nc4_get_hdf_typeid(grp->nc4_infovar->type_info->nc_typeid, &typeid,
#1553                                   var->type_info->endianness)))
#1557  if (var->no_fill)
#1565      if ((retval = get_fill_value(grp->nc4_infovar, &fillp)))
#1571          if (var->type_info->nc_type_class == NC_STRING)
#1584              if ((retval = nc4_get_hdf_typeid(grp->nc4_infovar->type_info->nc_typeid, &fill_typeid,
#1600  if (var->shuffle)
#1605  if (var->deflate)
#1606    if (H5Pset_deflate(plistidvar->deflate_level) < 0)
#1617  if (var->fletcher32)
#1625  if (var->ndims)
#1630      for (d = 0; d < var->ndimsd++) {
#1631 dim = var->dim[d];
#1632 assert(dim && dim->dimid == var->dimids[d]);
#1641      if(!var->shuffle && !var->deflate && !var->options_mask &&
#1642         !var->fletcher32 && (var->chunksizes == NULL || !var->chunksizes[0])) {
#1649            var->contiguous = NC_TRUE;
#1653      for (d = 0; d < var->ndimsd++)
#1655          dim = var->dim[d];
#1656   assert(dim && dim->dimid == var->dimids[d]);
#1659          if (!var->contiguous) {
#1660            if (var->chunksizes[d])
#1661              chunksize[d] = var->chunksizes[d];
#1665                if (var->type_info->nc_type_class == NC_STRING)
#1668                  type_size = var->type_info->size;
#1675                                     1/(double)(var->ndims - unlimdim));
#1683                var->chunksizes[d] = chunksize[d];
#1688      if (var->contiguous)
#1695          if (H5Pset_chunk(plistidvar->ndimschunksize) < 0)
#1700      if ((spaceid = H5Screate_simple(var->ndimsdimsizemaxdimsize)) < 0)
#1721  if (!var->contiguous && var->chunk_cache_size)
#1722    if (H5Pset_chunk_cache(access_plistidvar->chunk_cache_nelems,
#1723                           var->chunk_cache_sizevar->chunk_cache_preemption) < 0)
#1727  name_to_use = var->hdf5_name ? var->hdf5_name : var->name;
#1730  if ((var->hdf_datasetid = H5Dcreate2(grp->hdf_grpidname_to_usetypeid,
#1733  var->created = NC_TRUE;
#1734  var->is_new_var = NC_FALSE;
#1739  if (var->dimscale)
#1741      if (H5DSset_scale(var->hdf_datasetidvar->name) < 0)
#1746      if (var->ndims > 1)
#1747        if ((retval = write_coord_dimids(var)))
#1752        if ((retval = write_netcdf4_dimid(var->hdf_datasetidvar->dimids[0])))
#1758  if ((retval = write_attlist(var->attvar->varidgrp)))
#1760  var->attr_dirty = NC_FALSE;
#1782      if (var->type_info->nc_type_class == NC_VLEN)
#1784      else if (var->type_info->nc_type_class == NC_STRING && *(char **)fillp)
#1794nc4_adjust_var_cache(NC_GRP_INFO_T *grpNC_VAR_INFO_T * var)
#1801  if (var->contiguous)
#1808  for (d = 0; d < var->ndimsd++)
#1809    chunk_size_bytes *= var->chunksizes[d];
#1810  if (var->type_info->size)
#1811    chunk_size_bytes *= var->type_info->size;
#1818  if (var->chunk_cache_size == CHUNK_CACHE_SIZE)
#1819    if (chunk_size_bytes > var->chunk_cache_size)
#1821        var->chunk_cache_size = chunk_size_bytes * DEFAULT_CHUNKS_IN_CACHE;
#1822        if (var->chunk_cache_size > MAX_DEFAULT_CACHE_SIZE)
#1823          var->chunk_cache_size = MAX_DEFAULT_CACHE_SIZE;
#1824        if ((retval = nc4_reopen_dataset(grpvar)))
#2055  NC_VAR_INFO_T *var;
#2062  for (var = grp->varvarvar = var->l.next)
#2066      if (var->dimscale)
#2075          for (d = 0; d < var->ndimsd++)
#2078              if (var->dimscale_attached)
#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])
#2146write_var(NC_VAR_INFO_T *varNC_GRP_INFO_T *grpnc_bool_t write_dimid)
#2151  LOG((4, "%s: writing var %s", __func__var->name));
#2155  if (var->created && var->fill_val_changed)
#2158      var->fill_val_changed = NC_FALSE;
#2167      flag_atts_dirty(&var->att);
#2174  if (var->became_coord_var)
#2179        if (!strcmp(d1->namevar->name))
#2183            if ((retval = var_exists(grp->hdf_grpidvar->name, &exists)))
#2189                flag_atts_dirty(&var->att);
#2207        if (!strcmp(d1->namevar->name))
#2211            if ((retval = var_exists(grp->hdf_grpidvar->name, &exists)))
#2228                                                var->dimids[0], dim_datasetid)))
#2236  if (var->was_coord_var && var->dimscale_attached)
#2242      if (var->created)
#2249          if ((attr_exists = H5Aexists(var->hdf_datasetid, "CLASS")) < 0)
#2253              if (H5Adelete(var->hdf_datasetid, "CLASS") < 0)
#2256          if ((attr_exists = H5Aexists(var->hdf_datasetid, "NAME")) < 0)
#2260              if (H5Adelete(var->hdf_datasetid, "NAME") < 0)
#2265      if (var->dimscale_attached)
#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;
#2295      if (var->hdf_datasetid && H5Dclose(var->hdf_datasetid) < 0)
#2297      var->hdf_datasetid = 0;
#2300      if (H5Gunlink(grp->hdf_grpidvar->name) < 0)
#2305  if (var->is_new_var || replace_existing_var)
#2307      if ((retval = var_create_dataset(grpvarwrite_dimid)))
#2312      if (write_dimid && var->ndims)
#2313        if ((retval = write_netcdf4_dimid(var->hdf_datasetidvar->dimids[0])))
#2321      if(var->dimscale)
#2324                                            var->dimids[0], var->hdf_datasetid)))
#2331          if (var->dimscale_attached)
#2332            memset(var->dimscale_attached, 0, sizeof(nc_bool_t) * var->ndims);
#2337  var->was_coord_var = NC_FALSE;
#2338  var->became_coord_var = NC_FALSE;
#2341  if (var->attr_dirty)
#2344      if ((retval = write_attlist(var->attvar->varidgrp)))
#2346      var->attr_dirty = NC_FALSE;
#2442      for (v1 = grp->varv1v1 = v1->l.next)
#2492  NC_VAR_INFO_T *var;
#2498  for (var = grp->varvarvar = var->l.next)
#2501      if (var->dimscale && var->ndims)
#2507          if (var->dimids[0] < last_dimid)
#2509              LOG((5, "%s: %s is out of order coord var", __func__var->name));
#2513          last_dimid = var->dimids[0];
#2518          if (var->ndims > 1)
#2520              LOG((5, "%s: %s is multidimensional coord var", __func__var->name));
#2528          if (var->is_new_var || var->became_coord_var)
#2553  NC_VAR_INFO_T *var;
#2567  var = grp->var;
#2572  while (dim || var)
#2594      for (wrote_coord = NC_FALSEvar && !wrote_coordvar = var->l.next)
#2596          if ((retval = write_var(vargrpbad_coord_order)))
#2598          if (found_coord && var->varid == coord_varid)
#3630  NC_VAR_INFO_T *var;
#3644  for (var = grp->varvarvar = var->l.next)
#3647      int ndims = var->ndims;
#3651   if (var->dim[d] == NULL) {
#3652     nc4_find_dim(grpvar->dimids[d], &var->dim[d], NULL);
#3658      if (!var->dimscale)
#3663          if (var->dimscale_hdf5_objids)
#3665              for (d = 0; d < var->ndimsd++)
#3669                  LOG((5, "%s: var %s has dimscale info...", __func__var->name));
#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])
#3683                              var->dimids[d] = dim->dimid;
#3684                              var->dim[d] = dim;
#3690                  LOG((5, "%s: dimid for this dimscale is %d", __func__var->type_info->nc_typeid));
#3701              if ((spaceid = H5Dget_space(var->hdf_datasetid)) < 0)
#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++)
#3763                      LOG((3, "%s: creating phony dim for var %s", __func__var->name));
#3784                  var->dimids[d] = dim->dimid;
#3785                  var->dim[d] = dim;
nc4internal.c#116   NC_VAR_INFO_T *var;
#124   for (var = grp->varvarvar = var->l.next)
#125      if (var->varid == varid)
#127   if (!var)
#131   if (!var->created)
#138     if ((retval = nc4_open_var_grp2(grpvar->varid, &datasetid)))
#148       *maxlen = (var->dimids && var->dimids[0] == dimid) ? 1 : 0;
#156       if (dataset_ndims != var->ndims)
#168  if (var->dimids[d] == dimid) {
#320   NC_GRP_INFO_T **grpNC_VAR_INFO_T **var)
#325   assert(grp && var && h5 && h5->root_grp);
#334   for ((*var) = (*grp)->var; (*var); (*var) = (*var)->l.next)
#335     if ((*var)->varid == varid)
#337   if (!(*var))
#376nc4_find_var(NC_GRP_INFO_T *grp, const char *nameNC_VAR_INFO_T **var)
#378   assert(grp && var && name);
#381   for ((*var) = grp->var; (*var); (*var) = (*var)->l.next)
#382      if (0 == strcmp(name, (*var)->name))
#499   NC_VAR_INFO_T *var;
#513   for (var = grp->varvarvar = var->l.next)
#518     if ((retval = find_var_dim_max_length(grpvar->variddimid, &mylen)))
#532   NC_VAR_INFO_T *var;
#544      for(var = grp->varvarvar = var->l.next)
#546  if (var->varid == varid)
#548     attlist = var->att;
#552      if (!var)
#578   NC_VAR_INFO_T *var;
#595      for(var = grp->varvarvar = var->l.next)
#597  if (var->varid == varid)
#599     attlist = var->att;
#603      if (!var)
#673nc4_var_list_add(NC_VAR_INFO_T **listNC_VAR_INFO_T **var)
#690   if (var)
#691      *var = new_var;
#778   NC_VAR_INFO_T *var;
#793   for (var = grp->varvarvar = var->l.next)
#794      if (var->hash == hash && !strcmp(var->namename))
#1007nc4_var_list_del(NC_VAR_INFO_T **listNC_VAR_INFO_T *var)
#1012   if(var == NULL)
#1016   obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)var);
#1019   att = var->att;
#1023      if ((ret = nc4_att_list_del(&var->attatt)))
#1029   if (var->chunksizes)
#1030     {free(var->chunksizes);var->chunksizes = NULL;}
#1032   if (var->hdf5_name)
#1033     {free(var->hdf5_name); var->hdf5_name = NULL;}
#1035   if (var->name)
#1036     {free(var->name); var->name = NULL;}
#1038   if (var->dimids)
#1039     {free(var->dimids); var->dimids = NULL;}
#1041   if (var->dim)
#1042     {free(var->dim); var->dim = NULL;}
#1046   if (var->fill_value)
#1048      if (var->hdf_datasetid)
#1050         if (var->type_info)
#1052            if (var->type_info->nc_type_class == NC_VLEN)
#1053               nc_free_vlen((nc_vlen_t *)var->fill_value);
#1054            else if (var->type_info->nc_type_class == NC_STRING && *(char **)var->fill_value)
#1055               free(*(char **)var->fill_value);
#1058      free(var->fill_value);
#1059      var->fill_value = NULL;
#1063   if (var->type_info)
#1067      if ((retval = nc4_type_free(var->type_info)))
#1069      var->type_info = NULL;
#1073   if (var->dimscale_hdf5_objids)
#1074      free(var->dimscale_hdf5_objids);
#1077   if (var->dimscale_attached)
#1078      free(var->dimscale_attached);
#1081   free(var);
#1129   NC_VAR_INFO_T *v, *var;
#1162   var = grp->var;
#1163   while (var)
#1165      LOG((4, "%s: deleting var %s", __func__var->name));
#1168      if (var->hdf_datasetid && H5Dclose(var->hdf_datasetid) < 0)
#1170      v = var->l.next;
#1171      if ((retval = nc4_var_list_del(&grp->varvar)))
#1173      var = v;
#1308nc4_reform_coord_var(NC_GRP_INFO_T *grpNC_VAR_INFO_T *varNC_DIM_INFO_T *dim)
#1313   if(var->dimscale_attached)
#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;
#1344                     if (dims_detached++ == var->ndims)
#1351      free(var->dimscale_attached);
#1352      var->dimscale_attached = NULL;
#1369   var->dimscale = NC_TRUE;
#1370   dim->coord_var = var;
#1373   if (var->was_coord_var && grp != NULL)
#1378                                        var->dimids[0], var->hdf_datasetid)))
#1382      var->was_coord_var = NC_FALSE;
#1386      var->became_coord_var = NC_TRUE;
#1455   NC_VAR_INFO_T *var;
#1479   for(var = grp->varvarvar = var->l.next)
#1481      if(var->ndims > 0)
#1483         dims_string = (char*)malloc(sizeof(char)*(var->ndims*4));
#1485         for (d = 0; d < var->ndimsd++)
#1487             sprintf(temp_string, " %d", var->dimids[d]);
#1492    tabsvar->varidvar->namevar->type_info->nc_typeidvar->ndims, (int)var->dimscale,
#1493       (dims_string ? dims_string : " -"),var->type_info->endiannessvar->type_info->native_hdf_typeid));
#1494      for(att = var->attattatt = att->l.next)
nc4internal.h#276   NC_VAR_INFO_T *var;
#352int nc4_reopen_dataset(NC_GRP_INFO_T *grpNC_VAR_INFO_T *var);
#353int nc4_adjust_var_cache(NC_GRP_INFO_T *grpNC_VAR_INFO_T * var);
#365int nc4_find_var(NC_GRP_INFO_T *grp, const char *nameNC_VAR_INFO_T **var);
#375       NC_GRP_INFO_T **grpNC_VAR_INFO_T **var);
#388int nc4_var_list_add(NC_VAR_INFO_T **listNC_VAR_INFO_T **var);
#389int nc4_var_list_del(NC_VAR_INFO_T **listNC_VAR_INFO_T *var);
nc4var.c#40nc4_reopen_dataset(NC_GRP_INFO_T *grpNC_VAR_INFO_T *var)
#44   if (var->hdf_datasetid)
#51      if (H5Pset_chunk_cache(access_pidvar->chunk_cache_nelems,
#52      var->chunk_cache_size,
#53      var->chunk_cache_preemption) < 0)
#55      if (H5Dclose(var->hdf_datasetid) < 0)
#57      if ((var->hdf_datasetid = H5Dopen2(grp->hdf_grpidvar->name,
#78   NC_VAR_INFO_T *var;
#97   for (var = grp->varvarvar = var->l.next)
#98      if (var->varid == varid)
#100   if (!var)
#104   var->chunk_cache_size = size;
#105   var->chunk_cache_nelems = nelems;
#106   var->chunk_cache_preemption = preemption;
#108   if ((retval = nc4_reopen_dataset(grpvar)))
#145   NC_VAR_INFO_T *var;
#160   for (var = grp->varvarvar = var->l.next)
#161      if (var->varid == varid)
#163   if (!var)
#168      *sizep = var->chunk_cache_size;
#170      *nelemsp = var->chunk_cache_nelems;
#172      *preemptionp = var->chunk_cache_preemption;
#202check_chunksizes(NC_GRP_INFO_T *grpNC_VAR_INFO_T *var, const size_t *chunksizes)
#209   if ((retval = nc4_get_typelen_mem(grp->nc4_infovar->type_info->nc_typeid, 0, &type_len)))
#211   if (var->type_info->nc_type_class == NC_VLEN)
#215   for (d = 0; d < var->ndimsd++)
#231nc4_find_default_chunksizes2(NC_GRP_INFO_T *grpNC_VAR_INFO_T *var)
#242   if (var->type_info->nc_type_class == NC_STRING)
#245      type_size = var->type_info->size;
#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 */
#269   if (var->ndims == 1 && num_unlim == 1) {
#276       var->chunksizes[0] = suggested_size / type_size;
#278     "chunksize %ld", __func__var->namedDEFAULT_CHUNK_SIZEnum_valuestype_sizevar->chunksizes[0]));
#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++)
#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];
#312   retval = check_chunksizes(grpvarvar->chunksizes);
#320      for ( ; retval == NC_EBADCHUNKretval = check_chunksizes(grpvarvar->chunksizes))
#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;
#350   NC_VAR_INFO_T *var;
#417   if ((retval = nc4_var_list_add(&grp->var, &var)))
#421   if (!(var->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
#423   strcpy(var->namenorm_name);
#424   var->hash = hash_fast(norm_name, strlen(norm_name));
#425   var->varid = grp->nvars++;
#426   var->ndims = ndims;
#427   var->is_new_var = NC_TRUE;
#484  var->type_info = type_info;
#485  var->type_info->rc++;
#491      if (!(var->dim = calloc(ndims, sizeof(NC_DIM_INFO_T *))))
#493      if (!(var->dimids = calloc(ndims, sizeof(int))))
#503   var->contiguous = NC_TRUE;
#513      if (d == 0 && dim_grp == grp && dim->hash == var->hash && strcmp(dim->namenorm_name) == 0)
#515         var->dimscale = NC_TRUE;
#516         dim->coord_var = var;
#542  var->contiguous = NC_FALSE;
#545      var->dimids[d] = dimidsp[d];
#546      var->dim[d] = dim;
#552 var->ndimsvar->name));
#553   if (var->ndims)
#554      if (!(var->chunksizes = calloc(var->ndims, sizeof(size_t))))
#557   if ((retval = nc4_find_default_chunksizes2(grpvar)))
#562   if ((retval = nc4_adjust_var_cache(grpvar)))
#571      if (dim->hash == var->hash && !strcmp(dim->namenorm_name) &&
#572   (!var->ndims || dimidsp[0] != dim->dimid))
#578  if (!(var->hdf5_name = malloc((strlen(NON_COORD_PREPEND) +
#582  sprintf(var->hdf5_name, "%s%s", NON_COORD_PREPENDnorm_name);
#589   if (!var->dimscale && ndims)
#590      if (ndims && !(var->dimscale_attached = calloc(ndims, sizeof(nc_bool_t))))
#595      *varidp = var->varid;
#596   LOG((4, "new varid %d", var->varid));
#644   NC_VAR_INFO_T *var;
#674   for (var = grp->varvarvar = var->l.next)
#675      if (var->varid == varid)
#679   if (!var)
#684      strcpy(namevar->name);
#686      *xtypep = var->type_info->nc_typeid;
#688      *ndimsp = var->ndims;
#690      for (d = 0; d < var->ndimsd++)
#691         dimidsp[d] = var->dimids[d];
#694      for (att = var->attattatt = att->l.next)
#700   if (!var->contiguous && chunksizesp)
#701      for (d = 0; d < var->ndimsd++)
#703         chunksizesp[d] = var->chunksizes[d];
#708      *contiguousp = var->contiguous ? NC_CONTIGUOUS : NC_CHUNKED;
#712      *deflatep = (int)var->deflate;
#714      *deflate_levelp = var->deflate_level;
#716      *shufflep = (int)var->shuffle;
#718      *fletcher32p = (int)var->fletcher32;
#723      *options_maskp = var->options_mask;
#725      *pixels_per_blockp = var->pixels_per_block;
#729      *no_fill = (int)var->no_fill;
#733   if (!var->no_fill && fill_valuep)
#736     if (var->fill_value)
#738         if (var->type_info->nc_type_class == NC_STRING)
#740             if (*(char **)var->fill_value) {
#745               if (!(*(char **)fill_valuep = strdup(*(char **)var->fill_value)))
#753             assert(var->type_info->size);
#754             memcpy(fill_valuepvar->fill_valuevar->type_info->size);
#759         if (var->type_info->nc_type_class == NC_STRING)
#764            if ((retval = nc4_get_default_fill_value(var->type_info, (char **)fill_valuep)))
#774            if ((retval = nc4_get_default_fill_value(var->type_infofill_valuep)))
#782      *endiannessp = var->type_info->endianness;
#800   NC_VAR_INFO_T *var;
#824   for (var = grp->varvarvar = var->l.next)
#825      if (var->varid == varid)
#829   if (!var)
#846   if (var->created)
#862      if (!var->ndims)
#867      var->contiguous = NC_FALSE;
#868      var->deflate = *deflate;
#870         var->deflate_level = *deflate_level;
#877      var->shuffle = *shuffle;
#878      var->contiguous = NC_FALSE;
#884      var->fletcher32 = *fletcher32;
#885      var->contiguous = NC_FALSE;
#893      if (var->deflate || var->fletcher32 || var->shuffle)
#897      for (d = 0; d < var->ndimsd++)
#899  dim = var->dim[d];
#903      var->contiguous = NC_TRUE;
#910      var->contiguous = NC_FALSE;
#917  if ((retval = check_chunksizes(grpvarchunksizes)))
#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];
#932   if (!var->contiguous && (chunksizes || deflate || contiguous))
#935      if (!var->chunksizes[0])
#936  if ((retval = nc4_find_default_chunksizes2(grpvar)))
#940      if ((retval = nc4_adjust_var_cache(grpvar)))
#948         var->no_fill = NC_TRUE;
#950         var->no_fill = NC_FALSE;
#954   if (fill_value && !var->no_fill)
#958           var->name));
#966      if ((retval = nc_put_att(ncidvarid_FillValuevar->type_info->nc_typeid, 1, fill_value)))
#972      var->type_info->endianness = *endianness;
#1021   NC_VAR_INFO_T *var;
#1033   if ((retval = nc4_find_g_var_nc(ncncidvarid, &grp, &var)))
#1037   if (var->ndims)
#1038      if (!(cs = malloc(var->ndims * sizeof(size_t))))
#1047      for (i = 0; i < var->ndimsi++)
#1054   if (var->ndims)
#1068   NC_VAR_INFO_T *var;
#1084   if ((retval = nc4_find_g_var_nc(ncncidvarid, &grp, &var)))
#1088   if (var->ndims)
#1089      if (!(cs = malloc(var->ndims * sizeof(size_t))))
#1093   for (i = 0; i < var->ndimsi++)
#1099   if (var->ndims)
#1128   NC_VAR_INFO_T *var;
#1151   for (var = grp->varvarvar = var->l.next)
#1152      if (nn_hash == var->hash && !(strcmp(var->namenorm_name)))
#1154         *varidp = var->varid;
#1171   NC_VAR_INFO_T *var, *tmp_var;
#1200   for (var = grp->varvarvar = var->l.next)
#1202      if (nn_hash == var->hash && !strncmp(var->namenameNC_MAX_NAME))
#1204      if (var->varid == varid)
#1205         tmp_var = var;
#1209   var = tmp_var;
#1213   if (!(h5->flags & NC_INDEF) && strlen(name) > strlen(var->name) &&
#1219   if (var->created)
#1221      if (H5Gmove(grp->hdf_grpidvar->namename) < 0)
#1226   free(var->name);
#1227   if (!(var->name = malloc((strlen(name) + 1) * sizeof(char))))
#1229   strcpy(var->namename);
#1230   var->hash = nn_hash;
#1233   if (var->dimscale && strcmp(var->namevar->dim[0]->name))
#1236      if ((retval = nc4_break_coord_var(grpvarvar->dim[0])))
#1241   if (!var->dimscale)
#1244      if (var->ndims)
#1253         if ((retval = nc4_find_dim(grpvar->dimids[0], &dim, &dim_grp)))
#1258             if ((retval = nc4_reform_coord_var(grpvardim)))
#1278   NC_VAR_INFO_T *var;
#1296   for (var = grp->varvarvar = var->l.next)
#1297      if (var->varid == varid)
#1299   if (!var)
#1303      var->parallel_access = NC_COLLECTIVE;
#1305      var->parallel_access = NC_INDEPENDENT;
#1333   NC_VAR_INFO_T *var;
#1339   if ((retval = nc4_find_g_var_nc(ncncidvarid, &grp, &var)))
#1342   assert(grp && h5 && var && var->name);
#1344   for (d = 0; d < var->ndimsd++)
#1350   if (SDreaddata(var->sdsidstart32NULLedge32data))
nccomps.h#89    int var;
ncd2dispatch.c#40static void computedimindexanon(CDFnodedimCDFnodevar);
#46static NCerror showprojection(NCDAPCOMMON*, CDFnodevar);
#750 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#755 if(var->invisible) continue;
#756 if(var->array.basevar != NULL) continue;
#759fprintf(stderr,"buildvars.candidate=|%s|\n",var->ncfullname);
#762 vardims = var->array.dimsetall;
#773 definename = getdefinename(var);
#777 definename,var->ocname);
#789                        var->externaltype,
#798        var->ncid = varid;
#799 if(var->attributes != NULL) {
#800     for(j=0;j<nclistlength(var->attributes);j++) {
#801 NCattributeatt = (NCattribute*)nclistget(var->attributes,j);
#802 ncstat = buildattribute(dapcomm,att,var->etype,varid);
#808     showprojection(dapcomm,var);
#1040 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#1041        for(j=0;j<nclistlength(var->array.dimsetall);j++) {
#1042     CDFnodedim = (CDFnode*)nclistget(var->array.dimsetall,j);
#1044      computedimindexanon(dim,var);
#1133 CDFnodevar = dim->dim.array;
#1138                            var->ncfullname,dim->dim.index1-1);
#1270 CDFnodevar = (CDFnode*)nclistget(nccomm->cdf.ddsroot->tree->varnodes,i);
#1272 var->maxstringlength = 0; /* => use global dfalt */
#1274 pathstr = makeocpathstring(conn,var->ocnode,".");
#1279            if(sscanf(value,"%d",&len) && len > 0) var->maxstringlength = len;
#1284 CDFnodevar = (CDFnode*)nclistget(nccomm->cdf.ddsroot->tree->nodes,i);
#1285 if(var->nctype != NC_Sequence) continue;
#1286 var->sequencelimit = dfaltseqlim;
#1288 pathstr = makeocpathstring(conn,var->ocnode,".");
#1291     var->sequencelimit = 0;
#1297 var->sequencelimit = len;
#1326computedimindexanon(CDFnodedimCDFnodevar)
#1329    NClistdimset = var->array.dimsetall;
#1435 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#1439 if(var->etype != NC_STRING && var->etype != NC_URL) continue;
#1442 if(var->dodsspecial.maxstrlen > 0)
#1443     dimsize = var->dodsspecial.maxstrlen;
#1445     dimsize = var->maxstringlength;
#1452     if(var->dodsspecial.dimname != NULL) {
#1453         strncpy(dimname,var->dodsspecial.dimname,sizeof(dimname));
#1465     sdim->dim.array = var;
#1470 var->array.stringdim = sdim;
#1552showprojection(NCDAPCOMMONdapcommCDFnodevar)
#1561    collectnodepath(var,path,WITHOUTDATASET);
#1569    rank = nclistlength(var->array.dimset0);
#1571 CDFnodedim = (CDFnode*)nclistget(var->array.dimset0,i);
#1579    ncstat = nc_put_att_text(getncid(drno),var->ncid,
#1810    CDFnodevar = NULL;
#1813    computeseqcountconstraintsr(dapcomm,seq,&var);
#1815    ASSERT((var != NULL));
#1819    collectnodepath(var,path,WITHOUTDATASET);
#1951        CDFnodevar = (CDFnode*)nclistget(dapcomm->cdf.ddsroot->tree->varnodes,ivar);
#1952 NClistncdims = var->array.dimset0;
#1955     var->estimatedsize = nctypesizeof(var->etype);
#1958 makecdfpathstring(var,"."),var->estimatedsize);
#1962     size *= nctypesizeof(var->etype);
#1965 makecdfpathstring(var,"."),rank,size);
#1967     var->estimatedsize = size;
#1969 totalsize += var->estimatedsize;
#2113     CDFnodevar = (CDFnode*)nclistget(dapcomm->cdf.ddsroot->tree->varnodes,i);
#2116     collectnodepath(var,path,WITHOUTDATASET);
#2122fprintf(stderr,"suppressing var in unusable sequence: %s.%s\n",node->ncfullname,var->ncbasename);
#2146 CDFnodevar = (CDFnode*)nclistget(dapcomm->cdf.ddsroot->tree->varnodes,i);
#2147        NClistncdims = var->array.dimsetplus;
#2153 var->invisible = 1;
#2154 var->zerodim = 1;
ncdap.h#99extern NCerror collectvardefdims(NCDAPCOMMONdrnoCDFnodevarNClistdimset);
#143extern NCerror showprojection(NCDAPCOMMON*, CDFnodevar);
ncdump.c#1504   ncvar_t var; /* variable */
#1665   memset((void*)&var,0,sizeof(var));
#1668      NC_CHECKnc_inq_varndims(ncidvarid, &var.ndims) );
#1669      if(var.dims != NULL) free(var.dims);
#1670      var.dims = (int *) emalloc((var.ndims + 1) * sizeof(int));
#1671      NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1672    var.dims, &var.natts) );
#1674      get_type_name(ncidvar.typetype_name);
#1675      var.tinfo = get_typeinfo(var.type);
#1681      print_type_name (ncidvar.type);
#1683      print_name (var.name);
#1684      if (var.ndims > 0)
#1686      for (id = 0; id < var.ndimsid++) {
#1689  NC_CHECKnc_inq_dimname(ncidvar.dims[id], dim_name) );
#1706      while(var.dims[id] != dimid_test) { /* not in locid, try ancestors */
#1728  printf ("%s", id < var.ndims-1 ? ", " : ")");
#1733      for (ia = 0; ia < var.nattsia++) { /* print ia-th attribute */
#1734   pr_att(ncidkindvaridvar.nameia);
#1739   pr_att_specials(ncidkindvarid, &var);
#1779  NC_CHECKnc_inq_varndims(ncidvarid, &var.ndims) );
#1780  if(var.dims != NULL) free(var.dims);
#1781  var.dims = (int *) emalloc((var.ndims + 1) * sizeof(int));
#1782  NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1783       var.dims, &var.natts) );
#1784  var.tinfo = get_typeinfo(var.type);
#1795  vdims = (size_t *) emalloc((var.ndims + 1) * SIZEOF_SIZE_T);
#1797  for (id = 0; id < var.ndimsid++) {
#1799      NC_CHECKnc_inq_dimlen(ncidvar.dims[id], &len) );
#1812  if(var.fillvalp != NULL) free(var.fillvalp);
#1813  get_fill_info(ncidvarid, &var); /* sets has_fillval, fillvalp mmbrs */
#1814  if(var.timeinfo != NULL) {
#1815      if(var.timeinfo->units) free(var.timeinfo->units);
#1816      free(var.timeinfo);
#1818  get_timeinfo(ncidvarid, &var); /* sets has_timeval, timeinfo mmbrs */
#1820  var.fmt = get_fmt(ncidvaridvar.type);
#1821  var.locid = ncid;
#1822  set_tostring_func(&var);
#1823  if (vardata(&varvdimsncidvarid) == -1) {
#1824     error("can't output data for variable %s", var.name);
#1876   if(var.dims != NULL) free(var.dims);
#1877   if(var.fillvalp != NULL) free(var.fillvalp);
#1878   if(var.timeinfo != NULL) {
#1879      if(var.timeinfo->units) free(var.timeinfo->units);
#1880      free(var.timeinfo);
#1915    ncvar_t var; /* variable */
#1958    memset((void*)&var,0,sizeof(var));
#1960 NC_CHECKnc_inq_varndims(ncidvarid, &var.ndims) );
#1961 if(var.dims != NULL) free(var.dims);
#1962 var.dims = (int *) emalloc((var.ndims + 1) * sizeof(int));
#1963 NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1964      var.dims, &var.natts) );
#1965 printf ("  <variable name=\"%s\"", var.name);
#1966 pr_shape(&vardims);
#1972 if (var.natts == 0) {
#1983 printf (" type=\"%s\" />\n", prim_type_name(var.type));
#1989 printf (" type=\"%s\">\n", prim_type_name(var.type));
#1992 for (ia = 0; ia < var.nattsia++) {
ncgen.h#155    struct Symbol*   var; /* NULL => global*/
#211        Varinfo   var;
ncgen.h#50    int var; /* number of variable for this attribute */
ncgentab.c#2572        if(atts[i].var == varnum &&
#2578    atts[natts].var = varnum ;
#2585        atts[natts].var != NC_GLOBAL) {
#2587                   &vars[atts[natts].var].fill_value);
#2588        if(atts[natts].type != vars[atts[natts].var].type) {
#2590                   vars[atts[natts].var].name_FillValue);
ncgeny.c#3322        special = &vsym->var.special;
#3418        asym->att.var = vsym;
#3424        asym->att.var = NULL; /* NULL => NC_GLOBAL*/
nctime0.c#284    ncvar_t var; /* fake var structure for the att values; */
#309    memset((void*)&var,0,sizeof(var)); /* clear the fake var structure */
#310    get_timeinfo(ncidvarid, &var); /* sets has_timeval, timeinfo members */
#312    if (var.has_timeval) { /* no print unless time qualified */
#326 var.type = att->type; /* insert attrib type into fake var */
#329     nctime_val_tostring(&varsb, (void *)valp);  /* convert to str. */
#347 if(var.timeinfo->units) /* clean up from get_timeinfo */
#348     free(var.timeinfo->units);
#349 free(var.timeinfo);
ocdebug.h#81#define MEMCHECK(var,throw) {if((var)==NULL) return (throw);}
#82#define MEMFAIL(varMEMCHECK(var,OCCATCH(OC_ENOMEM))
#83#define MEMGOTO(var,stat,label) {if((var)==NULL) {stat=OC_ENOMEM;goto label;}}
semantics.c#431 Symbolvar = (Symbol*)listget(vardefs,i);
#432 if(var->data != NULL && listlength(var->data) > 0)
#433     processeconstrefsR(var->data);
#749     asym->typ.basetype = asym->att.var->typ.basetype; /* its basetype is same as its var*/
#755     asym->att.var->var.special._Fillvalue = asym->data;
#776     if(asym->att.var == NULL)
#778     if(asym->att.var != vsym) continue;
#781 vsym->var.attributes = list;
#1170 Symbolvar = (Symbol*)listget(vardefs,i);
#1172 Dimsetdimset = &var->typ.dimset;
#1174 if(var->data == NULL) continue; /* no data list to walk */
#1175 ischar = (var->typ.basetype->typ.typecode == NC_CHAR);
#1179     computeunlimitedsizes(dimset,first,var->data,ischar);
#1182     for(j=0;j<var->data->length;j++) {
#1183         NCConstantcon = var->data->data+j;
t_dap.c#52report(const int i, const char* var, const int line)
#54    fprintf(stdout,"%s mismatch: [%d] file: %s line: %d\n",var,i,__FILE__,line);
t_dap3a.c#53report(const int i, const char* var, const int line)
#55    fprintf(stdout,"%s mismatch: [%d] file: %s line: %d\n",var,i,__FILE__,line);
test_cvt.c#52report(const int i, const char* var, const int line)
#54    fprintf(stdout,"%s mismatch: [%d] file: %s line: %d\n",var,i,__FILE__,line);
test_write.c#96    double var;
#138    var = 1.0;
#139    err = nc_put_var1_double(ncidvaridNULL, &var);
#185    var = 1.0;
#186    err = nc_put_var1_double(ncidvaridNULL, &var);
#207    IF ((err = nc_get_var1_double(ncidvaridNULL, &var)))
#209    IF (var != 1.0)
#229    var = 2.0;
#230    IF ((err = nc_put_var1_double(ncidvaridNULL, &var)))
#248    err = nc_get_var1_double(ncidvaridNULL, &var);
#251    IF (var != 2.0)
testcdf.h#33    int var;
tst_files3.c#30   int ncmodenciddimids[NDIMS], var;
#41   if (nc_def_var(ncid, "test", NC_FLOATNDIMSdimids, &var)) ERR_RET;
#43     if (nc_def_var_deflate(ncidvar, 1, 1, 1)) ERR_RET;
#47  if (nc_put_vara_float(ncidvarstartcountdata)) ERR_RET;
#55   int ncmodenciddimids[NDIMS], var;
#65   if (nc_def_var(ncid, "test", NC_FLOATNDIMSdimids, &var)) ERR_RET;
#67      if (nc_def_var_deflate(ncidvar, 1, 1, 1)) ERR_RET;
#69   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#77   int ncmodenciddimids[NDIMS], var;
#87   if (nc_def_var(ncid, "test", NC_FLOATNDIMSdimids, &var)) ERR_RET;
#89      if (nc_def_var_deflate(ncidvar, 1, 1, 1)) ERR_RET;
#91   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
util.c#117 reclaimconstlist(vsym->var.data);
#118 if(vsym->var.dims != NULLefree(vsym->var.dims);
vartests.c#114    struct cdfvar var; /* variable */
#124    var.dims = (int *) emalloc(sizeof(int) * MAX_VAR_DIMS);
#125    var.name = (char *) emalloc(MAX_NC_NAME);
#127 if (ncvarinq(cdfidvaridvar.name, &var.type,
#128       &var.ndimsvar.dims, &var.natts) == -1) {
#134 if (strcmp(var.nametest.vars[varid].name) != 0) {
#136   pnamevar.nametest.vars[varid].namevarid);
#139 if (var.type != test.vars[varid].type) {
#141   pnamevar.typetest.vars[varid].typevarid);
#144 if (var.ndims != test.vars[varid].ndims) {
#146   pnamevar.ndimstest.vars[varid].ndimsvarid);
#150     for (idim = 0; idim < var.ndimsidim++)
#151       if (var.dims[idim] != test.vars[varid].dims[idim]) {
#153 pnameidimvar.dims[idim],
#165 if (ncvarinq(cdfidvaridvar.name, &var.type,
#166       &var.ndimsvar.dims, &var.natts) == -1) {
#171 if (strcmp(var.nametest.vars[varid].name) != 0) {
#173   pnamevar.nametest.vars[varid].namevarid);
#176 if (var.type != test.vars[varid].type) {
#178   pnamevar.typetest.vars[varid].typevarid);
#181 if (var.ndims != test.vars[varid].ndims) {
#183   pnamevar.ndimstest.vars[varid].ndimsvarid);
#187     for (idim = 0; idim < var.ndimsidim++)
#188       if (var.dims[idim] != test.vars[varid].dims[idim]) {
#190 pnameidimvar.dims[idim],
#197    if (ncvarinq(cdfid, -1, var.name, &var.type,
#198       &var.ndimsvar.dims, &var.natts) != -1 ||
#199 ncvarinq(cdfidtest.nvarsvar.name, &var.type,
#200       &var.ndimsvar.dims, &var.natts) != -1) {
#215 if (ncvarinq(cdfidvaridvar.name, &var.type,
#216       &var.ndimsvar.dims, &var.natts) != -1) {
#221    if(var.dims != NULL) free(var.dims);
#222    if(var.name != NULL) free(var.name);
#571    struct cdfvar var; /* variable */
#614    var.dims = (int *) emalloc(sizeof(int) * MAX_VAR_DIMS);
#615    var.name = (char *) emalloc(MAX_NC_NAME);
#616    if (ncvarinq(cdfidyy_idvar.name,
#617   &var.type, &var.ndimsvar.dims, &var.natts) == -1) {
#621    if (strcmp(var.name,yy.name) == 0) {
#625    if (strcmp(var.name,newname) != 0) {
#627       pnamevar.namenewname);
#637    if (ncvarrename(cdfid, -1, var.name) != -1 ||
#638 ncvarrename(cdfidtest.nvarsvar.name) != -1) {
#667    if (ncvarrename (cdfid, 0, var.name) != -1) {
#673    free(var.name);
#674    free(var.dims);


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