add.c#51    int i;
#64    for (i = 0; i < ivar->ndimsi++)
#65      test->vars[test->nvars].dims[i] = ivar->dims[i];
bm_file.c#827   int indimso1;
#854      for (i = 0; i < MAX_DIMSi++)
#855  vo[o1].chunksize[i] = 0;
bm_many_atts.c#27    int i;
#40    for(i = 1; i < argci++) {
#41 nitem = atoi(argv[i]);
bm_many_objs.c#25    int i;
#38    for(i = 1; i < argci++) {
#39 nitem = atoi(argv[i]);
bm_netcdf4_recs.c#26    int i;
bytebuffer.c#88  unsigned int i;
#90  for(i=0;i<bb->length;i++) bb->content[i] = fill;
#170  unsigned int i;
#195  for(j=newlen-1,i=index;i<bb->length;i++) {
cache.c#27    int i,j,found,index;
#39        for(found=0,i=0;i<nclistlength(cachenode->vars);i++) {
#40            CDFnodevar = (CDFnode*)nclistget(cachenode->vars,i);
#51    for(i=nclistlength(cache->nodes)-1;i>=0;i--) {
#52        cachenode = (NCcachenode*)nclistget(cache->nodes,i);
#60            if(var == target) {found=1;index=i;break;}
#95    int i;
#108     for(i=0;i<nclistlength(allvars);i++) {
#109         nclistpush(vars,nclistget(allvars,i));
#117        for(i=0;i<nclistlength(allvars);i++) {
#118            CDFnodevar = (CDFnode*)nclistget(allvars,i);
#153    for(i=0;i<nclistlength(vars);i++) {
#154        CDFnodevar = (CDFnode*)nclistget(vars,i);
#188for(i=0;i<nclistlength(vars);i++) {
#189CDFnodevar = (CDFnode*)nclistget(vars,i);
#342    int i;
#345    for(i=0;i<nclistlength(cache->nodes);i++) {
#346 freenccachenode(nccomm,(NCcachenode*)nclistget(cache->nodes,i));
#368    int i,cacheable;
#371    for(i=0;i<nclistlength(proj->var->segments);i++) {
#372        DCEsegmentsegment = (DCEsegment*)nclistget(proj->var->segments,i);
#381    int i;
#385    for(i=0;i<nclistlength(con->projections);i++) {
#386        if(!iscacheableprojection((DCEprojection*)nclistget(con->projections,i)))
#401    int i,j;
#405    for(i=0;i<nclistlength(allvars);i++) {
#406 CDFnodevar = (CDFnode*)nclistget(allvars,i);
cdf.c#39    unsigned int i;
#57    for(i=0;i<nclistlength(allnodes);i++) {
#58 CDFnodenode = (CDFnode*)nclistget(allnodes,i);
#75    unsigned int i,len;
#77    for(i=0;i<nclistlength(allnodes);i++) {
#78 CDFnodenode = (CDFnode*)nclistget(allnodes,i);
#93    for(i=0;i<len;i++) {
#94 CDFnodenode = (CDFnode*)nclistget(allvarnodes,i);
#98     nclistset(allvarnodes,i,(void*)NULL);
#105    for(i=0;i<len;i++) {
#106 CDFnodenode = (CDFnode*)nclistget(allvarnodes,i);
#110     nclistset(allvarnodes,i,(void*)NULL);
#114     nclistset(allvarnodes,i,(void*)NULL);
#118    for(i=0;i<len;i++) {
#119 CDFnodenode = (CDFnode*)nclistget(allvarnodes,i);
#125for(i=0;i<nclistlength(varnodes);i++) {
#126CDFnodenode = (CDFnode*)nclistget(varnodes,i);
#139    unsigned int i,glen;
#152    for(i=1;i<glen;i++) {
#153 CDFnodearraydim = (CDFnode*)nclistget(array->array.dimset0,i-1);
#154 CDFnodemap = (CDFnode*)nclistget(grid->subnodes,i);
#202    unsigned int i;
#205    for(i=0;i<nclistlength(gridnodes);i++) {
#206        CDFnodegrid = (CDFnode*)nclistget(gridnodes,i);
#219    unsigned int i,j,d;
#222    for(i=0;i<nclistlength(root->tree->nodes);i++) {
#223 CDFnodenode = (CDFnode*)nclistget(root->tree->nodes,i);
#230    for(i=0;i<nclistlength(varnodes);i++) {
#231 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#245        for(i=0;i<nclistlength(varnodes);i++) {
#247     CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#248     for(j=0;j<i;j++) {
#275    for(i=0;i<nclistlength(varnodes);i++) {
#276 CDFnodevar1 = (CDFnode*)nclistget(varnodes,i);
#278 for(j=0;j<i;j++) {
#309    unsigned int i;
#318 for(i=0;i<nclistlength(node->subnodes);i++) {
#319     CDFnodesub = (CDFnode*)nclistget(node->subnodes,i);
#340 for(i=0;i<nclistlength(node->subnodes);i++) {
#341     CDFnodesub = (CDFnode*)nclistget(node->subnodes,i);
#438    int indexijmatch;
#455        for(i=0;i<nclistlength(patternparent->subnodes);i++) {
#456            CDFnodepatternsubnode = (CDFnode*)nclistget(patternparent->subnodes,i);
#478            for(match=0,i=0;!match && i<nclistlength(patternparent->subnodes);i++) {
#479                CDFnodesubtemp = (CDFnode*)nclistget(patternparent->subnodes,i);
#506    int i;
#508    for(i=0;i<nclistlength(repairlist);i+=2) {
#509 CDFnodenode = (CDFnode*)nclistget(repairlist,i);
#510 CDFnodepattern = (CDFnode*)nclistget(repairlist,i+1);
#546    int i;
#548    for(i=0;i<nclistlength(subnodes);i++) {
#549 if(nclistget(subnodes,i) == child)
#550     return i;
#598    unsigned int i,j;
#617    int i;
#618    for(i=0;i<nclistlength(fullnode->subnodes);i++) {
#619 CDFnoden = (CDFnode*)nclistget(fullnode->subnodes,i);
#620 fprintf(stderr,"fullnode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname);
#622    for(i=0;i<nclistlength(connode->subnodes);i++) {
#623 CDFnoden = (CDFnode*)nclistget(connode->subnodes,i);
#624 fprintf(stderr,"connode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname);
#632    for(i=0;i<nclistlength(connode->subnodes);i++) {
#633        CDFnodeconsubnode = (CDFnode*)nclistget(connode->subnodes,i);
#662    unsigned int i;
#664    for(i=0;i<nclistlength(tree->nodes);i++) {
#665 CDFnodenode = (CDFnode*)nclistget(tree->nodes,i);
#679    int i,j;
#683    for(i=0;i<nclistlength(allnodes);i++) {
#684 CDFnodenode = (CDFnode*)nclistget(allnodes,i);
#705fprintf(stderr,"dimimprint: %d: %lu -> %lu\n",i,basedim->dim.declsize,dim->dim.declsize0);
#730    int i;
#732    for(i=0;i<nclistlength(dimset);i++) {
#737        dim = (CDFnode*)nclistget(dimset,i);
#773    int i;
#783    for(i=0;i<nclistlength(node->array.dimsetplus);i++) {
#786 clone = (CDFnode*)nclistget(node->array.dimsetplus,i);
#800    int i;
#813    for(i=0;i<nclistlength(node->array.dimset0);i++) {
#816  clone = (CDFnode*)nclistget(node->array.dimset0,i);
#845    int i;
#850    for(i=0;i<nclistlength(node->subnodes);i++) {
#851 CDFnodesubnode = (CDFnode*)nclistget(node->subnodes,i);
#885    int i;
#891    for(i=0;i<nclistlength(node->subnodes);i++) {
#892 CDFnodesubnode = (CDFnode*)nclistget(node->subnodes,i);
#968    size_t i,ocrank,ocnsubnodes;
#1041    for(i=0;i<ocnsubnodes;i++) {
#1044 oc_dds_ithfield(nccomm->oc.conn,ocnode,i,&ocsubnode);
#1060    int i;
#1070    for(i=0;i<nclistlength(tree->nodes);i++) {
#1071 CDFnodenode = (CDFnode*)nclistget(tree->nodes,i);
#1189    int i;
#1190    for(i=0;i<nclistlength(cdfnodes);i++) {
#1191 CDFnodenode = (CDFnode*)nclistget(cdfnodes,i);
#1201    size_t i,ocrank;
#1205    for(i=0;i<ocrank;i++) {
#1211 oc_dds_ithdimension(nccomm->oc.conn,ocnode,i,&ocdim);
cdftests.c#108    int i;
#111    for (i = 0; i < DATA_LENi++)
#112       dummy_data[i] = 0;
cdm_sea_soundings.c#26   int ij;
#29   for (i = 0; i < DIM_LENi++)
#31      if (!(data[i].temp_vl.p = malloc(sizeof(float) * (i + 1))))
#33      for (j = 0; j < i + 1; j++)
#34  ((float *)(data[i].temp_vl.p))[j] = 23.5 - j;
#35      data[i].temp_vl.len = i + 1;
#71    for (i = 0; i < DIM_LENi++)
#72       free(data[i].temp_vl.p);
constraints.c#58    int i;
#64    for(i=0;i<nclistlength(dceprojections);i++) {
#66 DCEprojectionproj = (DCEprojection*)nclistget(dceprojections,i);
#89    int i;
#95        for(i=0;i<nclistlength(constraint->projections);i++) {
#96            DCEprojectionp = (DCEprojection*)nclistget(constraint->projections,i);
#140    int i,j;
#146    for(i=0;i<nclistlength(proj->var->segments);i++) {
#147        DCEsegmentseg = (DCEsegment*)nclistget(proj->var->segments,i);
#177    int i,delta;
#181    for(i=0;i<delta;i++) {
#183        CDFnodenode = (CDFnode*)nclistget(fullpath,i);
#187        nclistinsert(segments,i,(void*)seg);
#192    for(i=delta;i<nclistlength(segments);i++) {
#193        DCEsegmentseg = (DCEsegment*)nclistget(segments,i);
#194        CDFnodenode = (CDFnode*)nclistget(fullpath,i);
#235    int i,nsegs;
#247    for(i=0;i<nclistlength(nodes);i++) {
#248        CDFnodenode = (CDFnode*)nclistget(nodes,i);
#270    for(i=0;i<nclistlength(namematches);i++) {
#271        CDFnodematchnode = (CDFnode*)nclistget(namematches,i);
#299 for(i=0;i<nclistlength(matches);i++) {
#300     CDFnodecandidate = (CDFnode*)nclistget(matches,i);
#338    int i,pathstart;
#355    for(i=0;i<nsegs;i++) {
#356 CDFnodenode = (CDFnode*)nclistget(matchpath,pathstart+i);
#357 DCEsegmentseg = (DCEsegment*)nclistget(segments,i);
#386    int i,j;
#409    for(i=0;i<nclistlength(segments);i++) {
#410 DCEsegmentsegment = (DCEsegment*)nclistget(segments,i);
#463    int i,whole;
#473    for(i=0;i<rank;i++) {
#474 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#475 if(!dapiswholeslice(&seg->slices[i],dim)) {whole = 0; break;}
#483    int i,whole;
#488    for(i=0;i<nclistlength(proj->var->segments);i++) {
#489        DCEsegmentsegment = (DCEsegment*)nclistget(proj->var->segments,i);
#498    int i;
#501 for(i=0;i<nclistlength(con->projections);i++) {
#502  if(!dapiswholeprojection((DCEprojection*)nclistget(con->projections,i)))
#528    int i,j,k;
#539    for(i=0;i<nclistlength(list);i++) {
#540 DCEprojectionp1 = (DCEprojection*)nclistget(list,i);
#543        for(j=i;j<nclistlength(list);j++) {
#561    for(i=0;i<nclistlength(list);i++) {
#562 DCEprojectionp1 = (DCEprojection*)nclistget(list,i);
#567        for(j=i;j<nclistlength(list);j++) {
#576     nclistset(list,i,(void*)NULL);
#588        for(i=0;i<nclistlength(list);i++) {
#589            DCEprojectiontarget = (DCEprojection*)nclistget(list,i);
#599                nclistset(list,i,(void*)NULL);
#604        for(i=0;i<nclistlength(tmp);i++) {
#605            DCEprojectioncontainer = (DCEprojection*)nclistget(tmp,i);
#607            for(j=0;i<nclistlength(leaf->subnodes);j++) {
#619    for(i=nclistlength(list)-1;i>=0;i--) {
#620        DCEprojectiontarget = (DCEprojection*)nclistget(list,i);
#622     nclistremove(list,i);
#661    int i,j;
#666    for(i=0;i<nclistlength(seglist1);i++) {
#667 DCEsegmentseg1 = (DCEsegment*)nclistget(seglist1,i);
#668 DCEsegmentseg2 = (DCEsegment*)nclistget(seglist2,i);
#691    int i,j;
#704    for(i=0;i<nclistlength(path);i++) {
#706 CDFnoden = (CDFnode*)nclistget(path,i);
#757    int i;
#768    for(result=null,i=0;i<nclistlength(projections);i++) {
#769 DCEprojectionp1 = (DCEprojection*)nclistget(projections,i);
#817    int i,j;
#826    for(i=0;i<nclistlength(segments);i++) {
#827 DCEsegmentseg = (DCEsegment*)nclistget(segments,i);
#849    int i;
#860    for(i=0;i<nclistlength(constraint->projections);i++) {
#862 DCEprojectionproj = (DCEprojection*)nclistget(constraint->projections,i);
cvt.c#618    int i;
#626    for(i=0;i<slen;i++) {
#630        con.value.charv = s[i];
dapalign.c#212    int i,j;
#300    for(i=0;i<NCCTYPECOUNT;i++) {
#302 padname(vec[i].typename),sizes8[i],vec[i].alignment);
#304    for(i=0;i<NCCTYPECOUNT;i++) {
#306 padname(vec[i].typename),sizes16[i],vec16[i].alignment);
#308    for(i=0;i<NCCTYPECOUNT;i++) {
#310 padname(vec[i].typename),sizes32[i],vec32[i].alignment);
#318    int i;
dapattr.c#21    int i,j;
#38    for(i=0;i<nclistlength(allnodes);i++) {
#39 CDFnodenode = (CDFnode*)nclistget(allnodes,i);
#123    int i;
#133    for(i=0;i<nvalues;i++)
#134 nclistpush(att->values,(void*)nulldup(values[i]));
#151    int i;
#162    for(i=0;i<nclistlength(subnodes);i++) {
#163        OCdasnode subnode = (OCdasnode)nclistget(subnodes,i);
#175    unsigned int i,j;
#197    for(i=0;i<nclistlength(alldasnodes);i++) {
#198 OCddsnode das = (OCddsnode)nclistget(alldasnodes,i);
#253    for(i=0;i<nclistlength(dasnodes);i++) {
#254 OCddsnode das = (OCddsnode)nclistget(dasnodes,i);
#276 nclistset(dasnodes,i,(void*)NULL);
#285    for(i=0;i<nclistlength(dasglobals);i++) {
#286 OCddsnode das = (OCddsnode)nclistget(dasglobals,i);
#291    for(i=0;i<nclistlength(dodsextra);i++) {
#292 OCddsnode das = (OCddsnode)nclistget(dodsextra,i);
#312    unsigned int i,j,k;
#323    for(i=0;i<nsubnodes;i++) {
#324 OCobject attnode = subnodes[i];
#442    size_t nsubnodes,i;
#447    for(i=0;i<nsubnodes;i++) {
#449 ocstat = oc_dds_ithsubnode(link,dasnode,i,&subnode);
#462    size_t nsubnodes,i;
#472        for(i=0;i<nsubnodes;i++) {
#474     ocstat = oc_dds_ithsubnode(link,ddsnode,i,&subnode);
#488    size_t nsubnodes,i;
#492    for(i=0;i<nsubnodes;i++) {
#494 ocstat = oc_dds_ithsubnode(link,ddsnode,i,&subnode);
dapcvt.c#16    size_t i;
#61    for(i=0;i<count;i++) {
#199    int i,ok;
#205    for(i=0;i<nvalues;i++) {
#206 char* s = (char*)nclistget(src,i);
dapdump.c#21    int stat,i,j,k;
#42    for(i=0;i<hdr->ngatts;i++) {
#43 NCattributeatt = &hdr->gatts[i];
#49        stat = nc_inq_attname(hdr->ncid,NC_GLOBAL,i,attname);
#57 i,att->name,nctypetostring(octypetonc(att->etype)),
#83    for(i=0;i<hdr->ndims;i++) {
#84 hdr->dims[i].dimid = i;
#86                   hdr->dims[i].dimid,
#87                   hdr->dims[i].name,
#88                   &hdr->dims[i].size);
#91 i,hdr->dims[i].name,(unsigned long)hdr->dims[i].size);
#95    for(i=0;i<hdr->nvars;i++) {
#96 Varvar = &hdr->vars[i];
#98 var->varid = i;
#109 i,
#256    int i;
#260    for(i=0;i<nclistlength(path);i++) {
#261 CDFnodenode = (CDFnode*)nclistget(path,i);
#262 if(i > 0) ncbytescat(buf,".");
#275    int i;
#276    for(i=0;i<indent;i++) ncbytescat(buf,indentstr);
#282    int i;
#286    for(i=0;i<nclistlength(root->subnodes);i++) {
#287 CDFnodenode = (CDFnode*)nclistget(root->subnodes,i);
#290     if(i==0) {
#293     } else if(i==1) {
#310    int i;
#355 for(i=0;i<nclistlength(dimset);i++) {
#356     CDFnodedim = (CDFnode*)nclistget(dimset,i);
#399    int i;
#464    for(i=0;i<nclistlength(node->array.dimset0);i++) {
#465 CDFnodedim = (CDFnode*)nclistget(node->array.dimset0,i);
#466        snprintf(tmp,sizeof(tmp),"dims[%d]={\n",i);
#507    int i;
#521    else for(i=0;i<nclistlength(node->vars);i++) {
#522 CDFnodevar = (CDFnode*)nclistget(node->vars,i);
#523 if(i > 0) ncbytescat(buf,",");
#537    int i;
#552        for(i=0;i<nclistlength(cache->nodes);i++) {
#553        NCcachenodenode = (NCcachenode*)nclistget(cache->nodes,i);
#594    int i;
#599    for(i=0;i<rank;i++,slice++) {
#629    int i;
#630    for(i=0;i<nclistlength(l);i++) {
#631 const char* s = (const char*)nclistget(l,i);
#632 fprintf(stderr,"[%d]: |%s|\n",i,s);
daplex.c#116    unsigned int i;
#237         for(i=0;;i++) {
#238     if(keywords[i] == NULL) break;
#239     if(strcasecmp(keywords[i],tmp)==0) {
#240         token=keytokens[i];
dapodom.c#16    int i;
#24    for(i=0;i<odom->rank;i++) {
#25 odom->start[i] = segment->slices[i+startindex].first;
#26 odom->stride[i] = segment->slices[i+startindex].stride;
#27 odom->stop[i] = (segment->slices[i+startindex].last + 1);
#32 odom->count[i] = segment->slices[i+startindex].count;
#34 odom->declsize[i] = segment->slices[i+startindex].declsize;
#35 odom->index[i] = odom->start[i];
#45    int i;
#50    for(i=0;i<odom->rank;i++) {
#53 istart = (start != NULL ? start[i] : 0);
#54 icount = (count != NULL ? count[i] : (size != NULL ? size[i] : 1));
#55 istride = (size_t)(stride != NULL ? stride[i] : 1);
#57 ideclsize = (size != NULL ? size[i]: (istop - istart));
#58 odom->start[i] = istart;
#59 odom->stop[i] = istop;
#60 odom->stride[i] = istride;
#61 odom->declsize[i] = ideclsize;
#62 odom->index[i] = odom->start[i];
#77    int i;
#83    } else for(i=0;i<odom->rank;i++) {
#85 (size_t)odom->index[i],
#86 (size_t)odom->start[i],
#87 (size_t)odom->stride[i],
#88 (size_t)odom->length[i]);
#105    int i;
#107    for(i=0;i<odom->rank;i++) {
#108 offset *= odom->declsize[i];
#109 offset += odom->index[i];
#117    int i; /* do not make unsigned */
#119    for(i=odom->rank-1;i>=0;i--) {
#120        odom->index[i] += odom->stride[i];
#121        if(odom->index[i] < odom->stop[i]) break;
#122 if(i == 0) return 0; /* leave the 0th entry if it overflows*/
#123 odom->index[i] = odom->start[i]; /* reset this position*/
#132    int i;
#134    for(i=0;i<odom->rank;i++) {
#136 tmp = odom->index[i];
#137 tmp = tmp - odom->start[i];
#138 tmp = tmp / odom->stride[i];
#139 tmp = tmp * steps[i];
#154    size_t i;
#156    for(i=0;i<odom->rank;i++) {
#157 count *= odom->size[i];
dapparse.c#104    int i;
#110    for(i=0;i<4096;i++) {if(state->lexstate->input[i] == '\0') break;}
#111    state->lexstate->input[i] = '\0';
#238    unsigned int i;
#242    for(i=0;i<rank;i++) {
#243        OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#245 dim->dim.arrayindex = i;
#249     dim->name = dimnameanon(node->name,i);
#329    unsigned int i;
#331    for(i=0;i<oclistlength(node->subnodes);i++) {
#332        OCnodesubnode = (OCnode*)oclistget(node->subnodes,i);
#340    size_t i;
#341    for(i=0;i<oclistlength(ocnodes);i++) {
#342 OCnodenode = (OCnode*)oclistget(ocnodes,i);
#405    unsigned int i,j;
#408    for(i=0;i<len;i++) {
#409 OCnodeio = (OCnode*)oclistget(list,i);
#411        for(j=i+1;j<len;j++) {
daputil.c#258    unsigned int i;
#260    for(i=0;i<nclistlength(dimensions);i++) {
#261 CDFnodedim = (CDFnode*)nclistget(dimensions,i);
#307    unsigned int i;
#308    for(i=0;i<nclistlength(l2);i++) nclistpush(l1,nclistget(l2,i));
#315    unsigned int i,len,found;
#318    for(i=0;i<len;i++) {
#319 if(nclistdeleteall(l1,nclistget(l2,i))) found = 1;
#327    int i; /* do not make unsigned */
#331    for(i=len-1;i>=0;i--) {
#332 void* test = nclistget(l,i);
#334     nclistremove(l,i);
#373    int i,len,first;
#395    for(first=1,i=1;i<len;i++) { /* start at 1 to skip dataset name */
#396 OCddsnode node = (OCddsnode)nclistget(ocpath,i);
#414    int i,len,first;
#428    for(first=1,i=0;i<len;i++) {
#429 CDFnodenode = (CDFnode*)nclistget(path,i);
#473    int i;
#477    for(len=0,i=0;i<nclistlength(names);i++) {
#478 char* name = (char*)nclistget(names,i);
#485    for(i=0;i<nclistlength(names);i++) {
#486 char* segment = (char*)nclistget(names,i);
#487 if(i > 0) strcat(result,separator);
data.c#298    int i;
#300    for(i=0;i<dl->length;i++) {
#301 clone->data[i] = cloneconstant(dl->data+i);
data.h#102#define   datalistith(dl,i) ((dl)==NULL?NULL:((i) >= (dl)->length?NULL:&(dl)->data[i]))
dceconstraints.c#190#define MAP(s1,i) ((s1)->first + ((s1)->stride*(i)))
#232    int i;
#243    for(i=0;i<nclistlength(dst);i++) {
#244 DCEprojectionp = (DCEprojection*)nclistget(dst,i);
#247    for(i=0;i<nclistlength(src);i++) {
#248 DCEprojectionp = (DCEprojection*)nclistget(src,i);
#262        for(i=0;i<nclistlength(cat);i++) {
#263     DCEprojectionp2 = (DCEprojection*)nclistget(cat,i);
#271     nclistset(cat,i,(void*)NULL);
#286    int i,j;
#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);
#446    int i;
#450    for(i=0;i<nclistlength(list);i++) {
#451 DCEnodenode = (DCEnode*)nclistget(list,i);
#533    int i;
#535    for(i=0;i<nclistlength(list);i++) {
#536 DCEnodenode = (DCEnode*)nclistget(list,i);
#604    int i;
#643            for(i=0;i<rank;i++) {
#644         DCEsliceslice = segment->slices+i;
#754    int i;
#757    for(i=0;i<nclistlength(list);i++) {
#758 DCEnodenode = (DCEnode*)nclistget(list,i);
#760 if(i>0) ncbytescat(buf,sep);
#778    int i;
#786 for(i=0;i<nclistlength(fcn->args);i++) {
#787     ceallnodesr((DCEnode*)nclistget(fcn->args,i),allnodes,which);
#792 for(i=0;i<nclistlength(var->segments);i++) {
#793     ceallnodesr((DCEnode*)nclistget(var->segments,i),allnodes,which);
#808 for(i=0;i<nclistlength(selection->rhs);i++)
#809            ceallnodesr((DCEnode*)nclistget(selection->rhs,i),allnodes,which);
#820 for(i=0;i<nclistlength(constraint->projections);i++)
#821     ceallnodesr((DCEnode*)nclistget(constraint->projections,i),allnodes,which);
#822 for(i=0;i<nclistlength(constraint->selections);i++)
#823     ceallnodesr((DCEnode*)nclistget(constraint->selections,i),allnodes,which);
#846 int i;
#850 for(i=0;i<NC_MAX_VAR_DIMS;i++)
#851     target->slices[i].node.sort = CES_SLICE;
#921    int i,whole;
#925    for(i=0;i<seg->rank;i++) {
#926 if(!dceiswholeslice(&seg->slices[i])) {whole = 0; break;}
#957    int i;
#960    for(i=0;i<len;i++) {
#961 DCEsegments1 = (DCEsegment*)nclistget(list1,i);
#962 DCEsegments2 = (DCEsegment*)nclistget(list2,i);
#976    int i;
#978        for(i=0;i<segment->rank;i++) {
#979     if(start != NULLstart[i] = segment->slices[i].first;
#980     if(count != NULLcount[i] = segment->slices[i].count;
#981     if(stride != NULLstride[i] = (size_t)segment->slices[i].stride;
#982     if(sizes != NULLsizes[i] = segment->slices[i].declsize;
#991    int icount;
#993    for(count=1,i=start;i<stop;i++) {
#994 count *= seg->slices[i].count;
#1046    int i;
#1084            for(i=0;i<rank;i++) {
#1085         DCEsliceslice = segment->slices+i;
#1199    int i;
#1202    for(i=0;i<nclistlength(list);i++) {
#1203 DCEnodenode = (DCEnode*)nclistget(list,i);
#1205 if(i>0) ncbytescat(buf,",");
dceparse.c#94    int i;
#101 for(i=0;i<nclistlength(slices);i++) {
#102     DCEsliceslice = (DCEslice*)nclistget(slices,i);
#103     segment->slices[i] = *slice;
#220    int i;
#224    for(i=0;i<nclistlength(list);i++) {
#225 DCEsliceslice = (DCEslice*)nclistget(list,i);
#226        seg->slices[i] = *slice;
dcopy.c#38      int iretequal1;
#88     for(i = 0; i < nelems1i++)
#90        if ((ret = nc_inq_enum_member(ncid1typeid1iname1,
#92    (ret = nc_inq_enum_member(ncid2typeid2iname2,
#109     for(i = 0; i < nelems1i++)
#112        if ((ret = nc_inq_compound_field(ncid1typeid1iname1, &offset1,
#115        if ((ret = nc_inq_compound_field(ncid2typeid2iname2, &offset2,
#145   int i,ret = NC_NOERR;
#160      for(i = 0; i < nidsi++)
#163  if ((ret = NC_compare_nc_types(ncid1tid1ncid2ids[i], &equal)))
#168        *tid2 = ids[i];
#188      for (i = 0; i < nidsi++)
#190  ret = NC_rec_find_nc_type(ncid1tid1ids[i], tid2);
#270   int i;
#277   for(i = 0; i < ndimsi++) {
#278      dimids_out[i] = dimids_in[i];
#279      if ((retval = nc_inq_dimname(ncid_indimids_in[i], dimname_in)))
#281      if ((retval = nc_inq_dimid(ncid_outdimname_in, &dimids_out[i])))
#551     int i;
#559     for (i = 0; i < leni++)
#560        if((res = nc_free_vlen(&vldata[i])))
ddispatch.c#46    int i;
#47    for(i=0;i<NC_MAX_VAR_DIMS;i++) {
#48 nc_sizevector0[i] = 0;
#49        nc_sizevector1[i] = 1;
#50        nc_ptrdiffvector1[i] = 1;
#52    for(i=0;i<NC_MAX_VAR_DIMS;i++) {
#53 NC_coord_one[i] = 1;
#54 NC_coord_zero[i] = 0;
#63    int i;
#189    int i;
#195    for(i=0;i<count;i++) {
#196        if(voverlay[i] == NULL) continue;
#197        vmerge[i] = voverlay[i];
dfile.c#168     size_t i;
#214     i = fread(magicMAGIC_NUMBER_LEN, 1, fp);
#216     if(i == 0)
#218     if(i != 1)
dimmap.c#22    int i;
#28    for(i = 0; i < ni++) {
#29 dimmap.odimids[i] = -1;
#30 dimmap.idimids[i] = -1;
#31 dimmap.ounlims[i] = 0;
#32 dimmap.iunlims[i] = 0;
driver.c#36    int inerrs = 0;
#44    for (i = 1; i <= NUM_FORMATSi++)
#46       switch (i)
#66       testfile = testfiles[i];
#107   int i;
#109   for (i = 0; i < test.ndimsi++)
#110      free(test.dims[i].name);
#112   for (i = 0; i < test.nvarsi++)
#114      free(test.vars[i].name);
#115      free(test.vars[i].dims);
#118   for (i = 0; i < test.nattsi++)
#119      free(test.atts[i].name);
dump.c#49    int i;
#59    for(dp=list->data,i=0;i<count;i++,dp++) {
#168 int i;
#169 for(i=0;i<listlength(g->subnodes);i++) {
#170     Symbolsym = (Symbol*)listget(g->subnodes,i);
#178 i,
#264    int icountindexdepth;
#273 for(i=0;i<index;i++) {
#275     dumpconstant1(&src->data[i]);
#278 for(i=index;i<count;i++) {
#280     dumpconstant1(&src->data[i]);
dumplib.c#465    int i;
#477 for (i=0; i < numgrpsi++) {
#478     ntypes += count_udtypes(ncids[i]);
#676    int i;
#677    for (i=0; i < nbytesi++) {
#698 size_t i;
#699 for(i = 0; i < v1leni++) {
#727     int i; /* array element counter when rank > 0 */
#730     for(i = 0; i < finfo->nvals[fidx]; i++) {
#1020    int i;
#1026    for(i = 0; i < sizei++) {
#1056    size_t i;
#1063    for(i = 0; i < leni++) {
#1066 if(i < len - 1) {
#1151     int i; /* array element counter when rank > 0 */
#1165 for(i=0; i < nstringsi++) { /* loop on product of all but
#1169     if(i < nstrings - 1) {
#1175 for(i = 0; i < tinfo->nvals[fidx]; i++) {
#1178     if(i < tinfo->nvals[fidx] - 1) {
#1495    int i;
#1527    for(i=0; i < sizeof(types)/sizeof(int); i++) {
#1529    for(i=0; i < max_atomic_typei++) {
#1533 tp->tid = types[i];
#1537 tp->size = sizes[i];
#1540 tp->fmt = get_default_fmt(types[i]);
#1546 tp->val_equals = (val_equals_funceq_funcs[i];
#1547 tp->typ_tostring = (typ_tostring_functs_funcs[i];
#1566 int i;
#1568 for(i=0; i < maxtype+1; i++)
#1569     nctypes[i] = NULL; /* so can later skip over unused type slots */
#1629   int i;
#1643   for(i = 0; i < ranki++) {
#1644       tinfo->sides[fidx][i] = sides[i];
#1645       tinfo->nvals[fidx] *= sides[i];
#1725     int i;
#1726     for(i = 0; i < ndimsi++) {
#1727 dimids[i] = i; /* for netCDF-3, dimids are 0, 1, ..., ndims-1 */
#1815 int i;
#1817 for(i = 0; i < ntypesi++) {
#1819     NC_CHECKnc_inq_type(curlocidtypeids[i], curnameNULL) );
dutf8proc.c#120  int i;
#127  for (i=1; i<lengthi++) {
#128    if ((str[i] & 0xC0) != 0x80) return UTF8PROC_ERROR_INVALIDUTF8;
dv2i.c#876 int iel_size;
#884 for (i=0; i<ndimsi++) imp[i] = map[i] / el_size;
#933 int iel_size;
#941 for (i=0; i<ndimsi++) imp[i] = map[i] / el_size;
dvar.c#508   int i;
#513   for(i = 0; i < ndimsi++)
#514      if ((status = nc_inq_dimlen(nciddimids[i], &shape[i])))
#611   int i;
#612   for (i = 0; i < leni++)
#613      free(data[i]);
dvarget.c#36    int i;
#40    for(i=0;i<odom->rank;i++) {
#41 odom->start[i] = (start != NULL ? start[i] : 0);
#42 odom->edges[i] = (edges != NULL ? edges[i] : 1);
#43 odom->stride[i] = (stride != NULL ? stride[i] : 1);
#44 odom->stop[i] = odom->start[i] + (odom->edges[i]*((size_t)odom->stride[i]));
#45 odom->index[i] = odom->start[i];
#64    int i;
#66    for(i=odom->rank-1;i>=0;i--) {
#67        odom->index[i] += (size_t)odom->stride[i];
#68        if(odom->index[i] < odom->stop[i]) break;
#69 if(i == 0) return 0; /* leave the 0th entry if it overflows*/
#70 odom->index[i] = odom->start[i]; /* reset this position*/
#139   int i,simplestride,isrecvar;
#203   for(i=0;i<rank;i++) {
#205 mystart[i] = (start == NULL ? 0 : start[i]);
#207    if(i == 0 && isrecvar)
#208         myedges[i] = numrecs - start[i];
#210       myedges[i] = varshape[i] - mystart[i];
#212     myedges[i] = edges[i];
#213 if(myedges[i] == 0)
#215 mystride[i] = (stride == NULL ? 1 : stride[i]);
#216 if(mystride[i] <= 0
#218           || ((unsigned long) mystride[i] >= X_INT_MAX))
#220   if(mystride[i] != 1) simplestride = 0;
#222 dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
#224 if(mystart[i] >= dimlen)
#227 if(mystart[i] + myedges[i] > dimlen)
dvarput.c#26    int i;
#30    for(i=0;i<odom->rank;i++) {
#31 odom->start[i] = (start != NULL ? start[i] : 0);
#32 odom->edges[i] = (edges != NULL ? edges[i] : 1);
#33 odom->stride[i] = (stride != NULL ? stride[i] : 1);
#34 odom->stop[i] = odom->start[i] + (odom->edges[i]*(size_t)odom->stride[i]);
#35 odom->index[i] = odom->start[i];
#48    int i;
#50    for(i=odom->rank-1;i>=0;i--) {
#51        odom->index[i] += (size_t)odom->stride[i];
#52        if(odom->index[i] < odom->stop[i]) break;
#53 if(i == 0) return 0; /* leave the 0th entry if it overflows*/
#54 odom->index[i] = odom->start[i]; /* reset this position*/
#125   int i,isstride1,isrecvar;
#196   for(i=0;i<rank;i++) {
#198 mystart[i] = (start == NULL ? 0 : start[i]);
#201    if(i == 0 && isrecvar)
#202         myedges[i] = numrecs - start[i];
#204    if(is_recdim[i] && isrecvar)
#205         myedges[i] = varshape[i] - start[i];
#208       myedges[i] = varshape[i] - mystart[i];
#210     myedges[i] = edges[i];
#211 if(myedges[i] == 0)
#213 mystride[i] = (stride == NULL ? 1 : stride[i]);
#214 if(mystride[i] <= 0
#216           || ((unsigned long) mystride[i] >= X_INT_MAX))
#218   if(mystride[i] != 1) isstride1 = 0;
#221 dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
#222 if(i == 0 && isrecvar) {/*do nothing*/}
#224 dimlen = varshape[i];
#225 if(is_recdim[i]) {/*do nothing*/}
#229   if(mystart[i] > dimlen)
#232   if(mystart[i] + myedges[i] > dimlen)
dvlen.c#55   size_t i;
#57   for(i = 0; i < leni++)
#58      if ((ret = nc_free_vlen(&vlens[i])))
escapes.c#113    int i;
#117    for(i=0;i<len;i++) {
#119 escapifychar((unsigned int)s0[i],tmp,quote);
#207    int i;
#213    for(i = 0; i < 128; i++) {
#215        rp[0] = i;
#217        repls[i] = rp;
#219    for(i=0; i < nctablei++) {
#220        size_t j = ctable[i].c;
#222        repls[j] = ctable[i].s;
#224    for(i = 128; i < 256; i++) {
#226        snprintf(rphexlen+1, "_X%2.2X", i); /* need to include null*/
#228        repls[i] = rp;
#230    for(i = 0; i < 256; i++) {
#231        lens[i] = strlen(repls[i]);
#349    int i;
#352    for(i=0;i<len;i++) {
#353 xescapifychar((unsigned int)s0[i],quote,escaped);
#425    int i;
#444    for(i=0;i<len16;i++) {
#445 jescapifychar(s16[i],quote,escaped);
#498    int i;
#515    for(i=0;i<slen;i++) {
#517 unsigned int c = s[i];
#519 if(i > 0) {
#525 if(i == 0 && thischarescaped)
genbin.c#263    unsigned long i;
#289 for(i=0;i<listlength(tsym->subnodes);i++) {
#290   Symboleconst = (Symbol*)listget(tsym->subnodes,i);
#318 for(i=0;i<listlength(tsym->subnodes);i++) {
#319     Symbolefield = (Symbol*)listget(tsym->subnodes,i);
#400    { int i; for(i=0;i<rank;i++) count[i] = indices[i] - start[i];}
#405    int i;
#407    for(i=0;i<rank;i++)
#408 fprintf(stderr,"%s%lu",(i>0?", ":""),(unsigned long)start[i]);
#411    for(i=0;i<rank;i++)
#412 fprintf(stderr,"%s%lu",(i>0?", ":""),(unsigned long)count[i]);
genc.c#100                int i;
#104                for(i=0;i<special->nchunks;i++) {
#106                            (i == 0?"":", "),special->_ChunkSizes[i]);
#703    int i,j;
#714 for(i=0;i<listlength(tsym->subnodes);i++) {
#715     Symboleconst = (Symbol*)listget(tsym->subnodes,i);
#740 for(i=0;i<listlength(tsym->subnodes);i++) {
#741     Symbolefield = (Symbol*)listget(tsym->subnodes,i);
#783    int i;
#812 for(i=0;i<listlength(tsym->subnodes);i++) {
#813     Symboleconst = (Symbol*)listget(tsym->subnodes,i);
#852 for(i=0;i<listlength(tsym->subnodes);i++) {
#854     Symbolefield = (Symbol*)listget(tsym->subnodes,i);
#871 for(i=0;i<listlength(tsym->subnodes);i++) {
#872     Symbolefield = (Symbol*)listget(tsym->subnodes,i);
#971 int i;
#972 for(i=0;i<listlength(vlendecls);i++) {
#973    Bytebufferdecl = (Bytebuffer*)listget(vlendecls,i);
#1002 int i;
#1018         for(i=0;i<rank;i++) length *= count[i];
#1038 for(i=0;i<rank;i++) {
#1039     bbprintf(stmt,"%s%lu",(i>0?", ":""),start[i]);
#1048 for(i=0;i<rank;i++) {
#1049     bbprintf(stmt,"%s%lu",(i>0?", ":""),count[i]);
#1093            int i;
#1094            for(i=0;i<listlength(vlendecls);i++) {
#1095                Bytebufferdecl = (Bytebuffer*)listget(vlendecls,i);
genchar.c#82    int i;
#95    for(i=0;i<data->length;i++) {
#96        NCConstantc = datalistith(data,i);
#122            for(i=0;i<padsize;i++) bbAppend(databuf,fillchar);
#137    int i;
#142    for(i=0;i<data->length;i++) {
#143        c = datalistith(data,i);
#220    int i;
#247 int i,cccount = 0;
#249 for(i=0;i<datalistlen(data);i++) {
#250     NCConstantcon = datalistith(data,i);
#261     for(i=0;i<datalistlen(data);i++) {
#262         con = datalistith(data,i);
#307    for(i=0;i<data->length;i++) {
#308        NCConstantc = datalistith(data,i);
#332            for(i=0;i<padsize;i++) bbAppend(charbuf,fillchar);
generate.c#46    int i;
#47    for(i=0;i<odom->rank;i++) {
#48 ASSERT(odom->index[i] == odom->start[i]+odom->count[i]);
#168                int i,uid;
#174                for(i=0;i<nelems;i++) {
#175                    NCConstantcon = datalistith(vsym->data,i+offset);
#176                    generator->list(generator,vsym,NULL,LISTDATA,uid,i,code);
#179                generator->listend(generator,vsym,NULL,LISTDATA,uid,i,code);
#222    int uid,i;
#246            for(i=0;odometermore(subodom);i++) {
#249                generator->list(generator,vsym,NULL,LISTDATA,uid,i,code);
#253            generator->listend(generator,vsym,NULL,LISTDATA,uid,i,code);
#265        for(i=0;odometermore(subodom);i++) {
#308        int i,uidnfieldsdllen;
#338        for(i=0;i<nfields;i++) {
#339            Symbolfield = (Symbol*)listget(tsym->subnodes,i);
#340            con = datalistith(data,i);
#341            generator->list(generator,field,&offsetbase,LISTCOMPOUND,uid,i,codebuf);
#344        generator->listend(generator,tsym,&offsetbase,LISTCOMPOUND,uid,i,codebuf);
#404    int i;
#425        for(i=0;i<xproduct;i++) {
#426            con = (data == NULL ? NULL : datalistith(data,i));
#427            generator->list(generator,basetype,NULL,LISTFIELDARRAY,uid,i,codebuf);
#430        generator->listend(generator,basetype,NULL,LISTFIELDARRAY,uid,i,codebuf);
genf77.c#147 int i;
#151                for(i=dimset->ndims-1;i>=0;i--) {
#153             Symboldsym = dimset->dimsyms[i];
#339                int i;
#349                for(i=0;i<listlength(calllist);i++) {
#350                    char* callstmt = (char*)listget(calllist,i);
#364     int i;
#366            for(i=0;i<listlength(f77procs);i++) {
#367             Bytebufferproctext = (Bytebuffer*)listget(f77procs,i);
#581    int i;
#589    for(i=0;i<plen;i++) {
#590 Symbolsym = (Symbol*)listget(prefix,i);
#598    i = (rootgroup == (Symbol*)listget(prefix,0))?1:0;
#599    for(;i<plen;i++) {
#600 Symbolsym = (Symbol*)listget(prefix,i);
#723    int i;
#786        for(i=rank-1;i>=0;i--) {
#789 (i==(rank-1)?"":","),
#790 count[i]);
#812 for(i=0;i<dimset->ndims;i++) {
#813     int reverse = (dimset->ndims - i) - 1;
#816     i+1,
#820 for(i=0;i<dimset->ndims;i++) {
#821     int reverse = (dimset->ndims - i) - 1;
#824 i+1,
genj.c#433    int i;
#461 for(i=0;i<rank;i++) {
#462            Symboldsym = dimset->dimsyms[i];
#465     if(i>0) {bbCat(dimbuf,", ");}
#502 for(i=0;i<rank;i++) {
#503     bbprintf(stmt,"%s%lu",(i>0?", ":""),start[i]);
genlib.c#200    int i;
#208    for(i=0;i<plen;i++) {
#209 Symbolsym = (Symbol*)listget(prefix,i);
#217    i = (rootgroup == (Symbol*)listget(prefix,0))?1:0;
#218    for(;i<plen;i++) {
#219 Symbolsym = (Symbol*)listget(prefix,i);
genlib.c#1964 int i;
#1967 for(i = 0; i < 128; i++) {
#1969     rp[0] = i;
#1971     repls[i] = rp;
#1973 for(i=0; i < nctablei++) {
#1974     size_t j = ctable[i].c;
#1976     repls[j] = ctable[i].s;
#1978 for(i = 128; i < 256; i++) {
#1980     snprintf(rphexlen, "_X%2.2X", i);
#1982     repls[i] = rp;
#1984 for(i = 0; i < 256; i++) {
#1985     lens[i] = strlen(repls[i]);
getfill.c#53    unsigned long i;
#65        for(i=0;i<listlength(tsym->subnodes);i++) {
#66     Symbolfield = (Symbol*)listget(tsym->subnodes,i);
#87    int i;
#100        for(i=0;i<listlength(tsym->subnodes);i++) {
#101     Symbolfield = (Symbol*)listget(tsym->subnodes,i);
#120    int i;
#138     for(i=0;i<size;i++) filllist(basetype,sublist);
#140     for(i=0;i<size;i++) {
getvara.c#100    int i;
#134    for(i=0;i<nclistlength(varnodes);i++) {
#135 CDFnodenode = (CDFnode*)nclistget(varnodes,i);
#162int i;
#164for(i=0;i<ncrank;i++)
#166 (long)startp[i],
#167 (long)countp[i],
#168 (long)stridep[i]
#180        for(i=0;i<ncrank;i++) {
#181     CDFnodedim = (CDFnode*)nclistget(ncdimsall,i);
#182     localcount[i] = dim->dim.declsize;
#191    for(i=0;i<ncrank;i++) {
#192      CDFnodedim = (CDFnode*)nclistget(ncdimsall,i);
#194      if(stridep[i] < 1) {
#198      if(startp[i] >= dim->dim.declsize
#199  || startp[i]+(stridep[i]*(countp[i]-1)) >= dim->dim.declsize) {
#209if(nclistlength(dims) > 0) {int i;
#210for(i=0;i<nclistlength(dims);i++)
#211fprintf(stderr,"(%lu:%lu:%lu)",(unsigned long)startp[i],(unsigned long)countp[i],(unsigned long)stridep[i]);
#213for(i=0;i<nclistlength(dims);i++)
#214if(stridep[i]==1)
#215fprintf(stderr,"[%lu:%lu]",(unsigned long)startp[i],(unsigned long)((startp[i]+countp[i])-1));
#217unsigned long iend = (stridep[i] * countp[i]);
#218iend = (iend + startp[i]);
#221(unsigned long)startp[i],(unsigned long)stridep[i],iend);
#432    int i;
#436    for(i=0;i<nclistlength(proj->var->segments);i++) {
#437 DCEsegmentseg = (DCEsegment*)nclistget(proj->var->segments,i);
#696    unsigned int i;
#698    for(point=-1,i=0;i<odom->rank;i++) {
#699        ASSERT((odom->size[i] != 0));
#700        if(odom->start[i] != 0 || odom->stride[i] != 1
#701           || odom->count[i] != odom->size[i])
#702     point = i;
#717    size_t i;
#718    for(i=0;i<nclistlength(node->subnodes);i++) {
#719        CDFnodetest = (CDFnode*) nclistget(node->subnodes,i);
#720        if(test == field) return i;
#893    unsigned int i;
#913    for(i=slice->first;i<slice->length;i+=slice->stride) {
#914        if(i < stringlen)
#915            *memory->next = stringmem[i];
#946    int i;
#981    for(i=0;i<nclistlength(strings);i++) {
#982 char* s = (char*)nclistget(strings,i);
#1022    unsigned int i;
#1024    for(i=0;i<nclistlength(xtree->nodes);i++) {
#1025 CDFnodexnode = (CDFnode*)nclistget(xtree->nodes,i);
#1049    unsigned int i;
#1050    for(i=0;i<nclistlength(xnode->array.dimsetall);i++) {
#1051 CDFnodexdim = (CDFnode*)nclistget(xnode->array.dimsetall,i);
#1052 CDFnodetdim = (CDFnode*)nclistget(pattern->array.dimsetall,i);
#1069    unsigned int i,plen,lastnode,gridable;
#1097    for(i=0;i<nclistlength(xnode->subnodes);i++) {
#1098        CDFnodexsubnode = (CDFnode*)nclistget(xnode->subnodes,i);
#1138    unsigned int i;
#1153    for(fieldindex=0,i=0;i<nclistlength(pattern->subnodes) && fieldindex<nclistlength(target->subnodes);i++) {
#1154        CDFnodepatternsubnode = (CDFnode*)nclistget(pattern->subnodes,i);
#1211    int i;
#1243    for(i=0;i<nclistlength(varnodes);i++) {
#1244 CDFnodenode = (CDFnode*)nclistget(varnodes,i);
#1290    for(i=0;i<ncrank;i++) {
#1291 CDFnodedim = (CDFnode*)nclistget(ncdims,i);
#1292 dimsizes[i] = dim->dim.declsize;
#1293 nelems *= edges[i];
#1342    for(i=0;i<nelems;i++) {
#1345 char* localpos = (localcopy + externsize*i);
large_files.c#39   int recijk;
#135       for(i=0; i<I_LENi++) {
#137           var1[j] = (float)(j + (rec+1) * i);
#139         var1_start[1] = i;
#171       for(i=0; i<I_LENi++) {
#172         avar1_start[1] = i;
#177           if (avar1[j] != (float)(j + (rec + 1) * i)) {
#179                    "should be %g !\n", recijavar1[j], (float) (j + (rec + 1)* i));
list.c#97  int i; /* do not make unsigned */
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#133listremove(Listl, unsigned long i)
#138  if(i >= len) return NULL;
#139  elem = l->content[i];
#140  for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#158    unsigned long i;
#159    for(i=0;i<listlength(l);i++) {
#160 if(elem == listget(l,i)) return 1;
#170  unsigned long i;
#173  for(i=0;i<listlength(l);i++) {
#174    void* candidate = l->content[i];
#176      for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#196    unsigned long i,j,k,len;
#201    for(i=0;i<len;i++) {
#202        for(j=i+1;j<len;j++) {
#203     if(content[i] == content[j]) {
list.h#34EXTERNC void* listremove(Listl, unsigned long i);
lookup3.c#282  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
#289  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
#355  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
#462  union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */
#468  if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {
#613  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
#619  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
#685  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
#799  uint32_t i;
#804  for (i=0; i<256; ++ibuf[i] = 'x';
#805  for (i=0; i<1; ++i)
#821  uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, klm=0, z;
#830    for (i=0; i<hlen; ++i)  /*----------------------- for each input byte, */
#846     a[i] ^= (k<<j);
#847     a[i] ^= (k>>(8-j));
#849     b[i] ^= ((k+1)<<j);
#850     b[i] ^= ((k+1)>>(8-j));
#871      printf("i %d j %d m %d len %d\n", ijmhlen);
#880      printf("Mix success  %2d bytes  %2d initvals  ",i,m);
#895  uint32_t i;
#942  i=47; j=0;
#943  hashlittle2(q, sizeof(q), &i, &j);
#944  if (hashlittle(q, sizeof(q), 47) != i)
#949  i=47, j=0;
#950  hashword2(&len, 1, &i, &j);
#951  if (hashword(&len, 1, 47) != i)
#953    ihashword(&len, 1, 47));
#958    for (i=0; i<MAXLEN; ++i)
#960      len = i;
#961      for (j=0; j<i; ++j) *(b+j)=0;
#965      *(b+i)=(uint8_t)~0;
#972               hi);
#982  uint32_t h,i,state[HASHSTATE];
#986  for (i=0; i<HASHSTATE; ++istate[i] = 1;
#988  for (i=0, h=0; i<8; ++i)
#991    printf("%2ld  0-byte strings, hash is  %.8x\n", ih);
nc.h#97extern int iterate_NCList(int i,NC**); /* Walk from 0 ...; ERANGE return => stop */
nc3dispatch.c#359    int i;
#360    for (i = 0; i <= ATOMICTYPEMAX3i++)
#361        if (!strcmp(nameNC_atomictypename(i))) {
#362            if (typeidp) *typeidp = i;
nc3internal.c#915 int i;
#917           for(i = 0; i < last_fix->ndimsi++ ) {
#918                varsize *= (last_fix->shape ? last_fix->shape[i] : 1);
nc4attr.c#43   int i;
#162  for (i = 0; i < att->leni++)
#164     vldest[i].len = att->vldata[i].len;
#165     if (!(vldest[i].p = malloc(vldest[i].len * base_typelen)))
#167     memcpy(vldest[i].patt->vldata[i].pvldest[i].len * base_typelen);
#172  for (i = 0; i < att->leni++)
#175            if(att->stdata[i])
#177                if (!(((char **)data)[i] = strdup(att->stdata[i])))
#181                ((char **)data)[i] = att->stdata[i];
#192     for (i = 0; i < att->leni++)
#222   int i;
#341      for (i = 0; i < att->leni++)
#342         if(att->stdata[i])
#343     free(att->stdata[i]);
#349      for (i = 0; i < att->leni++)
#350  nc_free_vlen(&att->vldata[i]);
#473         for (i = 0; i < att->leni++)
#475            att->vldata[i].len = vldata1[i].len;
#476            if (!(att->vldata[i].p = malloc(base_typelen * att->vldata[i].len)))
#478            memcpy(att->vldata[i].pvldata1[i].pbase_typelen * att->vldata[i].len);
#496        for (i = 0; i < att->leni++)
#498            if(NULL != ((char **)data)[i]) {
#499              LOG((5, "copying string %d of size %d", i, strlen(((char **)data)[i]) + 1));
#500              if (!(att->stdata[i] = strdup(((char **)data)[i])))
#504              att->stdata[i] = ((char **)data)[i];
nc4file.c#1130     int i;
#1147     for (i = 0; i < att->leni++)
#1149          if (!(att->stdata[i] = malloc(fixed_size))) {
#1153           strncpy(att->stdata[i], curfixed_size);
#1410            int i;
#1445            for (i = 0; i < type->u.e.num_membersi++)
#1449               if (!(member_name = H5Tget_member_name(hdf_typeidi)))
#1464               if (H5Tget_member_value(hdf_typeidivalue) < 0)
#1847   hsize_t num_obji;
#1856   for (i = 0; i < num_obji++)
#1858      if ((attid = H5Aopen_idx(grp->hdf_grpid, (unsigned int)i)) < 0)
nc4grp.c#246   int iret = NC_NOERR;
#267   for (i = 1; i < g && !reti++)
#268      ret = NC4_inq_grp_parent(gid[i - 1], &gid[i]);
#271   for (i = g - 1; !ret && i >= 0 && !reti--)
#273      if ((ret = NC4_inq_grpname(gid[i], grp_name)))
#276      if (i)
nc4hdf.c#558  int retval = NC_NOERRrange_error = 0, id2;
#584  for (i = 0; i < var->ndimsi++)
#586      start[i] = startp[i];
#587      count[i] = countp[i];
#884  int scalar = 0, retval = NC_NOERRrange_error = 0, id2;
#909  for (i = 0; i < var->ndimsi++)
#911      start[i] = startp[i];
#912      count[i] = countp[i];
#1209      for (i = 0; i < fill_leni++)
#3962    int t,i;
#3981 for(i=0;i<ocount;i++) {
#3982     hid_t o = idlist[i];
#4084    int i,j,na;
#4096    for(i = 0; i < nobji++) {
#4098        len = H5Gget_objname_by_idx(gid,(hsize_t)i,name,(size_t)NC_HDF5_MAX_NAME);
#4101        otype =  H5Gget_objtype_by_idx(gid,(size_t)i);
nc4internal.c#860      int i;
#868      for (i = 0; i < ndimsi++)
#869  field->dim_size[i] = dim_sizesp[i];
#1222   int i;
#1248      for (i = 0; i < att->leni++)
#1249         if(att->stdata[i])
#1250     free(att->stdata[i]);
#1257      for (i = 0; i < att->leni++)
#1258  nc_free_vlen(&att->vldata[i]);
nc4type.c#92   int iretval;
#94   for (i = 0; i < NUM_ATOMIC_TYPESi++)
#95      if (!strcmp(nameatomic_name[i]))
#98     *typeidp = i;
#571   int i;
#590   for (i = 0; i < type->u.e.num_membersi++)
#631   if (i == type->u.e.num_members)
#646   int i;
#669   for (i = 0; i < idxi++)
nc4var.c#1025   int iretval;
#1047      for (i = 0; i < var->ndimsi++)
#1049  chunksizesp[i] = (int)cs[i];
#1050  if (cs[i] > NC_MAX_INT)
#1071   int iretval;
#1093   for (i = 0; i < var->ndimsi++)
#1094      cs[i] = chunksizesp[i];
nc_hashmap.c#19  int i;
#21  for (i = 9; i--;)
#139    unsigned long i;
#143    for (i = 0; i < hash->sizei++)
#186    unsigned long i;
#190    for (i = 0; i < hash->sizei++)
#224  unsigned long i;
#231  for (i = 0; i < hash->sizei++)
#261  unsigned long i;
#268  for (i = 0; i < hash->sizei++)
#304    unsigned long i;
#308    for (i = 0; i < hash->sizei++)
#338    unsigned long i;
#342    for (i = 0; i < hash->sizei++)
nc_iter.c#92    int i;
#94        for(i = 0; i < iter->right_dimi++) {
#95            start[i] = 0;
#96            count[i] = 1;
#100        for(i = iter->right_dim + 1; i < iter->ranki++) {
#101            start[i] = 0;
#102            count[i] = iter->dimsizes[i];
#123    for(i = 0; i < iter->ranki++) {
#124 iter->to_get *= count[i];
#141    int i;
#147    for(i = 0; i < ranki++)
#148 iter->dimsizes[i] = dims[i];
#151    for(i = ranki > 0; i--) {
#152        if(prod*dims[i-1] <= bufsize) {
#153            prod *= dims[i-1];
#159    if (i > 0) {         /* variable won't fit in bufsize bytes */
#216    int i;
#218    for(i=0;i<ndims;i++) {
#219 Symboldim = sym->typ.dimset.dimsyms[i];
#220 dimlens[i] = dim->dim.declsize;
nc_test.c#87    int i;
#115    for (i = 1; i <= NUM_FORMATSi++)
#121       switch (i)
ncaux.c#90    int i;
#94    for(i=0;i<cmpd->nfields;i++) {
#95 struct NCAUX_FIELDfield = &cmpd->fields[i];
#109    int i;
#117    for(i=0;i<ndims;i++) {
#118 if(dimsizes[i] <= 0) {status = NC_EINVAL; goto done;}
#144    int i;
#146    for(i=0;i<ndims;i++) product *= (size_t)dimsizes[i];
#153    int i;
#166    for(i=0;i<cmpd->nfields;i++) {
#167 struct NCAUX_FIELDfield = &cmpd->fields[i];
#351    int i;
#357    for(i=0;i<cmpd->nfields;i++) {
#358 struct NCAUX_FIELDfield = &cmpd->fields[i];
#365    for(offset=0,i=0;i<cmpd->nfields;i++) {
#366        struct NCAUX_FIELDfield = &cmpd->fields[i];
ncbytes.c#85  unsigned long i;
#87  for(i=0;i<bb->length;i++) bb->content[i] = fill;
#153  int i; /* do not make unsigned */
#157  for(i=(int)bb->alloc;i>=1;i--) {bb->content[i]=bb->content[i-1];}
nccopy.c#307    int i;
#311    for(i = 0; i < nmembersi++) { /* insert enum members */
#314 NC_CHECK(nc_inq_enum_member(igrpitypeiename, &val));
#404    int i;
#412 for(i = 1; i < numgrpsi++) {
#418     NC_CHECK(nc_inq_grpname(grpids[i], grpname));
#419     if (option_grpstruct || group_wanted(grpids[i], option_nlgrpsoption_grpids)) {
#420         NC_CHECK(nc_inq_grpname_full(grpids[i], &len_nameNULL));
#422 NC_CHECK(nc_inq_grpname_full(grpids[i], &len_namegrpname_full));
#434 NC_CHECK(nc_inq_grpname(grpids[i], grpname));
#457    int i;
#464 for (i = 0; i < ntypesi++) {
#465     NC_CHECK(copy_type(igrptypes[i], ogrp));
#475 for(i = 0; i < numgrpsi++) {
#476     if (option_grpstruct || group_wanted(grpids[i], option_nlgrpsoption_grpids)) {
#481 NC_CHECK(get_grpid(grpids[i], ogrp, &ogid));
#482 NC_CHECK(copy_types(grpids[i], ogid));
#804    int i;
#824    for(i = 0; i < ndimsi++) {
#825 odimids[i] = dimmap_odimid(idimids[i]);
#826 if(odimids[i] == -1) {
#827     error("Oops, no dimension in output associated with input dimid %d", idimids[i]);
#913 int i;
#919 for(i = 0; i < numgrpsi++) {
#920     if (option_grpstruct || group_wanted(grpids[i], option_nlgrpsoption_grpids)) {
#921         NC_CHECK(copy_schema(grpids[i], ogid));
#1084    int i;
#1122    for(i = 0; i < numgrpsi++) {
#1123        if (!option_grpstruct && !group_wanted(grpids[i], option_nlgrpsoption_grpids))
#1125 NC_CHECK(copy_data(grpids[i], ogid));
ncd2dispatch.c#192    int i;
#197    for(i=0;i<NC_MAX_VAR_DIMS;i++) {
#198 dap_one[i] = 1;
#199 dap_zero[i] = 0;
#656    int i;
#671        for(i=0;i<last;i++) {
#672     CDFnodedim1 = (CDFnode*)nclistget(dimset,i);
#673     CDFnodedim2 = (CDFnode*)nclistget(dimset,i+1);
#675 nclistset(dimset,i,(void*)dim2);
#676 nclistset(dimset,i+1,(void*)dim1);
#707    for(i=0;i<nclistlength(dimset);i++) {
#708 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#725    for(i=0;i<nclistlength(dimset);i++) {
#726 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#741    int i,j;
#749    for(i=0;i<nclistlength(varnodes);i++) {
#750 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#817    int i;
#826        for(i=0;i<nclistlength(root->attributes);i++) {
#827        NCattributeatt = (NCattribute*)nclistget(root->attributes,i);
#837        for(i=0;i<nclistlength(cdfnodes);i++) {
#838     CDFnodedim = (CDFnode*)nclistget(cdfnodes,i);
#899    int i;
#912 for(i=0;i<nvalues;i++) {
#913     char* s = (char*)nclistget(att->values,i);
#921 for(i=0;i<nvalues;i++) {
#922     char* s = (char*)nclistget(att->values,i);
#923     if(i > 0) strcat(newstring,"\n");
#1025    int i,j;
#1039    for(i=0;i<nclistlength(varnodes);i++) {
#1040 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#1054    for(i=0;i<nclistlength(alldims);i++) {
#1056 CDFnodebasedim = (CDFnode*)nclistget(alldims,i);
#1059 for(j=i+1;j<nclistlength(alldims);j++) { /* Sigh, n**2 */
#1079    for(i=0;i<nclistlength(alldims);i++) {
#1080 CDFnodebasedim = (CDFnode*)nclistget(alldims,i);
#1084        for(j=i+1;j<nclistlength(alldims);j++) {
#1107    for(i=0;i<nclistlength(varnodes);i++) {
#1108 CDFnodenode = (CDFnode*)nclistget(varnodes,i);
#1116    for(i=0;i<nclistlength(alldims);i++) {
#1117 CDFnodedim = (CDFnode*)nclistget(alldims,i);
#1131    for(i=0;i<nclistlength(basedims);i++) {
#1132 CDFnodedim = (CDFnode*)nclistget(basedims,i);
#1163    for(i=0;i<nclistlength(basedims);i++) {
#1164 CDFnodedim1 = (CDFnode*)nclistget(basedims,i);
#1170 for(j=nclistlength(basedims)-1;j>i;j--) {
#1184for(i=0;i<nclistlength(basedims);i++) {
#1185CDFnodedim = (CDFnode*)nclistget(basedims,i);
#1212    int i,len;
#1269    for(i=0;i<nclistlength(nccomm->cdf.ddsroot->tree->varnodes);i++) {
#1270 CDFnodevar = (CDFnode*)nclistget(nccomm->cdf.ddsroot->tree->varnodes,i);
#1283    for(i=0;i<nclistlength(nccomm->cdf.ddsroot->tree->nodes);i++) {
#1284 CDFnodevar = (CDFnode*)nclistget(nccomm->cdf.ddsroot->tree->nodes,i);
#1328    int i;
#1330    for(i=0;i<nclistlength(dimset);i++) {
#1331 CDFnodecandidate = (CDFnode*)nclistget(dimset,i);
#1333    dim->dim.index1=i+1;
#1343    int i;
#1344    for(i=0;i<nclistlength(dims);i++) {
#1345        CDFnodedim = (CDFnode*)nclistget(dims,i);
#1348 nclistset(dims,i,(void*)basedim);
#1371    int i;
#1372    for(i=0;i<nclistlength(dimset);i++) {
#1373 CDFnodedim = (CDFnode*)nclistget(dimset,i);
#1390    int i;
#1395    for(i=0;i<nclistlength(varnodes);i++) {
#1396 CDFnodenode = (CDFnode*)nclistget(varnodes,i);
#1414    int i;
#1434    for(i=0;i<nclistlength(varnodes);i++) {
#1435 CDFnodevar = (CDFnode*)nclistget(varnodes,i);
#1478    unsigned int i;
#1485    for(i=0;i<nclistlength(basedims);i++) {
#1486        CDFnodedim = (CDFnode*)nclistget(basedims,i);
#1499    unsigned int i = 0;
#1515    for(i=0;i<nclistlength(dapcomm->cdf.ddsroot->tree->seqnodes);i++) {
#1516        CDFnodeseq = (CDFnode*)nclistget(dapcomm->cdf.ddsroot->tree->seqnodes,i);
#1554    int i,rank;
#1562    for(i=0;i<nclistlength(path);i++) {
#1563        CDFnodenode = (CDFnode*)nclistget(path,i);
#1564 if(i > 0) ncbytescat(projection,".");
#1570    for(i=0;i<rank;i++) {
#1571 CDFnodedim = (CDFnode*)nclistget(var->array.dimset0,i);
#1682    unsigned int i;
#1706    for(i=0;i<nclistlength(path);i++) {
#1707        CDFnodecurrent = (CDFnode*)nclistget(path,i);
#1724     next = (CDFnode*)nclistget(path,i+1);
#1786    unsigned int i;
#1787    for(i=0;i<nclistlength(parent->subnodes);i++) {
#1788 CDFnodenode = (CDFnode*)nclistget(parent->subnodes,i);
#1789 if(node == child) return i;
#1808    int i,j;
#1822    for(i=0;i<nclistlength(path);i++) {
#1823 CDFnodenode = (CDFnode*)nclistget(path,i);
#1824 if(i > 0) ncbytescat(seqcountconstraints,".");
#1902    unsigned int i;
#1908    for(i=0;i<nclistlength(node->subnodes);i++) {
#1909        CDFnodesubnode = (CDFnode*)nclistget(node->subnodes,i);
#1929    unsigned int i;
#1932 for(i=0;i<nclistlength(dimensions);i++) {
#1933     CDFnodedim = (CDFnode*)nclistget(dimensions,i);
#2105    int i,j;
#2112 for(i=nclistlength(dapcomm->cdf.ddsroot->tree->varnodes)-1;i>=0;i--) {
#2113     CDFnodevar = (CDFnode*)nclistget(dapcomm->cdf.ddsroot->tree->varnodes,i);
#2130        if(foundnclistremove(dapcomm->cdf.ddsroot->tree->varnodes,i);
#2144    int i,j;
#2145    for(i=0;i<nclistlength(dapcomm->cdf.ddsroot->tree->varnodes);i++) {
#2146 CDFnodevar = (CDFnode*)nclistget(dapcomm->cdf.ddsroot->tree->varnodes,i);
ncdump.c#837       int classi;
#873    for (i = 0; i < att.leni++) {
#875        printf("%s%s", souti < att.len-1 ? ", " : "");
#883    for (i = 0; i < att.leni++) {
#888    value = *((char *)data + i);
#891    value = *((unsigned char *)data + i);
#894    value = *((short *)data + i);
#897    value = *((unsigned short *)data + i);
#900    value = *((int *)data + i);
#903    value = *((unsigned int *)data + i);
#906    value = *((int64_t *)data + i);
#909    value = *((uint64_t *)data + i);
#918        printf("%s", i < att.len-1 ? ", " : "");
#995    int i;
#1003     for(i = 0; i < varp->ndimsi++) {
#1004 printf("%lu%s", (unsigned long)chunkp[i], i+1 < varp->ndims ? ", " : " ;\n");
#2095    int i;
#2259    i = 0;
#2264 char *path = strdup(argv[i]);
#2266     error("out of memory copying argument %s", argv[i]);
ncgenl.c#2267 register int number_to_movei;
#2298 for ( i = 0; i < number_to_move; ++i )
#2890 yy_size_t ni;
#2898 for ( i = 0; i < _yybytes_len; ++i )
#2899 buf[i] = yybytes[i];
#3079 register int i;
#3080 for ( i = 0; i < n; ++i )
#3081 s1[i] = s2[i];
ncgentab.c#2093    size_t isl;
#2098        for (i =len;i<sl;i++)
#2099    char_valp[i] = '\0';
#2570    int i;
#2571    for(i=0; i<nattsi++) { /* expensive */
#2572        if(atts[i].var == varnum &&
#2573           STREQ(atts[i].name,atts[natts].name)) {
ncgeny.c#291static Symbolmakeprimitivetype(nc_type i);
#429YYID (int i)
#432YYID (i)
#433    int i;
#436  return i;
#1889 int i;
#1904                for(i=stackbase;i<stacklen;i++) {
#1905                   Symboleid = (Symbol*)listget(stack,i);
#1924     int i;
#1929     for(i=stackbase;i<stacklen;i++) {
#1930       Symbolelem = (Symbol*)listget(stack,i);
#1980     int i,j;
#1986     for(i=stackbase;i<stacklen;i++) {
#1987       Symbolelem1 = (Symbol*)listget(stack,i);
#1988       for(j=i+1;j<stacklen;j++) {
#2001     for(i=stackbase;i<stacklen;i++) {
#2002         Symbolfsym = (Symbol*)listget(stack,i);
#2023     int i;
#2028            for(i=stackbase;i<stacklen;i++) {
#2029                Symbolf = (Symbol*)listget(stack,i);
#2167     int i;
#2171             for(i=stackbase;i<stacklen;i++) {
#2172                 Symbolsym = (Symbol*)listget(stack,i);
#2202     int i;
#2215         for(i=0;i<count;i++) {
#2216     Symboldsym = (Symbol*)listget(stack,stackbase+i);
#2217     dimset.dimsyms[i] = dsym;
#2276 int i;
#2289     for(i=0;i<count;i++) {
#2290         Symboldsym = (Symbol*)listget(stack,stackbase+i);
#2291         dimset.dimsyms[i] = dsym;
#2985    int i;
#3002    for(i=NC_NAT+1;i<=NC_STRING;i++) {
#3003        primsymbols[i] = makeprimitivetype(i);
#3172    int i;
#3177    for(i=0;i<listlength(grp->subnodes);i++) {
#3178 Symbolsym = (Symbol*)listget(grp->subnodes,i);
#3383                int i;
#3386                for(i=0;i<special->nchunks;i++) {
#3388                    convert1(&list->data[i],&iconst);
#3390                        special->_ChunkSizes[i] = (size_t)iconst.value.int32v;
#3460        int i;
#3462        for(i=0;i<list->length;i++,con++) {
ncgenyy.c#1617 register int number_to_movei;
#1648 for ( i = 0; i < number_to_move; ++i )
#2241 int i;
#2249 for ( i = 0; i < _yybytes_len; ++i )
#2250 buf[i] = yybytes[i];
#2430 register int i;
#2431 for ( i = 0; i < n; ++i )
#2432 s1[i] = s2[i];
nchashmap.c#48    int i;
#49    for(i=0;i<hm->alloc;i++) {
#50 if(hm->table[i] != NULLnclistfree(hm->table[i]);
#63    int i;
#73    for(i=0;i<len;i+=2,list+=2) {
#87    int i;
#97    for(i=0;i<len;i+=2,list+=2) {
#111    size_t i;
#121    for(i=0;i<len;i+=2,list+=2) {
#123     nclistremove(seq,(i+1));
#124     nclistremove(seq,i);
#146    int i;
#156    for(i=0;i<len;i+=2,list+=2) {
#167    int i;
#169    for(i=0;i<hm->alloc;i++) {
#170 NClistseq = hm->table[i];
#188    int i,j,index;
#195        for(index=0,i=0;i<hm->alloc;i++) {
#196      NClistseq = hm->table[i];
nchashmap.h#51externC int nchashith(NChashmap*, int inchashid*, void**);
nciter.c#27    int i;
#38 for(i = ranki > 0; i--) {
#39     if(prod*dims[i-1] <= bufsize) {
#40 prod *= dims[i-1];
#46 if (i > 0) {      /* variable won't fit in bufsize bytes */
#61    for(i = 0; i < ranki++) {
#62 prod *= iter->chunksizes[i];
#244    int i;
#250     for(i = 0; i < iter->right_dimi++) {
#251 start[i] = 0;
#252 count[i] = 1;
#256     for(i = iter->right_dim + 1; i < iter->ranki++) {
#257 start[i] = 0;
#258 count[i] = iter->dimsizes[i];
#261     for(i = 0; i < iter->ranki++) {
#262 start[i] = 0;
#263 if(iter->chunksizes[i] <= iter->dimsizes[i])
#264     count[i] = iter->chunksizes[i];
#266     count[i] = iter->dimsizes[i];
#290     for(i = 0; i < iter->ranki++) {
#291 int leftover = iter->dimsizes[i] - start[i];
#292 if(iter->chunksizes[i] <= iter->dimsizes[i])
#293     count[i] = iter->chunksizes[i];
#295     count[i] = iter->dimsizes[i];
#296 if(leftover < count[i])
#297     count[i] = leftover;
#302    for(i = 0; i < iter->ranki++) {
#303 iter->to_get *= count[i];
nclist.c#97  int i; /* do not make unsigned */
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#133nclistremove(NClistl, unsigned long i)
#138  if(i >= len) return NULL;
#139  elem = l->content[i];
#140  for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#158    unsigned long i;
#159    for(i=0;i<nclistlength(l);i++) {
#160 if(elem == nclistget(l,i)) return 1;
#170  unsigned long i;
#173  for(i=0;i<nclistlength(l);i++) {
#174    void* candidate = l->content[i];
#176      for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#196    unsigned long i,j,k,len;
#201    for(i=0;i<len;i++) {
#202        for(j=i+1;j<len;j++) {
#203     if(content[i] == content[j]) {
nclist.h#34EXTERNC void* nclistremove(NClistl, unsigned long i);
nclistmgr.c#39    int i;
#53    for(i=1; i < NCFILELISTLENGTHi++) {
#54 if(nc_filelist[i] == NULL) {new_id = i; break;}
#100   int i;
#104   for(i=1; i < NCFILELISTLENGTHi++) {
#105 if(nc_filelist[i] != NULL) {
#106     if(strcmp(nc_filelist[i]->path,path)==0) {
#107 f = nc_filelist[i];
nclog.c#207        int i;
#209 for(i=0;i<MAXTAGS;i++) {if(tagset[i]==NULL) break;}
#210 nctagsize = i;
ncpdispatch.c#1339    int i;
#1340    for (i = 0; i <= ATOMICTYPEMAX5i++)
#1341        if(!strcmp(nameNC_atomictypename(i))) {
#1342            if(typeidp) *typeidp = i;
nctestserver.c#32 int i;
#33 for(i=2;i<argc;i++,nservers++)
#34     serverlist[i-2] = argv[i];
nctime.c#99 int i; /* month counter */
#122 for (i = 0; i < 12; i++) {
ncuri.c#98    int i,nprotos;
#181    for(i=0;i<nprotos;i++) {
#182        if(strcmp(protocol,legalprotocols[i].name)==0) {
#183     proto = &legalprotocols[i];
#601    int i,c;
#632    for(cp=params,i=0;i<nparams;i++) {
#638 plist[2*i] = nulldup(cp);
#639 plist[2*i+1] = nulldup(vp);
#653  int i;
#657 i = ncuridecodeparams(uri);
#658 if(!i) return 0;
#661  i = ncfind(uri->paramlist,key);
#662  if(i < 0)
#666    value = uri->paramlist[(2*i)+1];
#688    int i;
#690    for(i=0,p=params;*p;p+=2,i++) {
#691 if(strcmp(key,*p)==0) return i;
ncx.c#5211  long ijni;
#5233    for (i=0; i<nii++) {
#5234      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#5238      nrange += xp[i] > SHORT_MAX || xp[i] < SHORT_MIN;
#5277  long ijni;
#5299    for (i=0; i<nii++) {
#5300      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#5304      nrange += xp[i] > SCHAR_MAX || xp[i] < SCHAR_MIN;
#5342  long ijni;
#5364    for (i=0; i<nii++) {
#5365      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#5369      nrange += xp[i] > INT_MAX || xp[i] < INT_MIN;
#5407  long ijni;
#5429    for (i=0; i<nii++) {
#5430      tp[i] = (float) MaxFLOAT_MINMin(FLOAT_MAX, (float) xp[i]));
#5434      nrange += xp[i] > FLOAT_MAX || xp[i] < FLOAT_MIN;
#5472  long ijni;
#5494    for (i=0; i<nii++) {
#5495      tp[i] = (double) MaxDOUBLE_MINMin(DOUBLE_MAX, (double) xp[i]));
#5499      nrange += xp[i] > DOUBLE_MAX || xp[i] < DOUBLE_MIN;
#5537  long ijni;
#5559    for (i=0; i<nii++) {
#5560      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#5564      nrange += xp[i] > LONGLONG_MAX || xp[i] < LONGLONG_MIN;
#5602  long ijni;
#5624    for (i=0; i<nii++) {
#5625      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#5629      nrange += xp[i] > UCHAR_MAX || xp[i] < 0;
#5667  long ijni;
#5689    for (i=0; i<nii++) {
#5690      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#5694      nrange += xp[i] > USHORT_MAX || xp[i] < 0;
#5732  long ijni;
#5754    for (i=0; i<nii++) {
#5755      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#5759      nrange += xp[i] > UINT_MAX || xp[i] < 0;
#5797  long ijni;
#5819    for (i=0; i<nii++) {
#5820      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#5824      nrange += xp[i] > ULONGLONG_MAX || xp[i] < 0;
#6088  long ijni;
#6109    for (i=0; i<nii++) {
#6111      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6115      nrange += tp[i] > X_SHORT_MAX || tp[i] < X_SHORT_MIN;
#6159  long ijni;
#6180    for (i=0; i<nii++) {
#6182      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6186      nrange += tp[i] > X_SHORT_MAX || tp[i] < X_SHORT_MIN;
#6229  long ijni;
#6250    for (i=0; i<nii++) {
#6252      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6256      nrange += tp[i] > X_SHORT_MAX || tp[i] < X_SHORT_MIN;
#6299  long ijni;
#6320    for (i=0; i<nii++) {
#6322      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6326      nrange += tp[i] > X_SHORT_MAX || tp[i] < X_SHORT_MIN;
#6369  long ijni;
#6390    for (i=0; i<nii++) {
#6392      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6396      nrange += tp[i] > X_SHORT_MAX || tp[i] < X_SHORT_MIN;
#6439  long ijni;
#6460    for (i=0; i<nii++) {
#6462      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6466      nrange += tp[i] > X_SHORT_MAX || tp[i] < X_SHORT_MIN;
#6509  long ijni;
#6530    for (i=0; i<nii++) {
#6532      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6536      nrange += tp[i] > X_SHORT_MAX ;
#6579  long ijni;
#6600    for (i=0; i<nii++) {
#6602      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6606      nrange += tp[i] > X_SHORT_MAX ;
#6649  long ijni;
#6670    for (i=0; i<nii++) {
#6672      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6676      nrange += tp[i] > X_SHORT_MAX ;
#6719  long ijni;
#6740    for (i=0; i<nii++) {
#6742      xp[i] = (short) MaxX_SHORT_MINMin(X_SHORT_MAX, (short) tp[i]));
#6746      nrange += tp[i] > X_SHORT_MAX ;
#7058  long ijni;
#7080    for (i=0; i<nii++) {
#7081      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#7085      nrange += xp[i] > USHORT_MAX ;
#7124  long ijni;
#7146    for (i=0; i<nii++) {
#7147      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#7151      nrange += xp[i] > SCHAR_MAX ;
#7189  long ijni;
#7211    for (i=0; i<nii++) {
#7212      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#7216      nrange += xp[i] > SHORT_MAX ;
#7254  long ijni;
#7276    for (i=0; i<nii++) {
#7277      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#7281      nrange += xp[i] > INT_MAX ;
#7319  long ijni;
#7341    for (i=0; i<nii++) {
#7342      tp[i] = (float) MaxFLOAT_MINMin(FLOAT_MAX, (float) xp[i]));
#7346      nrange += xp[i] > FLOAT_MAX ;
#7384  long ijni;
#7406    for (i=0; i<nii++) {
#7407      tp[i] = (double) MaxDOUBLE_MINMin(DOUBLE_MAX, (double) xp[i]));
#7411      nrange += xp[i] > DOUBLE_MAX ;
#7449  long ijni;
#7471    for (i=0; i<nii++) {
#7472      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#7476      nrange += xp[i] > LONGLONG_MAX ;
#7514  long ijni;
#7536    for (i=0; i<nii++) {
#7537      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#7541      nrange += xp[i] > UCHAR_MAX ;
#7579  long ijni;
#7601    for (i=0; i<nii++) {
#7602      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#7606      nrange += xp[i] > UINT_MAX ;
#7644  long ijni;
#7666    for (i=0; i<nii++) {
#7667      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#7671      nrange += xp[i] > ULONGLONG_MAX ;
#7935  long ijni;
#7956    for (i=0; i<nii++) {
#7958      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#7962      nrange += tp[i] > X_USHORT_MAX ;
#8006  long ijni;
#8027    for (i=0; i<nii++) {
#8029      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8033      nrange += tp[i] > X_USHORT_MAX || tp[i] < 0;
#8076  long ijni;
#8097    for (i=0; i<nii++) {
#8099      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8103      nrange += tp[i] > X_USHORT_MAX || tp[i] < 0;
#8146  long ijni;
#8167    for (i=0; i<nii++) {
#8169      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8173      nrange += tp[i] > X_USHORT_MAX || tp[i] < 0;
#8216  long ijni;
#8237    for (i=0; i<nii++) {
#8239      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8243      nrange += tp[i] > X_USHORT_MAX || tp[i] < 0;
#8286  long ijni;
#8307    for (i=0; i<nii++) {
#8309      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8313      nrange += tp[i] > X_USHORT_MAX || tp[i] < 0;
#8356  long ijni;
#8377    for (i=0; i<nii++) {
#8379      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8383      nrange += tp[i] > X_USHORT_MAX || tp[i] < 0;
#8426  long ijni;
#8447    for (i=0; i<nii++) {
#8449      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8453      nrange += tp[i] > X_USHORT_MAX ;
#8496  long ijni;
#8517    for (i=0; i<nii++) {
#8519      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8523      nrange += tp[i] > X_USHORT_MAX ;
#8566  long ijni;
#8587    for (i=0; i<nii++) {
#8589      xp[i] = (ushortMaxX_USHORT_MINMin(X_USHORT_MAX, (ushorttp[i]));
#8593      nrange += tp[i] > X_USHORT_MAX ;
#8905  long ijni;
#8927    for (i=0; i<nii++) {
#8928      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#8932      nrange += xp[i] > INT_MAX || xp[i] < INT_MIN;
#8971  long ijni;
#8993    for (i=0; i<nii++) {
#8994      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#8998      nrange += xp[i] > SCHAR_MAX || xp[i] < SCHAR_MIN;
#9036  long ijni;
#9058    for (i=0; i<nii++) {
#9059      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#9063      nrange += xp[i] > SHORT_MAX || xp[i] < SHORT_MIN;
#9101  long ijni;
#9123    for (i=0; i<nii++) {
#9124      tp[i] = (float) MaxFLOAT_MINMin(FLOAT_MAX, (float) xp[i]));
#9128      nrange += xp[i] > FLOAT_MAX || xp[i] < FLOAT_MIN;
#9166  long ijni;
#9188    for (i=0; i<nii++) {
#9189      tp[i] = (double) MaxDOUBLE_MINMin(DOUBLE_MAX, (double) xp[i]));
#9193      nrange += xp[i] > DOUBLE_MAX || xp[i] < DOUBLE_MIN;
#9231  long ijni;
#9253    for (i=0; i<nii++) {
#9254      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#9258      nrange += xp[i] > LONGLONG_MAX || xp[i] < LONGLONG_MIN;
#9296  long ijni;
#9318    for (i=0; i<nii++) {
#9319      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#9323      nrange += xp[i] > UCHAR_MAX || xp[i] < 0;
#9361  long ijni;
#9383    for (i=0; i<nii++) {
#9384      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#9388      nrange += xp[i] > USHORT_MAX || xp[i] < 0;
#9426  long ijni;
#9448    for (i=0; i<nii++) {
#9449      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#9453      nrange += xp[i] > UINT_MAX || xp[i] < 0;
#9491  long ijni;
#9513    for (i=0; i<nii++) {
#9514      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#9518      nrange += xp[i] > ULONGLONG_MAX || xp[i] < 0;
#9571  long ijni;
#9592    for (i=0; i<nii++) {
#9594      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#9598      nrange += tp[i] > X_INT_MAX || tp[i] < X_INT_MIN;
#9642  long ijni;
#9663    for (i=0; i<nii++) {
#9665      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#9669      nrange += tp[i] > X_INT_MAX || tp[i] < X_INT_MIN;
#9712  long ijni;
#9733    for (i=0; i<nii++) {
#9735      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#9739      nrange += tp[i] > X_INT_MAX || tp[i] < X_INT_MIN;
#9782  long ijni;
#9804    for (i=0; i<nii++) {
#9806      d = tp[i];
#9807      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) d));
#9808      nrange += tp[i] > X_INT_MAX || tp[i] < X_INT_MIN;
#9851  long ijni;
#9872    for (i=0; i<nii++) {
#9874      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#9878      nrange += tp[i] > X_INT_MAX || tp[i] < X_INT_MIN;
#9921  long ijni;
#9942    for (i=0; i<nii++) {
#9944      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#9948      nrange += tp[i] > X_INT_MAX || tp[i] < X_INT_MIN;
#9991  long ijni;
#10012    for (i=0; i<nii++) {
#10014      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#10018      nrange += tp[i] > X_INT_MAX ;
#10061  long ijni;
#10082    for (i=0; i<nii++) {
#10084      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#10088      nrange += tp[i] > X_INT_MAX ;
#10131  long ijni;
#10152    for (i=0; i<nii++) {
#10154      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#10158      nrange += tp[i] > X_INT_MAX ;
#10201  long ijni;
#10222    for (i=0; i<nii++) {
#10224      xp[i] = (int) MaxX_INT_MINMin(X_INT_MAX, (int) tp[i]));
#10228      nrange += tp[i] > X_INT_MAX ;
#10288  long ijni;
#10310    for (i=0; i<nii++) {
#10311      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#10315      nrange += xp[i] > UINT_MAX ;
#10354  long ijni;
#10376    for (i=0; i<nii++) {
#10377      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#10381      nrange += xp[i] > SCHAR_MAX ;
#10419  long ijni;
#10441    for (i=0; i<nii++) {
#10442      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#10446      nrange += xp[i] > SHORT_MAX ;
#10484  long ijni;
#10506    for (i=0; i<nii++) {
#10507      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#10511      nrange += xp[i] > INT_MAX ;
#10549  long ijni;
#10571    for (i=0; i<nii++) {
#10572      tp[i] = (float) MaxFLOAT_MINMin(FLOAT_MAX, (float) xp[i]));
#10576      nrange += xp[i] > FLOAT_MAX ;
#10614  long ijni;
#10636    for (i=0; i<nii++) {
#10637      tp[i] = (double) MaxDOUBLE_MINMin(DOUBLE_MAX, (double) xp[i]));
#10641      nrange += xp[i] > DOUBLE_MAX ;
#10679  long ijni;
#10701    for (i=0; i<nii++) {
#10702      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#10706      nrange += xp[i] > LONGLONG_MAX ;
#10744  long ijni;
#10766    for (i=0; i<nii++) {
#10767      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#10771      nrange += xp[i] > UCHAR_MAX ;
#10809  long ijni;
#10831    for (i=0; i<nii++) {
#10832      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#10836      nrange += xp[i] > USHORT_MAX ;
#10874  long ijni;
#10896    for (i=0; i<nii++) {
#10897      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#10901      nrange += xp[i] > ULONGLONG_MAX ;
#10954  long ijni;
#10975    for (i=0; i<nii++) {
#10977      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#10981      nrange += tp[i] > X_UINT_MAX ;
#11025  long ijni;
#11046    for (i=0; i<nii++) {
#11048      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11052      nrange += tp[i] > X_UINT_MAX || tp[i] < 0;
#11095  long ijni;
#11116    for (i=0; i<nii++) {
#11118      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11122      nrange += tp[i] > X_UINT_MAX || tp[i] < 0;
#11165  long ijni;
#11186    for (i=0; i<nii++) {
#11188      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11192      nrange += tp[i] > X_UINT_MAX || tp[i] < 0;
#11235  long ijni;
#11256    for (i=0; i<nii++) {
#11258      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11262      nrange += tp[i] > X_UINT_MAX || tp[i] < 0;
#11305  long ijni;
#11326    for (i=0; i<nii++) {
#11328      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11332      nrange += tp[i] > X_UINT_MAX || tp[i] < 0;
#11375  long ijni;
#11396    for (i=0; i<nii++) {
#11398      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11402      nrange += tp[i] > X_UINT_MAX || tp[i] < 0;
#11445  long ijni;
#11466    for (i=0; i<nii++) {
#11468      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11472      nrange += tp[i] > X_UINT_MAX ;
#11515  long ijni;
#11536    for (i=0; i<nii++) {
#11538      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11542      nrange += tp[i] > X_UINT_MAX ;
#11585  long ijni;
#11606    for (i=0; i<nii++) {
#11608      xp[i] = (uintMaxX_UINT_MINMin(X_UINT_MAX, (uinttp[i]));
#11612      nrange += tp[i] > X_UINT_MAX ;
#11751  long ijni;
#11773    for (i=0; i<nii++) {
#11774      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#11778      nrange += xp[i] > SCHAR_MAX || xp[i] < SCHAR_MIN;
#11816  long ijni;
#11838    for (i=0; i<nii++) {
#11839      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#11843      nrange += xp[i] > SHORT_MAX || xp[i] < SHORT_MIN;
#11881  long ijni;
#11903    for (i=0; i<nii++) {
#11904      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#11908      nrange += xp[i] > INT_MAX || xp[i] < INT_MIN;
#11946  long ijni;
#11968    for (i=0; i<nii++) {
#11969      tp[i] = (double) MaxDOUBLE_MINMin(DOUBLE_MAX, (double) xp[i]));
#11973      nrange += xp[i] > DOUBLE_MAX || xp[i] < DOUBLE_MIN;
#12011  long ijni;
#12033    for (i=0; i<nii++) {
#12034      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#12038      nrange += xp[i] > LONGLONG_MAX || xp[i] < LONGLONG_MIN;
#12076  long ijni;
#12098    for (i=0; i<nii++) {
#12099      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#12103      nrange += xp[i] > USHORT_MAX || xp[i] < 0;
#12141  long ijni;
#12163    for (i=0; i<nii++) {
#12164      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#12168      nrange += xp[i] > UCHAR_MAX || xp[i] < 0;
#12206  long ijni;
#12228    for (i=0; i<nii++) {
#12229      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#12233      nrange += xp[i] > UINT_MAX || xp[i] < 0;
#12271  long ijni;
#12293    for (i=0; i<nii++) {
#12294      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#12298      nrange += xp[i] > ULONGLONG_MAX || xp[i] < 0;
#12427  long ijni;
#12448    for (i=0; i<nii++) {
#12450      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12454      nrange += tp[i] > X_FLOAT_MAX || tp[i] < X_FLOAT_MIN;
#12497  long ijni;
#12518    for (i=0; i<nii++) {
#12520      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12524      nrange += tp[i] > X_FLOAT_MAX || tp[i] < X_FLOAT_MIN;
#12567  long ijni;
#12588    for (i=0; i<nii++) {
#12590      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12594      nrange += tp[i] > X_FLOAT_MAX || tp[i] < X_FLOAT_MIN;
#12637  long ijni;
#12658    for (i=0; i<nii++) {
#12660      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12664      nrange += tp[i] > X_FLOAT_MAX || tp[i] < X_FLOAT_MIN;
#12707  long ijni;
#12728    for (i=0; i<nii++) {
#12730      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12734      nrange += tp[i] > X_FLOAT_MAX || tp[i] < X_FLOAT_MIN;
#12777  long ijni;
#12798    for (i=0; i<nii++) {
#12800      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12804      nrange += tp[i] > X_FLOAT_MAX ;
#12847  long ijni;
#12868    for (i=0; i<nii++) {
#12870      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12874      nrange += tp[i] > X_FLOAT_MAX ;
#12917  long ijni;
#12938    for (i=0; i<nii++) {
#12940      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#12944      nrange += tp[i] > X_FLOAT_MAX ;
#12987  long ijni;
#13008    for (i=0; i<nii++) {
#13010      xp[i] = (float) MaxX_FLOAT_MINMin(X_FLOAT_MAX, (float) tp[i]));
#13014      nrange += tp[i] > X_FLOAT_MAX ;
#13147  long ijni;
#13169    for (i=0; i<nii++) {
#13170      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#13174      nrange += xp[i] > SCHAR_MAX || xp[i] < SCHAR_MIN;
#13212  long ijni;
#13234    for (i=0; i<nii++) {
#13235      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#13239      nrange += xp[i] > SHORT_MAX || xp[i] < SHORT_MIN;
#13277  long ijni;
#13299    for (i=0; i<nii++) {
#13300      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#13304      nrange += xp[i] > INT_MAX || xp[i] < INT_MIN;
#13342  long ijni;
#13364    for (i=0; i<nii++) {
#13365      tp[i] = (float) MaxFLOAT_MINMin(FLOAT_MAX, (float) xp[i]));
#13369      nrange += xp[i] > FLOAT_MAX || xp[i] < FLOAT_MIN;
#13407  long ijni;
#13429    for (i=0; i<nii++) {
#13430      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#13434      nrange += xp[i] > LONGLONG_MAX || xp[i] < LONGLONG_MIN;
#13472  long ijni;
#13494    for (i=0; i<nii++) {
#13495      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#13499      nrange += xp[i] > UCHAR_MAX || xp[i] < 0;
#13537  long ijni;
#13559    for (i=0; i<nii++) {
#13560      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#13564      nrange += xp[i] > USHORT_MAX || xp[i] < 0;
#13602  long ijni;
#13624    for (i=0; i<nii++) {
#13625      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#13629      nrange += xp[i] > UINT_MAX || xp[i] < 0;
#13667  long ijni;
#13689    for (i=0; i<nii++) {
#13690      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#13694      nrange += xp[i] > ULONGLONG_MAX || xp[i] < 0;
#13838  long ijni;
#13859    for (i=0; i<nii++) {
#13861      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#13865      nrange += tp[i] > X_DOUBLE_MAX || tp[i] < X_DOUBLE_MIN;
#13908  long ijni;
#13929    for (i=0; i<nii++) {
#13931      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#13935      nrange += tp[i] > X_DOUBLE_MAX || tp[i] < X_DOUBLE_MIN;
#13978  long ijni;
#13999    for (i=0; i<nii++) {
#14001      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#14005      nrange += tp[i] > X_DOUBLE_MAX || tp[i] < X_DOUBLE_MIN;
#14048  long ijni;
#14069    for (i=0; i<nii++) {
#14071      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#14075      nrange += tp[i] > X_DOUBLE_MAX || tp[i] < X_DOUBLE_MIN;
#14118  long ijni;
#14139    for (i=0; i<nii++) {
#14141      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#14145      nrange += tp[i] > X_DOUBLE_MAX || tp[i] < X_DOUBLE_MIN;
#14188  long ijni;
#14209    for (i=0; i<nii++) {
#14211      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#14215      nrange += tp[i] > X_DOUBLE_MAX ;
#14258  long ijni;
#14279    for (i=0; i<nii++) {
#14281      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#14285      nrange += tp[i] > X_DOUBLE_MAX ;
#14328  long ijni;
#14349    for (i=0; i<nii++) {
#14351      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#14355      nrange += tp[i] > X_DOUBLE_MAX ;
#14398  long ijni;
#14419    for (i=0; i<nii++) {
#14421      xp[i] = (double) MaxX_DOUBLE_MINMin(X_DOUBLE_MAX, (double) tp[i]));
#14425      nrange += tp[i] > X_DOUBLE_MAX ;
#14486  long ijni;
#14508    for (i=0; i<nii++) {
#14509      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#14513      nrange += xp[i] > LONGLONG_MAX || xp[i] < LONGLONG_MIN;
#14552  long ijni;
#14574    for (i=0; i<nii++) {
#14575      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#14579      nrange += xp[i] > SCHAR_MAX || xp[i] < SCHAR_MIN;
#14617  long ijni;
#14639    for (i=0; i<nii++) {
#14640      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#14644      nrange += xp[i] > SHORT_MAX || xp[i] < SHORT_MIN;
#14682  long ijni;
#14704    for (i=0; i<nii++) {
#14705      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#14709      nrange += xp[i] > INT_MAX || xp[i] < INT_MIN;
#14747  long ijni;
#14769    for (i=0; i<nii++) {
#14770      tp[i] = (float) MaxFLOAT_MINMin(FLOAT_MAX, (float) xp[i]));
#14774      nrange += xp[i] > FLOAT_MAX || xp[i] < FLOAT_MIN;
#14812  long ijni;
#14834    for (i=0; i<nii++) {
#14835      tp[i] = (double) MaxDOUBLE_MINMin(DOUBLE_MAX, (double) xp[i]));
#14839      nrange += xp[i] > DOUBLE_MAX || xp[i] < DOUBLE_MIN;
#14877  long ijni;
#14899    for (i=0; i<nii++) {
#14900      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#14904      nrange += xp[i] > UCHAR_MAX || xp[i] < 0;
#14942  long ijni;
#14964    for (i=0; i<nii++) {
#14965      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#14969      nrange += xp[i] > USHORT_MAX || xp[i] < 0;
#15007  long ijni;
#15029    for (i=0; i<nii++) {
#15030      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#15034      nrange += xp[i] > UINT_MAX || xp[i] < 0;
#15072  long ijni;
#15094    for (i=0; i<nii++) {
#15095      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#15099      nrange += xp[i] > ULONGLONG_MAX || xp[i] < 0;
#15152  long ijni;
#15173    for (i=0; i<nii++) {
#15175      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15179      nrange += tp[i] > X_LONGLONG_MAX || tp[i] < X_LONGLONG_MIN;
#15223  long ijni;
#15244    for (i=0; i<nii++) {
#15246      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15250      nrange += tp[i] > X_LONGLONG_MAX || tp[i] < X_LONGLONG_MIN;
#15293  long ijni;
#15314    for (i=0; i<nii++) {
#15316      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15320      nrange += tp[i] > X_LONGLONG_MAX || tp[i] < X_LONGLONG_MIN;
#15363  long ijni;
#15384    for (i=0; i<nii++) {
#15386      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15390      nrange += tp[i] > X_LONGLONG_MAX || tp[i] < X_LONGLONG_MIN;
#15433  long ijni;
#15454    for (i=0; i<nii++) {
#15456      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15460      nrange += tp[i] > X_LONGLONG_MAX || tp[i] < X_LONGLONG_MIN;
#15503  long ijni;
#15524    for (i=0; i<nii++) {
#15526      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15530      nrange += tp[i] > X_LONGLONG_MAX || tp[i] < X_LONGLONG_MIN;
#15573  long ijni;
#15594    for (i=0; i<nii++) {
#15596      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15600      nrange += tp[i] > X_LONGLONG_MAX ;
#15643  long ijni;
#15664    for (i=0; i<nii++) {
#15666      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15670      nrange += tp[i] > X_LONGLONG_MAX ;
#15713  long ijni;
#15734    for (i=0; i<nii++) {
#15736      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15740      nrange += tp[i] > X_LONGLONG_MAX ;
#15783  long ijni;
#15804    for (i=0; i<nii++) {
#15806      xp[i] = (longlongMaxX_LONGLONG_MINMin(X_LONGLONG_MAX, (longlongtp[i]));
#15810      nrange += tp[i] > X_LONGLONG_MAX ;
#15870  long ijni;
#15892    for (i=0; i<nii++) {
#15893      tp[i] = (ulonglongMaxULONGLONG_MINMin(ULONGLONG_MAX, (ulonglongxp[i]));
#15897      nrange += xp[i] > ULONGLONG_MAX ;
#15936  long ijni;
#15958    for (i=0; i<nii++) {
#15959      tp[i] = (scharMaxSCHAR_MINMin(SCHAR_MAX, (scharxp[i]));
#15963      nrange += xp[i] > SCHAR_MAX ;
#16001  long ijni;
#16023    for (i=0; i<nii++) {
#16024      tp[i] = (short) MaxSHORT_MINMin(SHORT_MAX, (short) xp[i]));
#16028      nrange += xp[i] > SHORT_MAX ;
#16066  long ijni;
#16088    for (i=0; i<nii++) {
#16089      tp[i] = (int) MaxINT_MINMin(INT_MAX, (int) xp[i]));
#16093      nrange += xp[i] > INT_MAX ;
#16131  long ijni;
#16153    for (i=0; i<nii++) {
#16154      tp[i] = (float) MaxFLOAT_MINMin(FLOAT_MAX, (float) xp[i]));
#16158      nrange += xp[i] > FLOAT_MAX ;
#16196  long ijni;
#16218    for (i=0; i<nii++) {
#16219      tp[i] = (double) MaxDOUBLE_MINMin(DOUBLE_MAX, (double) xp[i]));
#16223      nrange += xp[i] > DOUBLE_MAX ;
#16261  long ijni;
#16283    for (i=0; i<nii++) {
#16284      tp[i] = (longlongMaxLONGLONG_MINMin(LONGLONG_MAX, (longlongxp[i]));
#16288      nrange += xp[i] > LONGLONG_MAX ;
#16326  long ijni;
#16348    for (i=0; i<nii++) {
#16349      tp[i] = (ucharMaxUCHAR_MINMin(UCHAR_MAX, (ucharxp[i]));
#16353      nrange += xp[i] > UCHAR_MAX ;
#16391  long ijni;
#16413    for (i=0; i<nii++) {
#16414      tp[i] = (ushortMaxUSHORT_MINMin(USHORT_MAX, (ushortxp[i]));
#16418      nrange += xp[i] > USHORT_MAX ;
#16456  long ijni;
#16478    for (i=0; i<nii++) {
#16479      tp[i] = (uintMaxUINT_MINMin(UINT_MAX, (uintxp[i]));
#16483      nrange += xp[i] > UINT_MAX ;
#16536  long ijni;
#16557    for (i=0; i<nii++) {
#16559      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#16563      nrange += tp[i] > X_ULONGLONG_MAX ;
#16607  long ijni;
#16628    for (i=0; i<nii++) {
#16630      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#16634      nrange += tp[i] > X_ULONGLONG_MAX || tp[i] < 0;
#16677  long ijni;
#16698    for (i=0; i<nii++) {
#16700      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#16704      nrange += tp[i] > X_ULONGLONG_MAX || tp[i] < 0;
#16747  long ijni;
#16768    for (i=0; i<nii++) {
#16770      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#16774      nrange += tp[i] > X_ULONGLONG_MAX || tp[i] < 0;
#16817  long ijni;
#16838    for (i=0; i<nii++) {
#16840      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#16844      nrange += tp[i] > X_ULONGLONG_MAX || tp[i] < 0;
#16887  long ijni;
#16908    for (i=0; i<nii++) {
#16910      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#16914      nrange += tp[i] > X_ULONGLONG_MAX || tp[i] < 0;
#16957  long ijni;
#16978    for (i=0; i<nii++) {
#16980      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#16984      nrange += tp[i] > X_ULONGLONG_MAX || tp[i] < 0;
#17027  long ijni;
#17048    for (i=0; i<nii++) {
#17050      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#17054      nrange += tp[i] > X_ULONGLONG_MAX ;
#17097  long ijni;
#17118    for (i=0; i<nii++) {
#17120      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#17124      nrange += tp[i] > X_ULONGLONG_MAX ;
#17167  long ijni;
#17188    for (i=0; i<nii++) {
#17190      xp[i] = (ulonglongMaxX_ULONGLONG_MINMin(X_ULONGLONG_MAX, (ulonglongtp[i]));
#17194      nrange += tp[i] > X_ULONGLONG_MAX ;
oc.c#543    size_t count,i;
#553    for(i=0;i<count;i++) {
#558        err = oc_dds_ithfield(link,ddsnode,i,&field);
#592    size_t i;
#599        for(i=0;i<node->array.rank;i++) {
#600            OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#601     dims[i] = (OCobject)dim;
#688 size_t i;
#689        for(i=0;i<node->array.rank;i++) {
#690            OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#691     dimsizes[i] = dim->dim.declsize;
#729    int i;
#744     for(i=0;i<attr->nvalues;i++)
#745         strings[i] = nulldup(attr->values[i]);
#762    int i;
#763    for(i=0;i<n;i++) if(svec[i] != NULL) free(svec[i]);
#958    size_t count=0,i;
#970    for(i=0;i<count;i++) {
#974        err = oc_dds_ithfield(link,ddsnode,i,&field);
#986     err = oc_data_ithfield(link,datanode,i,&field);
oc.h#308extern OCerror oc_dds_attr(OClink,OCddsnode, size_t i,
ocbytes.c#85  size_t i;
#87  for(i=0;i<bb->length;i++) bb->content[i] = fill;
#150  int i; /* do not make unsigned */
#154  for(i=bb->alloc;i>=1;i--) {bb->content[i]=bb->content[i-1];}
occlientparams.c#31    int i;
#32    i = ocuridecodeparams(state->uri);
#33    return i?OC_NOERR:OC_EBADURL;
#50    int i;
#51    i = ocurisetparams(state->uri,params);
#52    return i?OC_NOERR:OC_EBADURL;
#59    int i;
#61    for(i=0;i<oclistlength(params);i++) {
#62 char* s = (char*)oclistget(params,i);
#76    int i,found = 0;
#78    for(i=0;i<oclistlength(params);i+=2) {
#79 char* name = (char*)oclistget(params,i);
#83 oclistremove(params,i+1); /* remove value */
#84 oclistremove(params,i); /* remove name */
#98    int i;
#100    for(i=0;i<oclistlength(params);i+=2) {
#101 char* name = (char*)oclistget(params,i);
#119    int i;
#121    for(i=0;i<oclistlength(params);i+=2) {
#122 char* name = (char*)oclistget(params,i);
#124     oclistinsert(params,i+1,(ocelem)nulldup(value));
occompile.c#77    size_t i;
#119     for(i=0;i<nelements;i++) {
#123 data->instances[i] = instance;
#127 instance->index = i;
#203 for(i=0;i<oclistlength(records);i++)
#204     ocdata_free(state,(OCdata*)oclistget(records,i));
#240    size_t i;
#251    for(i=0;i<nelements;i++) {
#254 fieldnode = (OCnode*)oclistget(xnode->subnodes,i);
#259 data->instances[i] = fieldinstance;
#263        fieldinstance->index = i;
#268 for(i=0;i<nelements;i++) {
#269            OCnodefieldnode = (OCnode*)oclistget(xnode->subnodes,i);
#270            OCdatafieldinstance = data->instances[i];
#280 for(i=0;i<data->ninstances;i++)
#281     ocdata_free(state,data->instances[i]);
#291    int i;
#347        for(i=0;i<data->nstrings;i++) {
#350     data->strings[i] = xxdr_getpos(xxdrs);
#383 int i;
#384        for(i=0;i<data->ninstances;i++)
#385     ocdata_free(state,data->instances[i]);
occurlfunctions.c#245    int i;
#259    for(i=0;i<store->ntriples;i++,triple++) {
ocdata.c#292    int i;
#326     for(p=(unsigned int*)memory,i=0;i<count;i++,p++) {
#337     for(llp=(unsigned long long*)memory,i=0;i<count;i++,llp++) {
#348     for(dp=(double*)memory,i=0;i<count;i++,dp++) {
#366     for(i=0;i<count;i++,sp++) {
#401 for(i=0;i<count;i++,sp++) {
#403     off_t offset = data->strings[start+i];
ocdump.c#125 unsigned int i;
#135 for(i=1;i<oclistlength(node->subnodes);i++) {
#136     dumpocnode1((OCnode*)oclistget(node->subnodes,i),depth+2);
#166 unsigned int i;
#167 for(i=0;i<oclistlength(node->attributes);i++) {
#168     OCattributeatt = (OCattribute*)oclistget(node->attributes,i);
#191    unsigned int i;
#192    for(i=0;i<node->array.rank;i++) {
#193        OCnodedim = (OCnode*)oclistget(node->array.dimensions,i);
#223    unsigned int i;
#226    for(i=0;i<oclistlength(path);i++) {
#228 OCnodenode = (OCnode*)oclistget(path,i);
#230 fprintf(stdout,"%s%s",(i>0?PATHSEPARATOR:""),node->name);
#231 sliceset = (OClist*)oclistget(ref->indexsets,i);
#301        int i;
#303        for(i=0;i<4;i++) {
#305     unsigned int c = (n8[i] & 0xff);
#329    unsigned int i,count,rem;
#351    for(pmem=memory,i=0;i<count;i++,pmem+=4) {
#353 if(i<(count-1))
#357 dumpfield(i*sizeof(unsigned int),mem,fromxdr);
#362 dumpfield(i*sizeof(unsigned int),mem,fromxdr);
#370    unsigned int i,count,rem;
#390    for(i=0;i<count;i++) {
#391 unsigned int vx = (unsigned int)imemory[i];
#395        sprintf(tmp,"%6d",i);
#548    size_t i,rank;
#626        for(i=0;i<data->ninstances;i++)
#627     ocdumpdatatree(state,data->instances[i],buffer,depth+1);
#634    int i;
#642    for(i=1;;i++) {
#643 OCdatanext = path[i-1];
#645 path[i] = next->container;
#648    for(i=i-1;i>=0;i--) {
#649 pathdata = path[i];
#654 if(i > 0) {
#655     OCdatanext = path[i-1];
ocinternal.c#417    unsigned int i;
#422    for(i=0;i<oclistlength(state->trees);i++) {
#693    int i=0;
#707    for(depth=0,i=0;i<avail;i++) {
#712     if(depth == 0) {i++; break;}
#715    errmsg = (char*)malloc((size_t)i+1);
#718    xxdr_getbytes(xdrs,errmsg,(off_t)i);
#719    errmsg[i] = '\0';
oclist.c#97  int i; /* do not make unsigned */
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#133oclistremove(OClistl, size_t i)
#138  if(i >= len) return NULL;
#139  elem = l->content[i];
#140  for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#161    size_t i;
#162    for(i=0;i<oclistlength(l);i++) {
#163 if(elem == oclistget(l,i)) return 1;
#173  size_t i;
#176  for(i=0;i<oclistlength(l);i++) {
#177    void* candidate = l->content[i];
#179      for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#199    size_t i,j,k,len;
#204    for(i=0;i<len;i++) {
#205        for(j=i+1;j<len;j++) {
#206     if(content[i] == content[j]) {
oclist.h#34EXTERNC void* oclistremove(OClistl, size_t i);
oclog.c#211        int i;
#213 for(i=0;i<MAXTAGS;i++) {if(tagset[i]==NULL) break;}
#214 octagsize = i;
ocnode.c#21    unsigned int i,j;
#23    for(i=0;i<oclistlength(ocnodes);i++) {
#24 OCnodenode = (OCnode*)oclistget(ocnodes,i);
#31    for(i=0;i<oclistlength(ocnodes);i++) {
#32 OCnodenode = (OCnode*)oclistget(ocnodes,i);
#46    unsigned int i;
#49        for(i=0;i<oclistlength(root->subnodes);i++) {
#50     OCnodenode = (OCnode*)oclistget(root->subnodes,i);
#82    int slen,i,len;
#87    for(i=0,slen=0;i<len;i++) {
#88 OCnodenode = (OCnode*)oclistget(path,(size_t)i);
#97    for(i=0;i<len;i++) {
#98 OCnodenode = (OCnode*)oclistget(path,(size_t)i);
#140 int i;
#142        for(i=0;i<att->nvalues;i++)
#143     att->values[i] = nulldup((char*)oclistget(values,(size_t)i));
#153    int i;
#164    for(i=0;i<oclistlength(state->trees);i++) {
#165 OCnodenode = (OCnode*)oclistget(state->trees,(size_t)i);
#167     oclistremove(state->trees,(size_t)i);
#192    unsigned int i,j;
#193    for(i=0;i<oclistlength(nodes);i++) {
#194 OCnodenode = (OCnode*)oclistget(nodes,i);
#253    unsigned int i,j;
#269    for(i=0;i<oclistlength(dasroot->tree->nodes);i++) {
#270 OCnodedas = (OCnode*)oclistget(dasroot->tree->nodes,i);
#299    for(i=0;i<oclistlength(ddsnodes);i++) {
#300 OCnodedds = (OCnode*)oclistget(ddsnodes,i);
#311    for(i=0;i<oclistlength(dasnodes);i++) {
#312 OCnodedas = (OCnode*)oclistget(dasnodes,i);
#320 oclistset(dasnodes,i,(void*)NULL);
#326    for(i=0;i<oclistlength(dasglobals);i++) {
#327 OCnodedas = (OCnode*)oclistget(dasglobals,i);
#332    for(i=0;i<oclistlength(dodsglobals);i++) {
#333 OCnodedas = (OCnode*)oclistget(dodsglobals,i);
#339    for(i=0;i<oclistlength(dasnodes);i++) {
#340 OCnodedas = (OCnode*)oclistget(dasnodes,i);
#357    unsigned int i;
#362    for(i=0;i<oclistlength(das->subnodes);i++) {
#363 OCnodeattnode = (OCnode*)oclistget(das->subnodes,i);
#377    unsigned int i;
#385    for(i=0;i<oclistlength(dods->subnodes);i++) {
#386 OCnodeattnode = (OCnode*)oclistget(dods->subnodes,i);
#425 int i;
#427        for(i=0;i<oclistlength(das->subnodes);i++) {
#428     OCnodesub = (OCnode*)oclistget(das->subnodes,i);
#441    unsigned int i;
#443    for(i=0;i<oclistlength(tree->nodes);i++) {
#444 OCnodenode = (OCnode*)oclistget(tree->nodes,i);
#452    int i,j;
#477 for(i=0;i<oclistlength(dxd->subnodes);i++) {
#478     OCnodedxd1 = (OCnode*)oclistget(dxd->subnodes,(size_t)i);
#496 for(i=0;i<oclistlength(dxd->subnodes);i++) {
#497     OCnodeddsdim = (OCnode*)oclistget(dds->array.dimensions,(size_t)i);
#498     OCnodedxddim = (OCnode*)oclistget(dxd->array.dimensions,(size_t)i);
#524    int i,j;
#530    for(i=0;i<oclistlength(treenodes);i++) {
#531        OCnodenode = (OCnode*)oclistget(treenodes,(size_t)i);
#565    int i,j;
#570    for(i=0;i<oclistlength(dasroot->subnodes);i++) {
#571 OCnodenode = (OCnode*)oclistget(dasroot->subnodes,i);
#584    for(i=0;i<oclistlength(dasroot->subnodes);i++) {
#585 OCnodedas = (OCnode*)oclistget(dasroot->subnodes,i);
#609    int i,j;
#613    for(i=0;i<oclistlength(das->subnodes);i++) {
#614 OCnodeattnode = (OCnode*)oclistget(das->subnodes,i);
#623    for(i=0;i<oclistlength(das->subnodes);i++) {
#624 OCnodedasnode = (OCnode*)oclistget(das->subnodes,i);
#643    int i;
#653    for(i=0;i<nstrings;i++) {
#654 char* value = strings[i];
ocrc.c#108    int i = 0;
#112        if(i < morelen)  /* ignore excess characters */
#113            more[i++]=c;
#119    more[i] = '\0';
#129    int i;
#140        for(i=(len-1);i>=0;i--) {
#141            if(strchr(TRIMCHARS,text[i]) == NULL) {
#142                text[i+1] = '\0'; /* elide trailing trimchars */
#221    int insorted;
#243        for(i=0;i<store->ntriples;i++) {
#244            if(store->triples[i].key[0] != '\0') { /* avoid empty slots */
#245                int lexorder = strcmp(store->triples[i].host,store->triples[largest].host);
#246                int leni = strlen(store->triples[i].host);
#250                if(leni != 0 && lenlarge == 0) largest = i;
#251                else if(lexorder > 0) largest = i;
#571    int i,found;
#585    for(found=0,i=0;i<ocrc->ntriples;i++,triple++) {
#613    int i;
#623    for(i=0;i<ntriples;i++) {
#625                (strlen(triples[i].host)==0?"--":triples[i].host),
#626                triples[i].key,
#627                triples[i].value);
ocuri.c#97    int i,nprotos;
#180    for(i=0;i<nprotos;i++) {
#181        if(strcmp(protocol,legalprotocols[i].name)==0) {
#182     proto = &legalprotocols[i];
#336 int i,nparms;
#356     for(i=0;i<nparms;i++) {
#357         char** pos = duri->paramlist+(i*2);
#592    int i,c;
#623    for(p=params,i=0;i<nparams;i++) {
#629      plist[2*i] = nulldup(p);
#630      plist[2*i+1] = nulldup(vp);
#644    int i;
#648 i = ocuridecodeparams(uri);
#649 if(!i) return 0;
#651    i = ocfind(uri->paramlist,key);
#652    if(i < 0)
#654    value = uri->paramlist[(2*i)+1];
#674    int i;
#676    for(i=0,p=params;*p;p+=2,i++) {
#677 if(strcmp(key,*p)==0) return i;
ocutil.c#62    unsigned int i,j;
#63    for(i=0;i<oclistlength(path);i++) {
#64 OCnodenode = (OCnode*)oclistget(path,i);
#94    unsigned int i,j;
#95    for(i=0;i<oclistlength(attset);i++) {
#96 OCattributeatt = (OCattribute*)oclistget(attset,i);
#114    unsigned int i;
#121            for(i=0;i<oclistlength(cdf->subnodes);i++) {
#122         OCnodenode = (OCnode*)oclistget(cdf->subnodes,i);
#135    unsigned int i;
#145        for(i=0;i<len;i++) {
#146     if((i+tlen) <= len
#147         && (ocstrncmp(content+i,mark,tlen)==0)) {
#148        *ddslenp = i;
#149         i += tlen;
#150         *bodp = i;
#164    unsigned int i;
#166    for(i=0;i<rank;i++) {
#167        count *= sizes[i];
#430    int i,j;
#449    for(i=0;i<len;i++) {
#450        if(ocstrncmp(contents+i,ERRTAG,strlen(ERRTAG))==0) {
#453     for(j=i;j<len;j++) {
#454         int c = contents[i+j];
#456     contents[i+j] = ERRFILL;
#459 contents+i);
#475    unsigned int i;
#477    for(i=0;i<rank;i++) {
#478 count *= sizes[i];
#479 count += indices[i];
#488    int i;
#489    for(i=rank-1;i>=0;i--) {
#490 indices[i] = index % sizes[i];
#491 index = (index - indices[i]) / sizes[i];
#502    unsigned int i;
#504    for(i=0;i<rank;i++) {
#505 count *= sizes[i];
#506 count += (edges[i]-1);
#514    int i;
#515    for(i=0;i<rank;i++) {
#516 if(indices[i] >= sizes[i]) return 0;
#554    int i;
#561    } else for(i=0;;i++) {
#562 char* ms = modestrings[i];
#564 if(!compact && i > 0)
#567        if(fisset(mode,(1<<i))) {
#600    int i;
#611    for(i=0;i<n;i++) {
#647    int i;
#666    for(i=0;i<n;i++) {
odom.c#17    int i;
#27    for(i=0;i<odom->rank;i++) {
#28 odom->declsize[i] = dimset->dimsyms[i]->dim.declsize;
#29 odom->start[i] = (startp == NULL ? 0
#30                                         : startp[i]);
#31 odom->count[i] = (countp == NULL ? odom->declsize[i]
#32                                         : countp[i]);
#33 odom->index[i] = odom->start[i];
#35 ASSERT(odom->start[i] + odom->count[i] <= odom->declsize[i]);
#65    int i;
#71    } else for(i=0;i<odom->rank;i++) {
#72 int ioffset = i + odom->offset;
#102    int i;
#105    for(i=last;i>=0;i--) {
#106 int ioffset = i+odom->offset;
#112 if(i==0) break; /* leave 0'th for next more() check */
#115    return i; /* return rightmost incremented */
#133    int i;
#135    for(i=0;i<odom->rank;i++) {
#136 int ioffset = i+odom->offset;
#137 if(i > 0) count *= odom->origin->declsize[ioffset];
offsets.c#216    int i,j;
#294    for(i=0;i<NCTYPES;i++) {
#296 padname(vec[i].typename),sizes8[i],vec[i].alignment);
#298    for(i=0;i<NCTYPES;i++) {
#300 padname(vec[i].typename),sizes16[i],vec16[i].alignment);
#302    for(i=0;i<NCTYPES;i++) {
#304 padname(vec[i].typename),sizes32[i],vec32[i].alignment);
#323    int i;
parallel_vara.c#84    int ijranknprocsverbose=1, err;
#95    while ((i = getopt(argcargv, "hq")) != EOF)
#96        switch(i) {
#119    for (i=0; i<NYi++)
#121             buf[i][j] = rank;
#145    for (i=0; i<8; i++) float_att[i] = i;
pres_temp_4D_rd.c#81   int lvllatlonreci = 0;
#141      i = 0;
#146        if (pres_in[lvl][lat][lon] != SAMPLE_PRESSURE + i)
#148        if (temp_in[lvl][lat][lon] != SAMPLE_TEMP + i)
#150        i++;
pres_temp_4D_wr.c#78   int lvllatlonreci = 0;
#95     pres_out[lvl][lat][lon] = SAMPLE_PRESSURE + i;
#96     temp_out[lvl][lat][lon] = SAMPLE_TEMP + i++;
pstdint.h#745#define DECLI(bitsglue3(int,bits,_tglue3(i,bits,=) glue3(INT,bits,_C) (0);
ref_ctest.c#780    static int i = -20;
#781    stat = nc_put_var_int(ncidi_id, &i);
ref_ctest64.c#780    static int i = -20;
#781    stat = nc_put_var_int(ncidi_id, &i);
renamegroup.c#41    int i,stat;
semantics.c#110     int i; /* Search for matching type in all groups (except...)*/
#112     for(i=NC_NAT;i<=NC_STRING;i++) {
#113 Symbolprim = basetypefor(i);
#177    unsigned long i;
#182 for(i=0;i<listlength(root->subnodes);i++) {
#183     Symbolgrp = (Symbol*)listget(root->subnodes,i);
#203    unsigned long i,j;
#205    for(i=0;i<listlength(grpdefs);i++) {
#206        Symbolsym = (Symbol*)listget(grpdefs,i);
#210    for(i=0;i<listlength(dimdefs);i++) {
#211        Symbolsym = (Symbol*)listget(dimdefs,i);
#215    for(i=0;i<listlength(typdefs);i++) {
#216        Symbolsym = (Symbol*)listget(typdefs,i);
#220    for(i=0;i<listlength(vardefs);i++) {
#221        Symbolsym = (Symbol*)listget(vardefs,i);
#225    for(i=0;i<listlength(typdefs);i++) {
#226        Symbolsym = (Symbol*)listget(typdefs,i);
#235    for(i=0;i<listlength(typdefs);i++) {
#236        Symbolsym = (Symbol*)listget(typdefs,i);
#245    for(i=0;i<listlength(gattdefs);i++) {
#246        Symbolsym = (Symbol*)listget(gattdefs,i);
#249    for(i=0;i<listlength(attdefs);i++) {
#250        Symbolsym = (Symbol*)listget(attdefs,i);
#262    unsigned long i,j;
#268    for(i=0;i<listlength(typdefs);i++) {
#269        Symbolsym = (Symbol*)listget(typdefs,i);
#300        for(i=0;i<listlength(typdefs);i++) {
#301     Symbolsym = (Symbol*)listget(typdefs,i);
#331    for(i=0;i<listlength(typdefs);i++) {
#332 Symboltsym = (Symbol*)listget(typdefs,i);
#339    for(i=0;i<listlength(typdefs);i++) {
#340        Symbolsym = (Symbol*)listget(typdefs,i);
#345    for(i=0;i<listlength(typdefs);i++) {
#346        Symboltsym = (Symbol*)listget(typdefs,i);
#389    unsigned long i,j;
#391    for(i=0;i<listlength(typdefs);i++) {
#392 Symbolsym = (Symbol*)listget(typdefs,i);
#402    for(i=0;i<listlength(typdefs);i++) {
#403 Symboltsym = (Symbol*)listget(typdefs,i);
#423    unsigned long i;
#425    for(i=0;i<listlength(attdefs);i++) {
#426 Symbolatt = (Symbol*)listget(attdefs,i);
#430    for(i=0;i<listlength(vardefs);i++) {
#431 Symbolvar = (Symbol*)listget(vardefs,i);
#442    int i;
#443    for(i=0,con=data->data;i<data->alloc;i++,con++) {
#531    int i;
#533    for(i=0;i<listlength(typdefs);i++) {
#536 Symbolen = (Symbol*)listget(typdefs,i);
#565    int i,j;
#567    for(i=0;i<listlength(grp->subnodes);i++) {
#568 Symbolsub= (Symbol*)listget(grp->subnodes,i);
#587    int i;
#588    for(i=0;i<listlength(en->subnodes);i++) {
#589 Symbolec = (Symbol*)listget(en->subnodes,i);
#601    int i;
#630     for(i=0;i<listlength(tsym->subnodes);i++) {
#631 Symbolfield = (Symbol*)listget(tsym->subnodes,i);
#635 if(i==0) tsym->typ.alignment = field->typ.alignment;
#641            for(i=0;i<listlength(tsym->subnodes);i++) {
#642              Symbolfield = (Symbol*)listget(tsym->subnodes,i);
#679    int i,j;
#680    for(i=0;i<listlength(vardefs);i++) {
#681 Symbolvsym = (Symbol*)listget(vardefs,i);
#708    int i;
#710    for(i=0;i<listlength(typdefs);i++) {
#711 Symboltsym = (Symbol*)listget(typdefs,i);
#714    for(i=0;i<listlength(typdefs);i++) {
#715 Symboltsym = (Symbol*)listget(typdefs,i);
#723    int i,j;
#725    for(i=0;i<listlength(gattdefs);i++) {
#726 Symbolasym = (Symbol*)listget(gattdefs,i);
#741    for(i=0;i<listlength(attdefs);i++) {
#742 Symbolasym = (Symbol*)listget(attdefs,i);
#771    for(i=0;i<listlength(vardefs);i++) {
#772 Symbolvsym = (Symbol*)listget(vardefs,i);
#940    int i;
#941    for(i=0;i<src->length;i++) {
#942 NCConstantcon = datalistith(src,i);
#981    int i;
#985    for(i=0;i<listlength(grp->subnodes);i++) {
#986 Symbolsym = (Symbol*)listget(grp->subnodes,i);
#1034    int i;
#1036    for(i=0;i<listlength(seq);i++) {
#1037        Symbolsub = (Symbol*)listget(seq,i);
#1046    int i;
#1047    for(i=0;i<listlength(grpdefs);i++) {
#1048 Symbolsym = (Symbol*)listget(grpdefs,i);
#1061    for(i=0;i<listlength(typdefs);i++) {
#1062 Symbolsym = (Symbol*)listget(typdefs,i);
#1066    for(i=0;i<listlength(dimdefs);i++) {
#1067 Symbolsym = (Symbol*)listget(dimdefs,i);
#1071    for(i=0;i<listlength(vardefs);i++) {
#1072 Symbolsym = (Symbol*)listget(vardefs,i);
#1084    int i;
#1112 for(i=0;i<data->length;i++) {
#1113     NCConstantcon = data->data+i;
#1124     for(i=0;i<data->length;i++) {
#1125 NCConstantcon = &data->data[i];
#1161    int i;
#1163    for(i=0;i<listlength(dimdefs);i++) {
#1164 Symboldim = (Symbol*)listget(dimdefs,i);
#1169    for(i=0;i<listlength(vardefs);i++) {
#1170 Symbolvar = (Symbol*)listget(vardefs,i);
#1195    else for(i=0;i<listlength(dimdefs);i++) {
#1196 Symboldim = (Symbol*)listget(dimdefs,i);
t_dap.c#43#define COMMA (i==0?"":",")
#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);
#116    int i,j;
#155    for(i=0;i<DIMSIZE;i++) {
#159     if(string3[i][j] > 0
#160        && string3[i][j] != '\n'
#161        && string3[i][j] != '\r'
#162        && string3[i][j] != '\t'
#163        &&(string3[i][j] < ' ' || string3[i][j] >= '\177'))
#164 string3[i][j] = '?';
#166 printf("%s\"%s\"",COMMA,string3[i]);
#171 for(i=0;i<DIMSIZE;i++) {
#173         if(string3[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
#183    for(i=0;i<DIMSIZE;i++) printf("%s'\\%03hho'",COMMA,ch[i]);
#193    for(i=0;i<DIMSIZE;i++) printf("%s%hhd",COMMA,int8v[i]);
#203    for(i=0;i<DIMSIZE;i++) printf("%s%hhu",COMMA,uint8v[i]);
#213    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
#223    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#233    for(i=0;i<DIMSIZE;i++) printf("%s%hd",COMMA,int16v[i]);
#243    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
#253    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#263    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
#273    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#283    for(i=0;i<DIMSIZE;i++) printf("%s%ld",COMMA,ilong[i]);
#293    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#303    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float64v[i]);
#338    int i;
#344    for(i=0;i<DIMSIZE;i++) {printf(" %llu",(unsigned long long)v[i]);} \
#347    for(i=0;i<DIMSIZE;i++) {printf(" %llu",(unsigned long long)vdata[i]);} \
#349    for(i=0;i<DIMSIZE;i++) {\
#350        if(v[i] != vdata[i]) {report(i,tag,line); break;}\
#354    for(i=0;i<DIMSIZE;i++) {printf(" %g",v[i]);} \
#357    for(i=0;i<DIMSIZE;i++) {printf(" %g",vdata[i]);} \
#359    for(i=0;i<DIMSIZE;i++) {\
#360        if(fdiff((double)v[i],(double)vdata[i])) {report(i,tag,line); break;}\
#363#define test for(i=0;i<DIMSIZE;i++) {\
#364        if(v[i] != vdata[i]) {report(i,tag,line); break;}\
#366#define ftest for(i=0;i<DIMSIZE;i++) {\
#367        if(fdiff((double)v[i],(double)vdata[i])) {report(i,tag,line); break;}\
#457    for(i=0;i<DIMSIZE;i++) {
#458 if(strcmp(v[i],vdata[i])!=0) {report(i,tag,line); break;}
t_dap3a.c#44#define COMMA (i==0?"":",")
#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);
#117    int i,j;
#155    for(i=0;i<DIMSIZE;i++) {
#159     if(string3[i][j] > 0
#160        && string3[i][j] != '\n'
#161        && string3[i][j] != '\r'
#162        && string3[i][j] != '\t'
#163        &&(string3[i][j] < ' ' || string3[i][j] >= '\177'))
#164 string3[i][j] = '?';
#166 printf("%s\"%s\"",COMMA,string3[i]);
#171 for(i=0;i<DIMSIZE;i++) {
#173         if(string3[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
#183    for(i=0;i<DIMSIZE;i++) printf("%s'\\%03hho'",COMMA,ch[i]);
#193    for(i=0;i<DIMSIZE;i++) printf("%s%hhd",COMMA,int8v[i]);
#203    for(i=0;i<DIMSIZE;i++) printf("%s%hhu",COMMA,uint8v[i]);
#213    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
#223    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#233    for(i=0;i<DIMSIZE;i++) printf("%s%hd",COMMA,int16v[i]);
#243    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
#253    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#263    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
#273    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#283    for(i=0;i<DIMSIZE;i++) printf("%s%ld",COMMA,ilong[i]);
#293    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
#303    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float64v[i]);
#338    int i;
#344    for(i=0;i<DIMSIZE;i++) {printf(" %llu",(unsigned long long)v[i]);} \
#347    for(i=0;i<DIMSIZE;i++) {printf(" %llu",(unsigned long long)vdata[i]);} \
#349    for(i=0;i<DIMSIZE;i++) {\
#350        if(v[i] != vdata[i]) {report(i,tag,line); break;}\
#354    for(i=0;i<DIMSIZE;i++) {printf(" %g",v[i]);} \
#357    for(i=0;i<DIMSIZE;i++) {printf(" %g",vdata[i]);} \
#359    for(i=0;i<DIMSIZE;i++) {\
#360        if(fdiff((double)v[i],(double)vdata[i])) {report(i,tag,line); break;}\
#363#define test for(i=0;i<DIMSIZE;i++) {\
#364        if(v[i] != vdata[i]) {report(i,tag,line); break;}\
#366#define ftest for(i=0;i<DIMSIZE;i++) {\
#367        if(fdiff((double)v[i],(double)vdata[i])) {report(i,tag,line); break;}\
#457    for(i=0;i<DIMSIZE;i++) {
#458 if(strcmp(v[i],vdata[i])!=0) {report(i,tag,line); break;}
test_cvt.c#43#define COMMA (i==0?"":",")
#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);
#116    int i,j;
#155    for(i=0;i<DIMSIZE;i++) {
#159     if(string3_tst[i][j] > 0
#160        && string3_tst[i][j] != '\n'
#161        && string3_tst[i][j] != '\r'
#162        && string3_tst[i][j] != '\t'
#163        &&(string3_tst[i][j] < ' ' || string3_tst[i][j] >= '\177'))
#164 string3_tst[i][j] = '?';
#166 printf("%s\"%s\"",COMMA,string3_tst[i]);
#171 for(i=0;i<DIMSIZE;i++) {
#173         if(string3_tst[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
#183    for(i=0;i<DIMSIZE;i++) printf("%s'\\%03hho'",COMMA,ch_tst[i]);
#193    for(i=0;i<DIMSIZE;i++) printf("%s%hhd",COMMA,int8_tst[i]);
#203    for(i=0;i<DIMSIZE;i++) printf("%s%hhu",COMMA,uint8_tst[i]);
#213    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32_tst[i]);
#223    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
#233    for(i=0;i<DIMSIZE;i++) printf("%s%hd",COMMA,int16_tst[i]);
#243    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32_tst[i]);
#253    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
#263    for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32_tst[i]);
#273    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
#283    for(i=0;i<DIMSIZE;i++) printf("%s%ld",COMMA,ilong_tst[i]);
#293    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
#303    for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float64_tst[i]);
#338    int i;
#344    for(i=0;i<DIMSIZE;i++) {printf(" %llu",(unsigned long long)v[i]);} \
#347    for(i=0;i<DIMSIZE;i++) {printf(" %llu",(unsigned long long)vdata[i]);} \
#349    for(i=0;i<DIMSIZE;i++) {\
#350        if(v[i] != vdata[i]) {report(i,tag,line); break;}\
#354    for(i=0;i<DIMSIZE;i++) {printf(" %g",v[i]);} \
#357    for(i=0;i<DIMSIZE;i++) {printf(" %g",vdata[i]);} \
#359    for(i=0;i<DIMSIZE;i++) {\
#360        if(fdiff((double)v[i],(double)vdata[i])) {report(i,tag,line); break;}\
#363#define test for(i=0;i<DIMSIZE;i++) {\
#364        if(v[i] != vdata[i]) {report(i,tag,line); break;}\
#366#define ftest for(i=0;i<DIMSIZE;i++) {\
#367        if(fdiff((double)v[i],(double)vdata[i])) {report(i,tag,line); break;}\
#457    for(i=0;i<DIMSIZE;i++) {
#458 if(strcmp(v[i],vdata[i])!=0) {report(i,tag,line); break;}
test_get.c#20    int i;
#32    for (i = 0; i < numVarsi++) {
#33        canConvert = (var_type[i] == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
#34 for (j = 0; j < var_rank[i]; j++)
#36        err = nc_get_var1_text(BAD_IDiindex, &value);
#42 for (j = 0; j < var_rank[i]; j++) {
#43     index[j] = var_shape[i][j];
#44     err = nc_get_var1_text(ncidiindex, &value);
#52 for (j = 0; j < var_nels[i]; j++) {
#53     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#56     expect = hash4var_type[i], var_rank[i], indexNCT_TEXT );
#57     if (var_rank[i] == 0 && i%2 )
#58 err = nc_get_var1_text(ncidiNULL, &value);
#60 err = nc_get_var1_text(ncidiindex, &value);
#62 if (inRange3(expect,var_type[i], NCT_TEXT)) {
#67     IF (!equal(value,expect,var_type[i],NCT_TEXT)) {
#98    int i;
#110    for (i = 0; i < numVarsi++) {
#111        canConvert = (var_type[i] == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
#112 for (j = 0; j < var_rank[i]; j++)
#114        err = nc_get_var1_uchar(BAD_IDiindex, &value);
#120 for (j = 0; j < var_rank[i]; j++) {
#121     index[j] = var_shape[i][j];
#122     err = nc_get_var1_uchar(ncidiindex, &value);
#130 for (j = 0; j < var_nels[i]; j++) {
#131     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#134     expect = hash4var_type[i], var_rank[i], indexNCT_UCHAR );
#135     if (var_rank[i] == 0 && i%2 )
#136 err = nc_get_var1_uchar(ncidiNULL, &value);
#138 err = nc_get_var1_uchar(ncidiindex, &value);
#140 if (inRange3(expect,var_type[i], NCT_UCHAR)) {
#145     IF (!equal(value,expect,var_type[i],NCT_UCHAR)) {
#176    int i;
#188    for (i = 0; i < numVarsi++) {
#189        canConvert = (var_type[i] == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
#190 for (j = 0; j < var_rank[i]; j++)
#192        err = nc_get_var1_schar(BAD_IDiindex, &value);
#198 for (j = 0; j < var_rank[i]; j++) {
#199     index[j] = var_shape[i][j];
#200     err = nc_get_var1_schar(ncidiindex, &value);
#208 for (j = 0; j < var_nels[i]; j++) {
#209     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#212     expect = hash4var_type[i], var_rank[i], indexNCT_SCHAR );
#213     if (var_rank[i] == 0 && i%2 )
#214 err = nc_get_var1_schar(ncidiNULL, &value);
#216 err = nc_get_var1_schar(ncidiindex, &value);
#218 if (inRange3(expect,var_type[i], NCT_SCHAR)) {
#223     IF (!equal(value,expect,var_type[i],NCT_SCHAR)) {
#254    int i;
#266    for (i = 0; i < numVarsi++) {
#267        canConvert = (var_type[i] == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
#268 for (j = 0; j < var_rank[i]; j++)
#270        err = nc_get_var1_short(BAD_IDiindex, &value);
#276 for (j = 0; j < var_rank[i]; j++) {
#277     index[j] = var_shape[i][j];
#278     err = nc_get_var1_short(ncidiindex, &value);
#286 for (j = 0; j < var_nels[i]; j++) {
#287     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#290     expect = hash4var_type[i], var_rank[i], indexNCT_SHORT );
#291     if (var_rank[i] == 0 && i%2 )
#292 err = nc_get_var1_short(ncidiNULL, &value);
#294 err = nc_get_var1_short(ncidiindex, &value);
#296 if (inRange3(expect,var_type[i], NCT_SHORT)) {
#301     IF (!equal(value,expect,var_type[i],NCT_SHORT)) {
#332    int i;
#344    for (i = 0; i < numVarsi++) {
#345        canConvert = (var_type[i] == NC_CHAR) == (NCT_INT == NCT_TEXT);
#346 for (j = 0; j < var_rank[i]; j++)
#348        err = nc_get_var1_int(BAD_IDiindex, &value);
#354 for (j = 0; j < var_rank[i]; j++) {
#355     index[j] = var_shape[i][j];
#356     err = nc_get_var1_int(ncidiindex, &value);
#364 for (j = 0; j < var_nels[i]; j++) {
#365     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#368     expect = hash4var_type[i], var_rank[i], indexNCT_INT );
#369     if (var_rank[i] == 0 && i%2 )
#370 err = nc_get_var1_int(ncidiNULL, &value);
#372 err = nc_get_var1_int(ncidiindex, &value);
#374 if (inRange3(expect,var_type[i], NCT_INT)) {
#379     IF (!equal(value,expect,var_type[i],NCT_INT)) {
#410    int i;
#422    for (i = 0; i < numVarsi++) {
#423        canConvert = (var_type[i] == NC_CHAR) == (NCT_LONG == NCT_TEXT);
#424 for (j = 0; j < var_rank[i]; j++)
#426        err = nc_get_var1_long(BAD_IDiindex, &value);
#432 for (j = 0; j < var_rank[i]; j++) {
#433     index[j] = var_shape[i][j];
#434     err = nc_get_var1_long(ncidiindex, &value);
#442 for (j = 0; j < var_nels[i]; j++) {
#443     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#446     expect = hash4var_type[i], var_rank[i], indexNCT_LONG );
#447     if (var_rank[i] == 0 && i%2 )
#448 err = nc_get_var1_long(ncidiNULL, &value);
#450 err = nc_get_var1_long(ncidiindex, &value);
#452 if (inRange3(expect,var_type[i], NCT_LONG)) {
#457     IF (!equal(value,expect,var_type[i],NCT_LONG)) {
#488    int i;
#500    for (i = 0; i < numVarsi++) {
#501        canConvert = (var_type[i] == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
#502 for (j = 0; j < var_rank[i]; j++)
#504        err = nc_get_var1_float(BAD_IDiindex, &value);
#510 for (j = 0; j < var_rank[i]; j++) {
#511     index[j] = var_shape[i][j];
#512     err = nc_get_var1_float(ncidiindex, &value);
#520 for (j = 0; j < var_nels[i]; j++) {
#521     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#524     expect = hash4var_type[i], var_rank[i], indexNCT_FLOAT );
#525     if (var_rank[i] == 0 && i%2 )
#526 err = nc_get_var1_float(ncidiNULL, &value);
#528 err = nc_get_var1_float(ncidiindex, &value);
#530 if (inRange3(expect,var_type[i], NCT_FLOAT)) {
#535     IF (!equal(value,expect,var_type[i],NCT_FLOAT)) {
#566    int i;
#578    for (i = 0; i < numVarsi++) {
#579        canConvert = (var_type[i] == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
#580 for (j = 0; j < var_rank[i]; j++)
#582        err = nc_get_var1_double(BAD_IDiindex, &value);
#588 for (j = 0; j < var_rank[i]; j++) {
#589     index[j] = var_shape[i][j];
#590     err = nc_get_var1_double(ncidiindex, &value);
#598 for (j = 0; j < var_nels[i]; j++) {
#599     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#602     expect = hash4var_type[i], var_rank[i], indexNCT_DOUBLE );
#603     if (var_rank[i] == 0 && i%2 )
#604 err = nc_get_var1_double(ncidiNULL, &value);
#606 err = nc_get_var1_double(ncidiindex, &value);
#608 if (inRange3(expect,var_type[i], NCT_DOUBLE)) {
#613     IF (!equal(value,expect,var_type[i],NCT_DOUBLE)) {
#644    int i;
#656    for (i = 0; i < numVarsi++) {
#657        canConvert = (var_type[i] == NC_CHAR) == (NCT_USHORT == NCT_TEXT);
#658 for (j = 0; j < var_rank[i]; j++)
#660        err = nc_get_var1_ushort(BAD_IDiindex, &value);
#666 for (j = 0; j < var_rank[i]; j++) {
#667     index[j] = var_shape[i][j];
#668     err = nc_get_var1_ushort(ncidiindex, &value);
#676 for (j = 0; j < var_nels[i]; j++) {
#677     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#680     expect = hash4var_type[i], var_rank[i], indexNCT_USHORT );
#681     if (var_rank[i] == 0 && i%2 )
#682 err = nc_get_var1_ushort(ncidiNULL, &value);
#684 err = nc_get_var1_ushort(ncidiindex, &value);
#686 if (inRange3(expect,var_type[i], NCT_USHORT)) {
#691     IF (!equal(value,expect,var_type[i],NCT_USHORT)) {
#722    int i;
#734    for (i = 0; i < numVarsi++) {
#735        canConvert = (var_type[i] == NC_CHAR) == (NCT_UINT == NCT_TEXT);
#736 for (j = 0; j < var_rank[i]; j++)
#738        err = nc_get_var1_uint(BAD_IDiindex, &value);
#744 for (j = 0; j < var_rank[i]; j++) {
#745     index[j] = var_shape[i][j];
#746     err = nc_get_var1_uint(ncidiindex, &value);
#754 for (j = 0; j < var_nels[i]; j++) {
#755     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#758     expect = hash4var_type[i], var_rank[i], indexNCT_UINT );
#759     if (var_rank[i] == 0 && i%2 )
#760 err = nc_get_var1_uint(ncidiNULL, &value);
#762 err = nc_get_var1_uint(ncidiindex, &value);
#764 if (inRange3(expect,var_type[i], NCT_UINT)) {
#769     IF (!equal(value,expect,var_type[i],NCT_UINT)) {
#800    int i;
#812    for (i = 0; i < numVarsi++) {
#813        canConvert = (var_type[i] == NC_CHAR) == (NCT_LONGLONG == NCT_TEXT);
#814 for (j = 0; j < var_rank[i]; j++)
#816        err = nc_get_var1_longlong(BAD_IDiindex, &value);
#822 for (j = 0; j < var_rank[i]; j++) {
#823     index[j] = var_shape[i][j];
#824     err = nc_get_var1_longlong(ncidiindex, &value);
#832 for (j = 0; j < var_nels[i]; j++) {
#833     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#836     expect = hash4var_type[i], var_rank[i], indexNCT_LONGLONG );
#837     if (var_rank[i] == 0 && i%2 )
#838 err = nc_get_var1_longlong(ncidiNULL, &value);
#840 err = nc_get_var1_longlong(ncidiindex, &value);
#842 if (inRange3(expect,var_type[i], NCT_LONGLONG)) {
#847     IF (!equal(value,expect,var_type[i],NCT_LONGLONG)) {
#878    int i;
#890    for (i = 0; i < numVarsi++) {
#891        canConvert = (var_type[i] == NC_CHAR) == (NCT_ULONGLONG == NCT_TEXT);
#892 for (j = 0; j < var_rank[i]; j++)
#894        err = nc_get_var1_ulonglong(BAD_IDiindex, &value);
#900 for (j = 0; j < var_rank[i]; j++) {
#901     index[j] = var_shape[i][j];
#902     err = nc_get_var1_ulonglong(ncidiindex, &value);
#910 for (j = 0; j < var_nels[i]; j++) {
#911     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#914     expect = hash4var_type[i], var_rank[i], indexNCT_ULONGLONG );
#915     if (var_rank[i] == 0 && i%2 )
#916 err = nc_get_var1_ulonglong(ncidiNULL, &value);
#918 err = nc_get_var1_ulonglong(ncidiindex, &value);
#920 if (inRange3(expect,var_type[i], NCT_ULONGLONG)) {
#925     IF (!equal(value,expect,var_type[i],NCT_ULONGLONG))