bindata.c#111bin_list(GeneratorgeneratorSymboltsym, void* liststateListClass lc, int uid, size_t countBytebufferbuf, ...)
#122bin_listend(GeneratorgeneratorSymboltsym, void* liststateListClass lc, int uid, size_t countBytebufferbuf, ...)
#134bin_vlendecl(GeneratorgeneratorSymboltsymBytebufferbuf, int uid, size_t count,...)
#139    vastart(ap,count);
#142    ptr.len = count;
bm_file.c#50      size_t start[MAX_DIMS], count[MAX_DIMS], inc[MAX_DIMS];
#78   size_t *last_count, size_t *start, size_t *count)
#95  count[d] = vo->count[d];
#96  (*slice_len) *= count[d];
#116     total[d] += count[d];
#127  *last_count =  count[0];
#148      count[0] = *start_inc;
#152  count[d] = dimlen[d];
#269   size_t *count = NULL, *start = NULL;
#364      if (!(count = malloc(real_ndims * sizeof(size_t))))
#384    &last_countstartcount)))
#410     count[0] = last_count;
#413  if (nc_get_vara(ncid1vstartcountdata)) ERR;
#421  if (nc_get_vara(ncid2vstartcountdata2)) ERR;
#448      if (count) free(count);
#643      size_t *count = NULL, *start = NULL;
#675      if (!(count = malloc(real_ndims * sizeof(size_t))))
#693    &last_countstartcount)))
#712     count[0] = last_count;
#724  if ((ret = nc_get_vara(ncid_invstartcountdata)))
#746     if ((ret = nc_put_vara(ncid_outvstartcountdata)))
#773      if (count) free(count);
#954      sscanf(subtoken, "%ld", &(vo[num_vo].count[ndims++]));
#1053       dvo[v].start[d], dvo[v].count[d], dvo[v].inc[d]);
cdata.c#141c_list(GeneratorgeneratorSymbolsym, void* liststateListClass lc, int uid, size_t countBytebuffercodebuf, ...)
#146        if(count > 0) bbCat(codebuf,", ");
#158c_listend(GeneratorgeneratorSymbolsym, void* liststateListClass lc, int uid, size_t countBytebufferbuf, ...)
#174c_vlendecl(GeneratorgeneratorSymboltsymBytebuffercodebuf, int uid, size_t count, ...)
#181    vastart(ap,count);
#192    bbprintf(codebuf,"{%u,(void*)vlen_%u}",count,uid);
constraints.c#412     size_t count = 0;
#418     count = countp[dimindex+j];
#419     slice->count = count;
#420     slice->length = count * slice->stride;
#453 size_t count = slice->count;
#455    || count != slice->declsize) return 0;
#674     size_t count1 = slice1->count;
#675     size_t count2 = slice2->count;
#809    slice->length = slice->count;
ctest.c#796    size_t count = 0;
#798    stat = nc_put_var1(ncidc_id, &countc_data);
#804    size_t count = 0;
#806    stat = nc_put_var1(ncidb_id, &countb_data);
#812    size_t count = 0;
#814    stat = nc_put_var1(ncids_id, &counts_data);
#820    size_t count = 0;
#822    stat = nc_put_var1(ncidi_id, &counti_data);
#828    size_t count = 0;
#830    stat = nc_put_var1(ncidf_id, &countf_data);
#836    size_t count = 0;
#838    stat = nc_put_var1(ncidd_id, &countd_data);
#1438    size_t count = 0;
#1440    stat = nc_put_var1(ncidvar_MINUS_name_MINUS_dashes_id, &countvar_MINUS_name_MINUS_dashes_data);
#1446    size_t count = 0;
#1448    stat = nc_put_var1(ncidvar_PERIOD_name_PERIOD_dots_id, &countvar_PERIOD_name_PERIOD_dots_data);
ctest64.c#796    size_t count = 0;
#798    stat = nc_put_var1(ncidc_id, &countc_data);
#804    size_t count = 0;
#806    stat = nc_put_var1(ncidb_id, &countb_data);
#812    size_t count = 0;
#814    stat = nc_put_var1(ncids_id, &counts_data);
#820    size_t count = 0;
#822    stat = nc_put_var1(ncidi_id, &counti_data);
#828    size_t count = 0;
#830    stat = nc_put_var1(ncidf_id, &countf_data);
#836    size_t count = 0;
#838    stat = nc_put_var1(ncidd_id, &countd_data);
#1438    size_t count = 0;
#1440    stat = nc_put_var1(ncidvar_MINUS_name_MINUS_dashes_id, &countvar_MINUS_name_MINUS_dashes_data);
#1446    size_t count = 0;
#1448    stat = nc_put_var1(ncidvar_PERIOD_name_PERIOD_dots_id, &countvar_PERIOD_name_PERIOD_dots_data);
dapcvt.c#13dapconvert(nc_type srctypenc_type dsttype, char* memory0, char* value0, size_t count)
#61    for(i=0;i<count;i++) {
dapdump.c#574    if(slice->count == 1) {
dapodom.c#32 odom->count[i] = segment->slices[i+startindex].count;
#42     const size_t* start, const size_t* count,
#54 icount = (count != NULL ? count[i] : (size != NULL ? size[i] : 1));
#155    off_t count = 1;
#157 count *= odom->size[i];
#159    return count;
dapodom.h#14    size_t         count[NC_MAX_VAR_DIMS];
#26                                const size_t* start, const size_t* count,
data.h#68        unsigned int count; /* # of vlen basetype instances*/
#88    unsigned long count;
dceconstraints.c#77 prefix,s->first,s->stride,last,s->stop,s->length,s->count);
#214    sr.count = (sr.length + (sr.stride - 1))/sr.stride;
#615            if(slice->count == 1) {
#938    slice->count = declsize;
#971  size_t* count,
#980     if(count != NULLcount[i] = segment->slices[i].count;
#991    int icount;
#993    for(count=1,i=start;i<stop;i++) {
#994 count *= seg->slices[i].count;
#996    return count;
#1065     (unsigned long)slice->count,
dceconstraints.h#27    size_t count;  /* (length + (stride-1))/ stride == actual # of elements returned to client*/
#125  size_t* count,
dceparse.c#149    slice->count  = slice->length / slice->stride;
#212    slice->count = 1;
dcopy.c#262   size_t *count = NULL, *start = NULL;
#337   if (!(count = malloc((size_t)real_ndims * sizeof(size_t))))
#369      count[d] = d ? dimlen[d] : 1;
#379     if(count) free(count);
#391     retval = nc_get_vara_schar(ncid_invarid_instartcount,
#394        retval = nc_put_vara_schar(ncid_outvarid_outstartcount,
#398     retval = nc_get_vara_text(ncid_invarid_instartcount,
#401        retval = nc_put_vara_text(ncid_outvarid_outstartcount,
#405     retval = nc_get_vara_short(ncid_invarid_instartcount,
#408        retval = nc_put_vara_short(ncid_outvarid_outstartcount,
#412     retval = nc_get_vara_int(ncid_invarid_instartcount,
#415        retval = nc_put_vara_int(ncid_outvarid_outstartcount,
#419     retval = nc_get_vara_float(ncid_invarid_instartcount,
#422        retval = nc_put_vara_float(ncid_outvarid_outstartcount,
#426     retval = nc_get_vara_double(ncid_invarid_instartcount,
#429        retval = nc_put_vara_double(ncid_outvarid_outstartcount,
#433     retval = nc_get_vara_uchar(ncid_invarid_instartcount,
#436        retval = nc_put_vara_uchar(ncid_outvarid_outstartcount,
#440     retval = nc_get_vara_ushort(ncid_invarid_instartcount,
#443        retval = nc_put_vara_ushort(ncid_outvarid_outstartcount,
#447     retval = nc_get_vara_uint(ncid_invarid_instartcount,
#450        retval = nc_put_vara_uint(ncid_outvarid_outstartcount,
#454     retval = nc_get_vara_longlong(ncid_invarid_instartcount,
#457        retval = nc_put_vara_longlong(ncid_outvarid_outstartcount,
#461     retval = nc_get_vara_ulonglong(ncid_invarid_instartcount,
#464        retval = nc_put_vara_ulonglong(ncid_outvarid_outstartcount,
#476   if (count) free(count);
ddispatch.c#190    size_t count = sizeof(NC_Dispatch) / sizeof(void*);
#192    assert(count * sizeof(void*) == sizeof(NC_Dispatch));
#195    for(i=0;i<count;i++) {
dump.c#51    unsigned int count;
#58    count = list->length;
#59    for(dp=list->data,i=0;i<count;i++,dp++) {
#264    int icountindexdepth;
#266    count = src->length;
#268    if(count > MAXELEMcount = MAXELEM;
#269    if(index > countindex = count;
#278 for(i=index;i<count;i++) {
#282        if(count < src->length) fprintf(stderr,"...");
dv2i.c#730    const long* count,
#736 A_DECL(cntp, size_t, ndimscount);
#738 A_INIT(cntp, size_t, ndimscount);
#758    const long* count,
#764 A_DECL(cntp, size_t, ndimscount);
#766 A_INIT(cntp, size_t, ndimscount);
#786    const long* count,
#792 return ncvarput(ncidvaridstartcountvalue);
#798 A_DECL(cntp, size_t, ndimscount);
#801 A_INIT(cntp, size_t, ndimscount);
#824    const long* count,
#830 return ncvarget(ncidvaridstartcountvalue);
#835 A_DECL(cntp, size_t, ndimscount);
#838 A_INIT(cntp, size_t, ndimscount);
#861    const long* count,
#869 return ncvarputs(ncidvaridstartcountstridevalue);
#889 A_DECL(cntp, size_t, ndimscount);
#892 A_INIT(cntp, size_t, ndimscount);
#918    const long* count,
#926 return ncvargets(ncidvaridstartcountstridevalue);
#946 A_DECL(cntp, size_t, ndimscount);
#949 A_INIT(cntp, size_t, ndimscount);
f77data.c#89f77_list(GeneratorgeneratorSymbolsym, void* liststateListClass lc, int uid, size_t countBytebuffercodebuf, ...)
#93        if(count > 0) bbCat(codebuf,", ");
#107f77_listend(GeneratorgeneratorSymbolsym, void* liststateListClass lc, int uid, size_t countBytebufferbuf, ...)
#113f77_vlendecl(GeneratorgeneratorSymboltsymBytebuffercodebuf, int uid, size_t count, ...)
genbin.c#375             int rank, size_t* start, size_t* count)
#378 return genbin_writeattr(generator,sym,memory,rank,start,count);
#380 return genbin_writevar(generator,sym,memory,rank,start,count);
#392         size_t* count
#399    size_t count[NC_MAX_VAR_DIMS];
#400    { int i; for(i=0;i<rank;i++) count[i] = indices[i] - start[i];}
#412 fprintf(stderr,"%s%lu",(i>0?", ":""),(unsigned long)count[i]);
#419 size_t count[1] = {1};
#420        stat = nc_put_var1(vsym->container->ncidvsym->ncidcountdata);
#422        stat = nc_put_vara(vsym->container->ncidvsym->ncidstartcountdata);
#431           int rank, size_t* start, size_t* count)
genc.c#31                       int rank, size_t* start, size_t* count);
#946           int rank, size_t* start, size_t* count)
#949 genc_writeattr(generator,sym,code,rank,start,count);
#951 genc_writevar(generator,sym,code,rank,start,count);
#958           int rank, size_t* start, size_t* count)
#1018         for(i=0;i<rank;i++) length *= count[i];
#1049     bbprintf(stmt,"%s%lu",(i>0?", ":""),count[i]);
#1071               int rank, size_t* start, size_t* count)
generate.c#48 ASSERT(odom->index[i] == odom->start[i]+odom->count[i]);
#65 size_t count;
#67        for(count=0;count<asym->data->length;count++) {
#68            NCConstantcon = datalistith(asym->data,count);
#69            generator->list(generator,asym,NULL,LISTATTR,uid,count,codebuf);
#72        generator->listend(generator,asym,NULL,LISTATTR,uid,count,codebuf);
#86    const size_t* count;
#105 count = odometercountvector(odom);
#155            writer(generator,vsym,code,odom->rank,odom->start,odom->count);
#180                writer(generator,vsym,code,rank,odom->start,odom->count);
#189            size_t nelems=nc_next_iter(&iter,odom->start,odom->count);
#196            writer(generator,vsym,code,odom->rank,odom->start,odom->count);
#350        size_t count;
#369            generator->vlenstring(generator,tsym,vlenbuf,&uid,&count);
#372            for(count=0;count<data->length;count++) {
#374                generator->list(generator,tsym,NULL,LISTVLEN,uid,count,vlenbuf);
#375                con = datalistith(data,count);
#378            generator->listend(generator,tsym,NULL,LISTVLEN,uid,count,codebuf,(void*)vlenbuf);
#380        generator->vlendecl(generator,tsym,codebuf,uid,count,vlenbuf);
genf77.c#178 int count = gasym->data->length;
#180         if(count == 0) continue;
#181 if(pertypesizes[typecode] < count)
#182     pertypesizes[typecode] = count; /* keep max */
#188 int count = asym->data->length;
#190         if(count == 0) continue;
#191 if(pertypesizes[typecode] < count)
#192     pertypesizes[typecode] = count; /* keep max */
#706             int rank, size_t* start, size_t* count)
#709 genf77_writeattr(generator,sym,code,rank,start,count);
#711 genf77_writevar(generator,sym,code,rank,start,count);
#719           int rank, size_t* start, size_t* count)
#790 count[i]);
#825 count[reverse]);
#853        int rank, size_t* start, size_t* count)
genj.c#33                       int rank, size_t* start, size_t* count);
#417           int rank, size_t* start, size_t* count)
#420 genj_writeattr(generator,sym,code,rank,start,count);
#422 genj_writevar(generator,sym,code,rank,start,count);
#429              int rank, size_t* start, size_t* count)
#518               int rank, size_t* start, size_t* count)
genlib.c#1911    int count; /* number chars in newname */
#1990    count = 0;
#1999  count += lens[j] - 1;
#2005 count += idtlen - 1;
#2007    newlen = strlen(name) + count + 1; /* bytes left to be filled */
getvara.c#701           || odom->count[i] != odom->size[i])
#766    size_t count,rank0;
#821     count = dcesegmentsize(segment,0,rank0); /* how many to read */
#822     internlen = interntypesize*count;
#824            ocstat = oc_data_readn(conn,currentcontent,dap_zero,count,internlen,memory->next);
#832     count = dcesegmentsize(segment,safeindex,rank0); /* read in count chunks */
#833     internlen = interntypesize*count;
#835         ocstat = oc_data_readn(conn,currentcontent,odom->index,count,internlen,memory->next);
#879     count = dcesegmentsize(segment,0,rank0); /* how many to read */
#880     internlen = interntypesize*count;
#881            ocstat = oc_data_readn(conn,currentcontent,dap_zero,count,internlen,memory->next);
jdata.c#118j_list(GeneratorgeneratorSymbolsym, void* liststateListClass lc, int uid, size_t countBytebuffercodebuf, ...)
#122        if(count > 0) bbCat(codebuf,", ");
#136j_listend(GeneratorgeneratorSymbolsym, void* liststateListClass lc, int uid, size_t countBytebufferbuf, ...)
#142j_vlendecl(GeneratorgeneratorSymboltsymBytebuffercodebuf, int uid, size_t count, ...)
load.c#505    size_t count[NC_MAX_VAR_DIMS];
#537     count[0] = vars[varnum].nrecs;
#540     count[0] = dims[vars[varnum].dims[0]].size;
#546 count[idim] = dims[vars[varnum].dims[idim]].size;
#551 stat = nc_put_vara_schar(ncidvarnumstartcount,
#555 stat = nc_put_vara_text(ncidvarnumstartcountcharvalp);
#558 stat = nc_put_vara_short(ncidvarnumstartcountshortvalp);
#561 stat = nc_put_vara_int(ncidvarnumstartcountintvalp);
#564 stat = nc_put_vara_float(ncidvarnumstartcountfloatvalp);
#567 stat = nc_put_vara_double(ncidvarnumstartcountdoublevalp);
main.c#455 size_t count;
#465 count = fread(bom,1,2,fp);
#466 if(count == 2) {
memio.c#371            ssize_t count = read(fdposred);
#372            if(count < 0) {status = errno; goto unwind_open;}
#373            if(count == 0) {status = NC_ENOTNC; goto unwind_open;}
#374            red -= count;
#375            pos += count;
#503         ssize_t count = write(fdposwritten);
#504         if(count < 0)
#506         if(count == 0)
#508 written -= count;
#509 pos += count;
nc3dispatch.h#172         const size_t *start, const size_t *count,
#177      const size_t *start, const size_t *count,
nc3internal.h#73  unsigned long count;
nc4dispatch.h#146         const size_t *start, const size_t *count,
#151      const size_t *start, const size_t *count,
nc4hdf.c#497             hsize_t *starthsize_t *count)
#508      LOG((4, "start[%d]=%Ld  count[%d]=%Ld", d2start[d2], d2count[d2]));
#555  hsize_t start[NC_MAX_VAR_DIMS], count[NC_MAX_VAR_DIMS];
#587      count[i] = countp[i];
#617  log_dim_info(varfdimsfmaxdimsstartcount);
#629              (start[d2] == (hssize_t)fdims[d2] && count[d2] > 0))
#631          if (start[d2] + count[d2] > fdims[d2])
#651                              countNULL) < 0)
#656      if ((mem_spaceid = H5Screate_simple(var->ndimscountNULL)) < 0)
#735              if (start[d2] + count[d2] > fdims[d2])
#737                  xtend_size[d2] = (long long unsigned)(start[d2] + count[d2]);
#743              if (start[d2] + count[d2] > dim->len)
#745                  dim->len = start[d2] + count[d2];
#797                                  startNULLcountNULL) < 0)
#877  hsize_t *xtend_size = NULLcount[NC_MAX_VAR_DIMS];
#912      count[i] = countp[i];
#942  log_dim_info(varfdimsfmaxdimsstartcount);
#961            (start[d2] == (hssize_t)ulen && count[d2] > 0))
#963        if (start[d2] + count[d2] > ulen)
#972          fill_value_size[d2] = count[d2];
#973        else if (start[d2] + count[d2] > fdims[d2])
#974          fill_value_size[d2] = count[d2] - (fdims[d2] - start[d2]);
#977        count[d2] -= fill_value_size[d2];
#985            (start[d2] == (hssize_t)fdims[d2] && count[d2] > 0))
#987        if (start[d2] + count[d2] > fdims[d2])
#991        fill_value_size[d2] = count[d2];
#998    if (count[d2] == 0)
#1024                                  startNULLcountNULL) < 0)
#1028          if ((mem_spaceid = H5Screate_simple(var->ndimscountNULL)) < 0)
#1196          real_data_size *= (count[d2] - start[d2]);
#2680  size_t count = 0;
#2700          for (cp = (char *)srccp1 = destcount < lencount++)
#2712          for (bp = (signed char *)srcbp1 = destcount < lencount++)
#2716          for (bp = (signed char *)srcubp = destcount < lencount++)
#2724          for (bp = (signed char *)srcsp = destcount < lencount++)
#2728          for (bp = (signed char *)srcusp = destcount < lencount++)
#2738              for (bp = (signed char *)srclp = destcount < lencount++)
#2744              for (bp = (signed char *)srcip = destcount < lencount++)
#2749          for (bp = (signed char *)srcuip = destcount < lencount++)
#2757          for (bp = (signed char *)srclip = destcount < lencount++)
#2761          for (bp = (signed char *)srculip = destcount < lencount++)
#2769          for (bp = (signed char *)srcfp = destcount < lencount++)
#2773          for (bp = (signed char *)srcdp = destcount < lencount++)
#2787          for (ubp = (unsigned char *)srcbp = destcount < lencount++)
#2795          for (ubp = (unsigned char *)srcsp = destcount < lencount++)
#2799          for (ubp = (unsigned char *)srcubp1 = destcount < lencount++)
#2803          for (ubp = (unsigned char *)srcusp = destcount < lencount++)
#2809              for (ubp = (unsigned char *)srclp = destcount < lencount++)
#2815              for (ubp = (unsigned char *)srcip = destcount < lencount++)
#2820          for (ubp = (unsigned char *)srcuip = destcount < lencount++)
#2824          for (ubp = (unsigned char *)srclip = destcount < lencount++)
#2828          for (ubp = (unsigned char *)srculip = destcount < lencount++)
#2832          for (ubp = (unsigned char *)srcfp = destcount < lencount++)
#2836          for (ubp = (unsigned char *)srcdp = destcount < lencount++)
#2850          for (sp = (short *)srcubp = destcount < lencount++)
#2858          for (sp = (short *)srcbp = destcount < lencount++)
#2866          for (sp = (short *)srcsp1 = destcount < lencount++)
#2870          for (sp = (short *)srcusp = destcount < lencount++)
#2879            for (sp = (short *)srclp = destcount < lencount++)
#2882            for (sp = (short *)srcip = destcount < lencount++)
#2886          for (sp = (short *)srcuip = destcount < lencount++)
#2894          for (sp = (short *)srclip = destcount < lencount++)
#2898          for (sp = (short *)srculip = destcount < lencount++)
#2906          for (sp = (short *)srcfp = destcount < lencount++)
#2910          for (sp = (short *)srcdp = destcount < lencount++)
#2924          for (usp = (unsigned short *)srcubp = destcount < lencount++)
#2932          for (usp = (unsigned short *)srcbp = destcount < lencount++)
#2940          for (usp = (unsigned short *)srcsp = destcount < lencount++)
#2948          for (usp = (unsigned short *)srcusp1 = destcount < lencount++)
#2953            for (usp = (unsigned short *)srclp = destcount < lencount++)
#2956            for (usp = (unsigned short *)srcip = destcount < lencount++)
#2960          for (usp = (unsigned short *)srcuip = destcount < lencount++)
#2964          for (usp = (unsigned short *)srclip = destcount < lencount++)
#2968          for (usp = (unsigned short *)srculip = destcount < lencount++)
#2972          for (usp = (unsigned short *)srcfp = destcount < lencount++)
#2976          for (usp = (unsigned short *)srcdp = destcount < lencount++)
#2992              for (lp = (long *)srcubp = destcount < lencount++)
#3000              for (lp = (long *)srcbp = destcount < lencount++)
#3008              for (lp = (long *)srcsp = destcount < lencount++)
#3016              for (lp = (long *)srcusp = destcount < lencount++)
#3026                  for (lp = (long *)srclp1 = destcount < lencount++)
#3035                  for (lp = (long *)srcip = destcount < lencount++)
#3044              for (lp = (long *)srcuip = destcount < lencount++)
#3052              for (lp = (long *)srclip = destcount < lencount++)
#3056              for (lp = (long *)srculip = destcount < lencount++)
#3064              for (lp = (long *)srcfp = destcount < lencount++)
#3068              for (lp = (long *)srcdp = destcount < lencount++)
#3082              for (ip = (int *)srcubp = destcount < lencount++)
#3090              for (ip = (int *)srcbp = destcount < lencount++)
#3098              for (ip = (int *)srcsp = destcount < lencount++)
#3106              for (ip = (int *)srcusp = destcount < lencount++)
#3116                  for (ip = (int *)srclp1 = destcount < lencount++)
#3125                  for (ip = (int *)srcip1 = destcount < lencount++)
#3134              for (ip = (int *)srcuip = destcount < lencount++)
#3142              for (ip = (int *)srclip = destcount < lencount++)
#3146              for (ip = (int *)srculip = destcount < lencount++)
#3154              for (ip = (int *)srcfp = destcount < lencount++)
#3158              for (ip = (int *)srcdp = destcount < lencount++)
#3173          for (uip = (unsigned int *)srcubp = destcount < lencount++)
#3181          for (uip = (unsigned int *)srcbp = destcount < lencount++)
#3189          for (uip = (unsigned int *)srcsp = destcount < lencount++)
#3197          for (uip = (unsigned int *)srcusp = destcount < lencount++)
#3206            for (uip = (unsigned int *)srclp = destcount < lencount++)
#3213            for (uip = (unsigned int *)srcip = destcount < lencount++)
#3221          for (uip = (unsigned int *)srcuip1 = destcount < lencount++)
#3229          for (uip = (unsigned int *)srclip = destcount < lencount++)
#3233          for (uip = (unsigned int *)srculip = destcount < lencount++)
#3237          for (uip = (unsigned int *)srcfp = destcount < lencount++)
#3241          for (uip = (unsigned int *)srcdp = destcount < lencount++)
#3255          for (lip = (long long *)srcubp = destcount < lencount++)
#3263          for (lip = (long long *)srcbp = destcount < lencount++)
#3271          for (lip = (long long *)srcsp = destcount < lencount++)
#3279          for (lip = (long long *)srcusp = destcount < lencount++)
#3287          for (lip = (long long *)srcuip = destcount < lencount++)
#3296            for (lip = (long long *)srclp = destcount < lencount++)
#3303            for (lip = (long long *)srcip = destcount < lencount++)
#3311          for (lip = (long long *)srclip1 = destcount < lencount++)
#3315          for (lip = (long long *)srculip = destcount < lencount++)
#3323          for (lip = (long long *)srcfp = destcount < lencount++)
#3327          for (lip = (long long *)srcdp = destcount < lencount++)
#3341          for (ulip = (unsigned long long *)srcubp = destcount < lencount++)
#3349          for (ulip = (unsigned long long *)srcbp = destcount < lencount++)
#3357          for (ulip = (unsigned long long *)srcsp = destcount < lencount++)
#3365          for (ulip = (unsigned long long *)srcusp = destcount < lencount++)
#3373          for (ulip = (unsigned long long *)srcuip = destcount < lencount++)
#3382            for (ulip = (unsigned long long *)srclp = destcount < lencount++)
#3389            for (ulip = (unsigned long long *)srcip = destcount < lencount++)
#3397          for (ulip = (unsigned long long *)srclip = destcount < lencount++)
#3405          for (ulip = (unsigned long long *)srculip1 = destcount < lencount++)
#3409          for (ulip = (unsigned long long *)srcfp = destcount < lencount++)
#3413          for (ulip = (unsigned long long *)srcdp = destcount < lencount++)
#3427          for (fp = (float *)srcubp = destcount < lencount++)
#3435          for (fp = (float *)srcbp = destcount < lencount++)
#3443          for (fp = (float *)srcsp = destcount < lencount++)
#3451          for (fp = (float *)srcusp = destcount < lencount++)
#3459          for (fp = (float *)srcuip = destcount < lencount++)
#3468            for (fp = (float *)srclp = destcount < lencount++)
#3475            for (fp = (float *)srcip = destcount < lencount++)
#3483          for (fp = (float *)srclip = destcount < lencount++)
#3491          for (fp = (float *)srclip = destcount < lencount++)
#3499          for (fp = (float *)srcfp1 = destcount < lencount++)
#3507          for (fp = (float *)srcdp = destcount < lencount++)
#3521          for (dp = (double *)srcubp = destcount < lencount++)
#3529          for (dp = (double *)srcbp = destcount < lencount++)
#3537          for (dp = (double *)srcsp = destcount < lencount++)
#3545          for (dp = (double *)srcusp = destcount < lencount++)
#3553          for (dp = (double *)srcuip = destcount < lencount++)
#3562            for (dp = (double *)srclp = destcount < lencount++)
#3569            for (dp = (double *)srcip = destcount < lencount++)
#3577          for (dp = (double *)srclip = destcount < lencount++)
#3585          for (dp = (double *)srclip = destcount < lencount++)
#3593          for (dp = (double *)srcfp = destcount < lencount++)
#3601          for (dp = (double *)srcdp1 = destcount < lencount++)
#4044    int count;
#4052    count = 0;
#4053    stat = NC4_walk(h5->root_grp->hdf_grpid, &count);
#4057 isnc4 = (count >= 2);
nc_hashmap.c#63  unsigned long count = hm->count;
#69  hm->count = 0;
#81  assert(count == hm->count);
#88  unsigned long count = hm->count;
#94  hm->count = 0;
#106  assert(count == hm->count);
#123  hm->count = 0;
#133  if (hash->size*3/4 <= hash->count) {
#161 ++hash->count;
#180  if (hash->size*3/4 <= hash->count) {
#208 ++hash->count;
#243   --hash->count;
#280   --hash->count;
#299  if (hash->count)
#333  if (hash->count)
#366  return hash->count;
nc_iter.c#90      size_t *count /* returned count vector for next vara call */
#96            count[i] = 1;
#99        count[iter->right_dim] = iter->rows;
#102            count[i] = iter->dimsizes[i];
#111            count[iter->right_dim] = iter->rows;
#115                count[iter->right_dim] = iter->leftover;
#124 iter->to_get *= count[i];
nc_iter.h#46nc_next_iter(nciter_t *iterp, size_t *start, size_t *count);
nccopy.c#966    size_t *count;
#1039    count = (size_t *) emalloc((iterp->rank + 1) * sizeof(size_t));
#1043    while((ntoget = nc_next_iter(iterpstartcount)) > 0) {
#1044 NC_CHECK(nc_get_vara(igrpvaridstartcountbuf));
#1045 NC_CHECK(nc_put_vara(ogrpovaridstartcountbuf));
#1066    free(count);
#1243   size_t *count,   /* edge lengths for record data */
#1247    NC_CHECK(nc_get_vara(ncidvaridstartcountbuf));
#1248    NC_CHECK(nc_put_vara(ogrpovaridstartcountbuf));
#1262    size_t **count;
#1268    count = (size_t **) emalloc(nrec_vars * sizeof(size_t*));
#1283 count[ivar] = (size_t *) emalloc(ndims * sizeof(size_t));
#1293     count[ivar][ii] = dimlen;
#1296 count[ivar][0] = 1; /* 1 record */
#1312        start[ivar], count[ivar], buf[ivar]));
#1318 if(count[ivar])
#1319     free(count[ivar]);
#1323    if(count)
#1324 free(count);
ncd2dispatch.c#48static NCerror makeseqdim(NCDAPCOMMON*, CDFnodeseq, size_t countCDFnode** sqdimp);
#1658makeseqdim(NCDAPCOMMONdapcommCDFnodeseq, size_t countCDFnode** sqdimp)
#1672    sqdim->dim.declsize = count;
#1673    sqdim->dim.declsize0 = count;
ncdump.c#362 ssize_t count = read(fdposred);
#363 if(count < 0) {status = errno; goto done;}
#364        if(count == 0) {status = NC_ENOTNC; goto done;}
#366 red -= count;
#367 pos += count;
ncgeny.c#238static int count;
#2206     count = stacklen - stackbase;
#2207     if(count >= NC_MAX_VAR_DIMS) {
#2209 count = NC_MAX_VAR_DIMS - 1;
#2210 stacklen = stackbase + count;
#2212               dimset.ndims = count;
#2215         for(i=0;i<count;i++) {
#2280 count = stacklen - stackbase;
#2281 if(count >= NC_MAX_VAR_DIMS) {
#2283     count = NC_MAX_VAR_DIMS - 1;
#2284     stacklen = stackbase + count;
#2286           dimset.ndims = count;
#2287 if(count > 0) {
#2289     for(i=0;i<count;i++) {
nciter.c#242      size_t *count /* returned count vector for next vara call */
#252 count[i] = 1;
#255     count[iter->right_dim] = iter->rows;
#258 count[i] = iter->dimsizes[i];
#264     count[i] = iter->chunksizes[i];
#266     count[i] = iter->dimsizes[i];
#277 count[iter->right_dim] = iter->rows;
#281     count[iter->right_dim] = iter->leftover;
#293     count[i] = iter->chunksizes[i];
#295     count[i] = iter->dimsizes[i];
#296 if(leftover < count[i])
#297     count[i] = leftover;
#303 iter->to_get *= count[i];
nciter.h#50nc_next_iter(nciter_t *iterp, size_t *start, size_t *count);
nclog.c#192nclogtextn(int tag, const char* text, size_t count)
#195    fwrite(text,1,count,nclogstream);
nclog.h#26extern void nclogtextn(int tag, const char* text, size_t count);
nctime.c#281 delMonths = delMonths * nDel * delTime.count + bhtime.month - 1;
#295 delHours = delHours * (double)(nDel * delTime.count);
#506 delMonths *= delTime.count;
#520 delHours *= (double)delTime.count;
#829 deltime.count = 1;
#1043 deltime.count = 1;
nctime.h#127 long    count;      /* units count  */
oc.c#543    size_t count,i;
#551    err = oc_dds_nsubnodes(link,ddsnode,&count);
#553    for(i=0;i<count;i++) {
#958    size_t count=0,i;
#968    err = oc_dds_nsubnodes(link,ddsnode,&count);
#970    for(i=0;i<count;i++) {
#1375    size_t countrank;
#1389    count = octotaldimsize(rank,edges);
#1391    return OCTHROW(oc_data_readn(link,datanode,start,count,memsize,memory));
occonstraints.h#10    size_t count;
ocdata.c#235ocdata_read(OCstatestateOCdatadata, size_t start, size_t count,
#262    countsize = elemsize*count;
#275           || (start+count) > data->ninstances)
#278        stat = ocread(data,xdrs,(char*)memory,memsize,start,count);
#290ocread(OCdatadataXXDRxdrs, char* memory, size_t memsize, size_t start, size_t count)
#301    OCASSERT(count > 0);
#302    OCASSERT((start+count) <= data->ninstances);
#309    xdrtotal = count*data->xdrsize; /* amount (in xdr sizes) to read */
#313    totalsize = elemsize*count;
#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++) {
#399 if(count > data->nstrings)
#401 for(i=0;i<count;i++,sp++) {
ocdump.c#216    fprintf(stdout,":%lu",(unsigned long)(slice->first+slice->count)-1);
#329    unsigned int i,count,rem;
#348    count = (len / sizeof(int));
#351    for(pmem=memory,i=0;i<count;i++,pmem+=4) {
#353 if(i<(count-1))
#370    unsigned int i,count,rem;
#384    count = (len / sizeof(int));
#390    for(i=0;i<count;i++) {
ochttp.c#180 size_t count;
#185 count = fwrite(ptrsizenmembfetchdata->stream);
#186 if (count > 0) {
#187 fetchdata->size += (count * size);
#194 return count;
ocinternal.c#483        unsigned long count = tree->data.datasize - tree->data.bod;
#484        memcpy(tree->xdrmemory,tree->xdrmemory+tree->data.bod,count);
#485        tree->data.datasize = count;
#506 size_t count;
#508        count = fread(chunk,1,sizeof(chunk),tree->data.file);
#509 if(count <= 0) break; /* EOF;*/
#510        ocbytesappendn(state->packet,chunk,count);
oclog.c#196oclogtextn(int tag, const char* text, size_t count)
#199    fwrite(text,1,count,oclogstream);
oclog.h#26extern void oclogtextn(int tag, const char* text, size_t count);
ocread.c#242 off_t count = (off_t)read(fd,buf,sizeof(buf));
#243 if(count == 0)
#245 else if(count <  0) {
#250 ocbytesappendn(packet,buf,(unsigned long)count);
#251 totalread += count;
ocutil.c#165    size_t count = 1;
#167        count *= sizes[i];
#169    return count;
#476    size_t count = 0;
#478 count *= sizes[i];
#479 count += indices[i];
#481    return count;
#503    size_t count = 0;
#505 count *= sizes[i];
#506 count += (edges[i]-1);
#508    return count;
odom.c#31 odom->count[i] = (countp == NULL ? odom->declsize[i]
#35 ASSERT(odom->start[i] + odom->count[i] <= odom->declsize[i]);
#77 (unsigned long)odom->origin->count[ioffset]
#87    size_t index,start,count;
#92    count = odom->origin->count[offset];
#93    if(index < start + count) return 1;
#110              +odom->origin->count[ioffset]))
#134    size_t count = 0;
#137 if(i > 0) count *= odom->origin->declsize[ioffset];
#138 count += odom->origin->index[ioffset];
#140    return count;
#160    return odom->count;
odom.h#14    size_t    count[NC_MAX_VAR_DIMS];
parallel_vara.c#88    size_t global_nyglobal_nxstart[2], count[2];
#158    count[0] = NY;
#159    count[1] = NX;
#161    err = nc_put_vara_int(ncidvaridstartcount, &buf[0][0]); ERR
#182    err = nc_get_vara_int(ncidvaridstartcount, &buf[0][0]); ERR
pres_temp_4D_rd.c#70   size_t start[NDIMS], count[NDIMS];
#121   count[0] = 1;
#122   count[1] = NLVL;
#123   count[2] = NLAT;
#124   count[3] = NLON;
#134       count, &pres_in[0][0][0])))
#137       count, &temp_in[0][0][0])))
pres_temp_4D_wr.c#67   size_t start[NDIMS], count[NDIMS];
#176   count[0] = 1;
#177   count[1] = NLVL;
#178   count[2] = NLAT;
#179   count[3] = NLON;
#191      if ((retval = nc_put_vara_float(ncidpres_varidstartcount,
#194      if ((retval = nc_put_vara_float(ncidtemp_varidstartcount,
putget.c#46arrayp(const char *label, size_t count, const size_t *array)
#50 for(; count > 0; count--, array++)
t_nc.c#192createtestvars(int id, const struct tcdfvar *testvars, size_t count)
#198 for(ii = 0; (size_t) ii < countii++, vp++ )
test_get.c#3934    size_t count[MAX_RANK];
#4009                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4010                    nels *= count[j];
#4024     err = toMixedBase(jvar_rank[i], countindex2);
#4041                    err = nc_get_vars_text(ncidiindexcountstridevalue);
#4108    size_t count[MAX_RANK];
#4183                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4184                    nels *= count[j];
#4198     err = toMixedBase(jvar_rank[i], countindex2);
#4215                    err = nc_get_vars_uchar(ncidiindexcountstridevalue);
#4282    size_t count[MAX_RANK];
#4357                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4358                    nels *= count[j];
#4372     err = toMixedBase(jvar_rank[i], countindex2);
#4389                    err = nc_get_vars_schar(ncidiindexcountstridevalue);
#4456    size_t count[MAX_RANK];
#4531                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4532                    nels *= count[j];
#4546     err = toMixedBase(jvar_rank[i], countindex2);
#4563                    err = nc_get_vars_short(ncidiindexcountstridevalue);
#4630    size_t count[MAX_RANK];
#4705                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4706                    nels *= count[j];
#4720     err = toMixedBase(jvar_rank[i], countindex2);
#4737                    err = nc_get_vars_int(ncidiindexcountstridevalue);
#4804    size_t count[MAX_RANK];
#4879                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4880                    nels *= count[j];
#4894     err = toMixedBase(jvar_rank[i], countindex2);
#4911                    err = nc_get_vars_long(ncidiindexcountstridevalue);
#4978    size_t count[MAX_RANK];
#5053                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5054                    nels *= count[j];
#5068     err = toMixedBase(jvar_rank[i], countindex2);
#5085                    err = nc_get_vars_float(ncidiindexcountstridevalue);
#5152    size_t count[MAX_RANK];
#5227                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5228                    nels *= count[j];
#5242     err = toMixedBase(jvar_rank[i], countindex2);
#5259                    err = nc_get_vars_double(ncidiindexcountstridevalue);
#5326    size_t count[MAX_RANK];
#5401                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5402                    nels *= count[j];
#5416     err = toMixedBase(jvar_rank[i], countindex2);
#5433                    err = nc_get_vars_ushort(ncidiindexcountstridevalue);
#5500    size_t count[MAX_RANK];
#5575                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5576                    nels *= count[j];
#5590     err = toMixedBase(jvar_rank[i], countindex2);
#5607                    err = nc_get_vars_uint(ncidiindexcountstridevalue);
#5674    size_t count[MAX_RANK];
#5749                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5750                    nels *= count[j];
#5764     err = toMixedBase(jvar_rank[i], countindex2);
#5781                    err = nc_get_vars_longlong(ncidiindexcountstridevalue);
#5848    size_t count[MAX_RANK];
#5923                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5924                    nels *= count[j];
#5938     err = toMixedBase(jvar_rank[i], countindex2);
#5955                    err = nc_get_vars_ulonglong(ncidiindexcountstridevalue);
#6025    size_t count[MAX_RANK];
#6102                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6103                    nels *= count[j];
#6119 imap[j-1] = imap[j] * count[j];
#6123                    err = toMixedBase(jvar_rank[i], countindex2);
#6140                    err = nc_get_varm_text(ncid,i,index,count,stride,imap,value);
#6207    size_t count[MAX_RANK];
#6284                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6285                    nels *= count[j];
#6301 imap[j-1] = imap[j] * count[j];
#6305                    err = toMixedBase(jvar_rank[i], countindex2);
#6322                    err = nc_get_varm_uchar(ncid,i,index,count,stride,imap,value);
#6389    size_t count[MAX_RANK];
#6466                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6467                    nels *= count[j];
#6483 imap[j-1] = imap[j] * count[j];
#6487                    err = toMixedBase(jvar_rank[i], countindex2);
#6504                    err = nc_get_varm_schar(ncid,i,index,count,stride,imap,value);
#6571    size_t count[MAX_RANK];
#6648                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6649                    nels *= count[j];
#6665 imap[j-1] = imap[j] * count[j];
#6669                    err = toMixedBase(jvar_rank[i], countindex2);
#6686                    err = nc_get_varm_short(ncid,i,index,count,stride,imap,value);
#6753    size_t count[MAX_RANK];
#6830                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6831                    nels *= count[j];
#6847 imap[j-1] = imap[j] * count[j];
#6851                    err = toMixedBase(jvar_rank[i], countindex2);
#6868                    err = nc_get_varm_int(ncid,i,index,count,stride,imap,value);
#6935    size_t count[MAX_RANK];
#7012                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7013                    nels *= count[j];
#7029 imap[j-1] = imap[j] * count[j];
#7033                    err = toMixedBase(jvar_rank[i], countindex2);
#7050                    err = nc_get_varm_long(ncid,i,index,count,stride,imap,value);
#7117    size_t count[MAX_RANK];
#7194                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7195                    nels *= count[j];
#7211 imap[j-1] = imap[j] * count[j];
#7215                    err = toMixedBase(jvar_rank[i], countindex2);
#7232                    err = nc_get_varm_float(ncid,i,index,count,stride,imap,value);
#7299    size_t count[MAX_RANK];
#7376                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7377                    nels *= count[j];
#7393 imap[j-1] = imap[j] * count[j];
#7397                    err = toMixedBase(jvar_rank[i], countindex2);
#7414                    err = nc_get_varm_double(ncid,i,index,count,stride,imap,value);
#7481    size_t count[MAX_RANK];
#7558                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7559                    nels *= count[j];
#7575 imap[j-1] = imap[j] * count[j];
#7579                    err = toMixedBase(jvar_rank[i], countindex2);
#7596                    err = nc_get_varm_ushort(ncid,i,index,count,stride,imap,value);
#7663    size_t count[MAX_RANK];
#7740                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7741                    nels *= count[j];
#7757 imap[j-1] = imap[j] * count[j];
#7761                    err = toMixedBase(jvar_rank[i], countindex2);
#7778                    err = nc_get_varm_uint(ncid,i,index,count,stride,imap,value);
#7845    size_t count[MAX_RANK];
#7922                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7923                    nels *= count[j];
#7939 imap[j-1] = imap[j] * count[j];
#7943                    err = toMixedBase(jvar_rank[i], countindex2);
#7960                    err = nc_get_varm_longlong(ncid,i,index,count,stride,imap,value);
#8027    size_t count[MAX_RANK];
#8104                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8105                    nels *= count[j];
#8121 imap[j-1] = imap[j] * count[j];
#8125                    err = toMixedBase(jvar_rank[i], countindex2);
#8142                    err = nc_get_varm_ulonglong(ncid,i,index,count,stride,imap,value);
test_nstride_cached.c#86    size_t start[5], count[5];
#115        count[idim] = 1;
#150    count[0] =  XSIZE;
#151    count[1] =  YSIZE;
#159 idim,start[idim],idim,count[idim],idim,stride[idim]);
#162    ncstatus = nc_get_vars_float (ncidvaridstartcountstride, (float*) dat);
#200    count[0] =  XSIZE;
#201    count[1] =  YSIZE;
#209 idimstart[idim], idimcount[idim], idimstride[idim]);
#212    ncstatus = nc_get_vars_float (ncidvaridstartcountstride, (float*) dat);
#257    count[0] =  5;
#258    count[1] =  2;
#266 idim,start[idim],idim,count[idim],idim,stride[idim]);
#270    ncstatus = nc_get_vars_float (ncidvaridstartcountstride,  (float*) sdat);
test_partvar.c#45    size_t* count;
#56static void odom_set(Odomodom, size_t* start, size_t* count);
#61static size_t subslice(int rank, size_t* count, int startdim);
#62static int check(float*, size_t* start, size_t* count);
#77void dump(float* source, size_t start, size_t count)
#81    printf("start=%lu count=%lu\n",(unsigned long)start,(unsigned long)count);
#82    for(i=0;i<count;i++) {
#96    size_t count[RANK];
#129    memcpy(count,count0,sizeof(count0));
#130    count[0] = 1;
#136        if((retval = nc_get_vara_float(ncid,varid,start,count,fpos)))
#138 nslice = subslice(RANK,count,1);
#160subslice(int rank, size_t* count, int startdim)
#165 offset *= count[i];
#170check(float* target, size_t* start, size_t* count)
#176    odom_set(odom,start,count);
#200    odom->count = (size_t*)calloc(sizeof(size_t)*rank,1);
#210    free(odom->count);
#215odom_set(Odomodom, size_t* start, size_t* count)
#221        odom->count[i] = count[i];
#225        odom->stop[i] =  odom->start[i] + odom->count[i];
#256 offset *= odom->count[i];
test_put.c#6748    size_t count[MAX_RANK];
#6847     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6848     nels *= count[j];
#6861     err = toMixedBase(jvar_rank[i], countindex2);
#6874     err = nc_put_vars_text(ncidiindexcountstridevalue);
#6920    size_t count[MAX_RANK];
#7019     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7020     nels *= count[j];
#7033     err = toMixedBase(jvar_rank[i], countindex2);
#7046     err = nc_put_vars_uchar(ncidiindexcountstridevalue);
#7092    size_t count[MAX_RANK];
#7191     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7192     nels *= count[j];
#7205     err = toMixedBase(jvar_rank[i], countindex2);
#7218     err = nc_put_vars_schar(ncidiindexcountstridevalue);
#7264    size_t count[MAX_RANK];
#7363     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7364     nels *= count[j];
#7377     err = toMixedBase(jvar_rank[i], countindex2);
#7390     err = nc_put_vars_short(ncidiindexcountstridevalue);
#7436    size_t count[MAX_RANK];
#7535     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7536     nels *= count[j];
#7549     err = toMixedBase(jvar_rank[i], countindex2);
#7562     err = nc_put_vars_int(ncidiindexcountstridevalue);
#7608    size_t count[MAX_RANK];
#7707     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7708     nels *= count[j];
#7721     err = toMixedBase(jvar_rank[i], countindex2);
#7734     err = nc_put_vars_long(ncidiindexcountstridevalue);
#7780    size_t count[MAX_RANK];
#7879     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7880     nels *= count[j];
#7893     err = toMixedBase(jvar_rank[i], countindex2);
#7906     err = nc_put_vars_float(ncidiindexcountstridevalue);
#7952    size_t count[MAX_RANK];
#8051     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8052     nels *= count[j];
#8065     err = toMixedBase(jvar_rank[i], countindex2);
#8078     err = nc_put_vars_double(ncidiindexcountstridevalue);
#8124    size_t count[MAX_RANK];
#8223     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8224     nels *= count[j];
#8237     err = toMixedBase(jvar_rank[i], countindex2);
#8250     err = nc_put_vars_ushort(ncidiindexcountstridevalue);
#8296    size_t count[MAX_RANK];
#8395     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8396     nels *= count[j];
#8409     err = toMixedBase(jvar_rank[i], countindex2);
#8422     err = nc_put_vars_uint(ncidiindexcountstridevalue);
#8468    size_t count[MAX_RANK];
#8567     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8568     nels *= count[j];
#8581     err = toMixedBase(jvar_rank[i], countindex2);
#8594     err = nc_put_vars_longlong(ncidiindexcountstridevalue);
#8640    size_t count[MAX_RANK];
#8739     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8740     nels *= count[j];
#8753     err = toMixedBase(jvar_rank[i], countindex2);
#8766     err = nc_put_vars_ulonglong(ncidiindexcountstridevalue);
#8815    size_t count[MAX_RANK];
#8916                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8917                    nels *= count[j];
#8933                        imap[j-1] = imap[j] * count[j];
#8936                    err = toMixedBase(jvar_rank[i], countindex2);
#8949                    err = nc_put_varm_text(ncid,i,index,count,stride,imap,value);
#8995    size_t count[MAX_RANK];
#9096                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9097                    nels *= count[j];
#9113                        imap[j-1] = imap[j] * count[j];
#9116                    err = toMixedBase(jvar_rank[i], countindex2);
#9129                    err = nc_put_varm_uchar(ncid,i,index,count,stride,imap,value);
#9175    size_t count[MAX_RANK];
#9276                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9277                    nels *= count[j];
#9293                        imap[j-1] = imap[j] * count[j];
#9296                    err = toMixedBase(jvar_rank[i], countindex2);
#9309                    err = nc_put_varm_schar(ncid,i,index,count,stride,imap,value);
#9355    size_t count[MAX_RANK];
#9456                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9457                    nels *= count[j];
#9473                        imap[j-1] = imap[j] * count[j];
#9476                    err = toMixedBase(jvar_rank[i], countindex2);
#9489                    err = nc_put_varm_short(ncid,i,index,count,stride,imap,value);
#9535    size_t count[MAX_RANK];
#9636                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9637                    nels *= count[j];
#9653                        imap[j-1] = imap[j] * count[j];
#9656                    err = toMixedBase(jvar_rank[i], countindex2);
#9669                    err = nc_put_varm_int(ncid,i,index,count,stride,imap,value);
#9715    size_t count[MAX_RANK];
#9816                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9817                    nels *= count[j];
#9833                        imap[j-1] = imap[j] * count[j];
#9836                    err = toMixedBase(jvar_rank[i], countindex2);
#9849                    err = nc_put_varm_long(ncid,i,index,count,stride,imap,value);
#9895    size_t count[MAX_RANK];
#9996                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9997                    nels *= count[j];
#10013                        imap[j-1] = imap[j] * count[j];
#10016                    err = toMixedBase(jvar_rank[i], countindex2);
#10029                    err = nc_put_varm_float(ncid,i,index,count,stride,imap,value);
#10075    size_t count[MAX_RANK];
#10176                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10177                    nels *= count[j];
#10193                        imap[j-1] = imap[j] * count[j];
#10196                    err = toMixedBase(jvar_rank[i], countindex2);
#10209                    err = nc_put_varm_double(ncid,i,index,count,stride,imap,value);
#10255    size_t count[MAX_RANK];
#10356                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10357                    nels *= count[j];
#10373                        imap[j-1] = imap[j] * count[j];
#10376                    err = toMixedBase(jvar_rank[i], countindex2);
#10389                    err = nc_put_varm_ushort(ncid,i,index,count,stride,imap,value);
#10435    size_t count[MAX_RANK];
#10536                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10537                    nels *= count[j];
#10553                        imap[j-1] = imap[j] * count[j];
#10556                    err = toMixedBase(jvar_rank[i], countindex2);
#10569                    err = nc_put_varm_uint(ncid,i,index,count,stride,imap,value);
#10615    size_t count[MAX_RANK];
#10716                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10717                    nels *= count[j];
#10733                        imap[j-1] = imap[j] * count[j];
#10736                    err = toMixedBase(jvar_rank[i], countindex2);
#10749                    err = nc_put_varm_longlong(ncid,i,index,count,stride,imap,value);
#10795    size_t count[MAX_RANK];
#10896                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10897                    nels *= count[j];
#10913                        imap[j-1] = imap[j] * count[j];
#10916                    err = toMixedBase(jvar_rank[i], countindex2);
#10929                    err = nc_put_varm_ulonglong(ncid,i,index,count,stride,imap,value);
test_read.c#1040    size_t count[MAX_RANK];
#1111     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1112     nels *= count[j];
#1127     err = nc_get_vars(ncidiindexcountstridebuf);
#1137 err = toMixedBase(jvar_rank[i], countindex2);
#1205    size_t count[MAX_RANK];
#1287 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1301     err = nc_get_varm(ncidiindexcountstrideimap2p);
test_vara.c#41    size_t* count;
#52static void odom_set(Odomodom, size_t* start, size_t* count);
#57static int check(size_t* start, size_t* count);
#77    size_t count[RANK];
#103    memcpy(count,count0,sizeof(count0));
#105    if((retval = nc_get_vara_float(ncid,varid,start,count,(float*)threeD)))
#107    if(!check(start,count)) goto fail;
#111    memcpy(count,count0,sizeof(count0));
#112    count[0] = 1;
#114    if((retval = nc_get_vara_float(ncid,varid,start,count,(float*)threeD)))
#116    if(!check(start,count)) goto fail;
#128static int check(size_t* start, size_t* count)
#134    odom_set(odom,start,count);
#156    odom->count = (size_t*)calloc(sizeof(size_t)*rank,1);
#165    free(odom->count);
#170static void odom_set(Odomodom, size_t* start, size_t* count)
#176        odom->count[i] = count[i];
#180        odom->stop[i] =  odom->start[i] + odom->count[i];
#208 offset *= odom->count[i];
test_varm3.c#78    size_t start[5], count[5];
#117        count[idim] = 1;
#128    count[0] = 12;
#135    for(i=0;i<ndim;i++) printf(" %d",(int)count[i]);
#144    err = nc_get_vars_float (ncidvaridstartcountstride,
#151    check(err = nc_get_varm_float (ncidvaridstartcountstrideimap,(float*) dat),__FILE__,__LINE__);
#174    count[0] =  6;
#182    for(i=0;i<ndim;i++) printf(" %d",(int)count[i]);
#191    check(err = nc_get_vars_float(ncidvaridstartcountstride,
#197    check(err = nc_get_varm_float(ncidvaridstartcountstrideimap,
#219    count[0] =  3;
#227    for(i=0;i<ndim;i++) printf(" %d",(int)count[i]);
#236    check(err = nc_get_vars_float(ncidvaridstartcountstride,
#242    check(err = nc_get_varm_float(ncidvaridstartcountstrideimap,
test_write.c#925    size_t count[MAX_RANK];
#1004                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1005                    nels *= count[j];
#1019     err = toMixedBase(jvar_rank[i], countindex2);
#1035     err = nc_put_vars(ncidiindexcountstridebuf);
#1078    size_t count[MAX_RANK];
#1182 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1196     err = nc_put_varm(ncidiindexcountstrideimap2p);
tst_ar4.c#105   size_t start[NDIMS3], count[NDIMS3];
#181      count[0] = TIME_LEN;
#182      count[1] = 1;
#183      count[2] = 1;
#187      if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#196     if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#208      count[0] = 1;
#209      count[1] = LAT_LEN;
#210      count[2] = LON_LEN;
#214      if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
#222  if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
tst_ar4_3d.c#113   size_t start[NDIMS3], count[NDIMS3];
#189      count[0] = TIME_LEN;
#190      count[1] = 1;
#191      count[2] = 1;
#195      if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#204     if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#216      count[0] = 1;
#217      count[1] = LAT_LEN;
#218      count[2] = LON_LEN;
#222      if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
#230  if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
tst_ar4_4d.c#220   size_t start[NDIMS4], count[NDIMS4];
#303      count[0] = TIME_LEN;
#304      count[1] = 1;
#305      count[2] = 1;
#306      count[3] = 1;
#310      if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#321        if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#337      count[0] = 1;
#338      count[1] = DEPTH_LEN;
#339      count[2] = 1;
#340      count[3] = 1;
#344      if (nc_get_vara_float(ncidvaridstartcountvert_data)) ERR_RET;
#372      count[0] = 1;
#373      count[1] = 1;
#374      count[2] = LAT_LEN;
#375      count[3] = LON_LEN;
#379      if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
#389     if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
tst_big_rvar.c#48    size_t count[NUMDIMS] = {1, 1, DIM2DIM3};
#71    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#73    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#81    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#95    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
tst_big_var2.c#52    size_t count[NUMDIMS] = {1, DIM1DIM2};
#75    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#81    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#89    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#103    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
tst_big_var6.c#50    size_t count[NUMDIMS] = {1, 1, 1, DIM3};
#71    if (nc_put_vara_short(ncidvaridstartcount, &data[0])) ERR;
#79    if (nc_put_vara_short(ncidvaridstartcount, &data[0])) ERR;
#85    if (nc_get_vara_short(ncidvaridstartcount, &data[0])) ERR;
tst_bug324.c#82     size_t count[1] = {LEN_LAT};
#83     if ( nc_get_vara(ncidlat_idstartcountlat_data) ) ERR;
#89     size_t count[1] = {LEN_H};
#90     if ( nc_get_vara(ncidh_idstartcounth_data) ) ERR;
tst_chunks3.c#168    size_t start[3], count[3];
#291    count[0] = 1;
#292    count[1] = dims[1];
#293    count[2] = dims[2];
#300 if((stat = nc_put_vara(ncidvarid_gstartcount, &varyz[0])))
#312 if((stat = nc_put_vara(ncidvarid_kstartcount, &varyz[0])))
#328 if((stat = nc_put_vara(ncidvarid_xstartcount, &varyz[0])))
#344    count[0] = dims[0];
#345    count[1] = 1;
#346    count[2] = dims[2];
#353 if((stat = nc_put_vara(ncidvarid_gstartcount, &varxz[0])))
#365 if((stat = nc_put_vara(ncidvarid_kstartcount, &varxz[0])))
#381 if((stat = nc_put_vara(ncidvarid_xstartcount, &varxz[0])))
#397    count[0] = dims[0];
#398    count[1] = dims[1];
#399    count[2] = 1;
#406 if((stat = nc_put_vara(ncidvarid_gstartcount, &varxy[0])))
#418 if((stat = nc_put_vara(ncidvarid_kstartcount, &varxy[0])))
#434 if((stat = nc_put_vara(ncidvarid_xstartcount, &varxy[0])))
#450    count[0] = 1;
#451    count[1] = dims[1];
#452    count[2] = dims[2];
#459 if((stat = nc_get_vara(ncidvarid_gstartcount, &varyz[0])))
#471 if((stat = nc_get_vara(ncidvarid_kstartcount, &varyz[0])))
#487 if((stat = nc_get_vara(ncidvarid_xstartcount, &varyz[0])))
#503    count[0] = dims[0];
#504    count[1] = 1;
#505    count[2] = dims[2];
#512 if((stat = nc_get_vara(ncidvarid_gstartcount, &varxz[0])))
#524 if((stat = nc_get_vara(ncidvarid_kstartcount, &varxz[0])))
#540 if((stat = nc_get_vara(ncidvarid_xstartcount, &varxz[0])))
#556    count[0] = dims[0];
#557    count[1] = dims[1];
#558    count[2] = 1;
#565 if((stat = nc_get_vara(ncidvarid_gstartcount, &varxy[0])))
#577 if((stat = nc_get_vara(ncidvarid_kstartcount, &varxy[0])))
#593 if((stat = nc_get_vara(ncidvarid_xstartcount, &varxy[0])))
tst_comp.c#39       int count;
#73   NC_COMPOUND_OFFSET(struct obs_tcount), NC_INT)) ERR;
#133       val_in.count != missing_val.count ||
#148       if (val_in.count != obsdata[i].countERR;
tst_compounds.c#631     int count;
#658  obsdata[i].count = 2 * i + 1;
#664      missing_val.count = 99;
#676      if (nc_insert_compound(ncidtypeid, "count", NC_COMPOUND_OFFSET(struct obs_tcount),
#726   val_in.count != missing_val.count ||
#737  if (val_in.count != obsdata[i].countERR;
#759     int count;
#809   val_in.count != missing_val.count ||
#820  if (val_in.count != obsdata[i].countERR;
tst_coords3.c#84   size_t start[DATA_NDIMS] = {0, 0, 0}, count[DATA_NDIMS] = {1, YC_LENXC_LEN};
#89   if (nc_get_vara_float(ncid, 0, startcount, (float *)temp_in)) ERR_RET;
#288      size_t start[DATA_NDIMS] = {0, 0, 0}, count[DATA_NDIMS] = {1, YC_LENXC_LEN};
#354      if (nc_put_vara_float(ncid, 0, startcount, (const float *)temp)) ERR;
#383      size_t start[DATA_NDIMS] = {0, 0, 0}, count[DATA_NDIMS] = {1, YC_LENXC_LEN};
#415      if (nc_put_vara_float(ncid, 0, startcount, (const float *)temp)) ERR;
tst_create_files.c#41       size_t start[NDIMS3], count[NDIMS3];
#76       count[0] = 1;
#80   count[d] = dim_len[d];
#83   if (nc_put_vara_float(ncidvaridstartcount, (const float *) data))
tst_dims.c#455      size_t start[MAX_DIMS], count[MAX_DIMS];
#488      count[0] = 1;
#489      if (nc_put_vara_ulonglong(ncid, 0, startcountuint64_data)) ERR;
#619      size_t start[MAX_DIMS], count[MAX_DIMS], index[MAX_DIMS];
#646      count[0] = 1;
#647      if (nc_put_vara(ncidhp_varidstartcountdata)) ERR;
#845      size_t start[4], count[4];
#1016      count[0] = LAT_LEN;
#1017      count[1] = LON_LEN;
#1018      count[2] = LEVEL_LEN;
#1019      count[3] = TIME_LEN;
#1020      if (nc_put_vara(ncidpres_varidstartcount,
#1022      count[2] = TIME_LEN;
#1023      if (nc_put_vara(ncidhp_varidstartcount,
tst_dims2.c#250      size_t time_lenbeam_lenstart[NDIMS] = {0, 0}, count[NDIMS] = {1, MAX_VALUES};
#271      if (nc_put_vara_double(ncidvaridstartcountvalue)) ERR;
#279      if (nc_put_vara_double(ncidvaridstartcountvalue)) ERR;
#298      size_t count[] = {1, 1};
#321     count[1] = j;
#323     count[1] = 1000-j;
#325  if (nc_put_vara_int(ncidvaridstartcountvalue)) ERR;
#326  time_recs = MAX(time_recsstart[0] + count[0]);
#327  beam_recs = MAX(beam_recsstart[1] + count[1]);
#355      size_t index[NDIMS], count[NDIMS], len_in;
#378      count[0] = 1;
#379      count[1] = TL; /* Note we are not writing NULL char. */
#380      if (nc_put_vara_text(ncidvaridindexcountttext)) ERR;
#402      count[0] = 1;
#403      count[1] = TL; /* Note we are not writing NULL char. */
#405  if (nc_put_vara_text(ncidvaridindexcountttext)) ERR;
tst_diskless.c#183    size_t count[1] = {DIM1_LEN};
#216    if (nc_put_vara_short(ncidvarid2startcountshort_data)) ERR;
tst_diskless3.c#53   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#74      count[0] = 1;
#79  if((status=nc_put_vara_text(ncidvarid[v], startcount, &data[r]))) ERRSTAT(status);
#109   size_t start[NDIMS], count[NDIMS];
#119   count[0] = 1;
#121   if((status=nc_put_vara_text(ncidvaridstartcount, &data))) ERRSTAT(status);
tst_diskless4.c#47    size_t count[1];
#163 count[0] = CHUNKSIZE;
#165 if((status=nc_put_vara(ncid,varids[iv],start,count,(void*)data)))
#174 count[0] = CHUNKSIZE;
#175 if((status=nc_get_vara(ncid,varids[iv],start,count,(void*)data)))
tst_files.c#322      size_t count[NDIMS], index[NDIMS] = {0};
#340  count[0] = TEXT_LEN + 1;
#341  if (nc_put_vara_text(ncid[f], varidindexcountttext)) ERR;
#347  if (nc_get_vara_text(ncid[f], varidindexcount, (char *)ttext_in)) ERR;
tst_files2.c#96   size_t start[MAX_DIMS], count[MAX_DIMS];
#139  count[d] = 1;
#143  count[d] = dim_len[d];
#154        if (nc_put_vara_float(ncidvarids[i], startcount,
#160     if (nc_put_vara_float(ncidvarids[i], startcount,
tst_files3.c#32   size_t count[NDIMS] = {1, 1, Z_LEN};
#47  if (nc_put_vara_float(ncidvarstartcountdata)) ERR_RET;
#56   size_t start[NDIMS] = {0, 0, 0}, count[NDIMS] = {X_LENY_LENZ_LEN};
#69   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#78   size_t start[NDIMS] = {0, 0, 0}, count[NDIMS] = {X_LENY_LENZ_LEN};
#91   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#104   hsize_t count[NDIMS] = {1, 1, Z_LEN};
#135   if ((mem_spaceid = H5Screate_simple(NDIMScountNULL)) < 0) ERR;
#143  countNULL) < 0) ERR_RET;
tst_files4.c#54       size_t count[4] = {1, SLICE_LENPARTICLE_LENAXIS_LEN};
#83       startcountdata)) ERR;
tst_fill_attr_vanish.c#45  size_t start[1] = {0}, count[1] = {1};
#76  if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_fillbug.c#28   size_t start[1] = {0}, count[1] = {1};
#50   if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_fills.c#94      size_t count[2] = {1, MAX_VALS};
#109      if (nc_put_vara_int(ncidrec_idstartcountrec)) ERR;
#112      if (nc_get_vara_text(ncid, 1, startcountvals)) ERR;
#122      if (nc_get_vara_text(ncid, 1, startcountvals)) ERR;
#266  size_t count[] = {1, NVALS};
#274        if (nc_get_vara_text(ncidvaridstartcountvals)) ERR;
#282        if (nc_get_vara_schar(ncidvaridstartcountvals)) ERR;
#290        if (nc_get_vara_short(ncidvaridstartcountvals)) ERR;
#298        if (nc_get_vara_int(ncidvaridstartcountvals)) ERR;
#306        if (nc_get_vara_float(ncidvaridstartcountvals)) ERR;
#314        if (nc_get_vara_double(ncidvaridstartcountvals)) ERR;
tst_grps.c#865      size_t start[1] = {0}, count[1] = {3};
#874      if (nc_put_vara_int(henry_vii_idvaridstartcountdata_out)) ERR;
#890      if (nc_get_vara_int(grpids_in[0], 0, startcountdata_in)) ERR;
tst_grps2.c#172      size_t start[1] = {0}, count[1] = {3};
#181      if (nc_put_vara_int(henry_vii_idvaridstartcountdata_out)) ERR;
#197      if (nc_get_vara_int(grpids_in[0], 0, startcountdata_in)) ERR;
tst_h4_lendian.c#63    intn ijcount;
#71    count = 0;
#75          array_data[j][i] = count++;
tst_h_compounds.c#285            int count;
#306  obsdata[i].count = 2 * i + 1;
#319      if (H5Tinsert(typeidCOUNTHOFFSET(struct obs_tcount), H5T_NATIVE_INT) < 0) ERR;
#361             obsdata[i].count != obsdata_in[i].count || obsdata[i].relhum != obsdata_in[i].relhum ||
#401             obsdata[i].count != obsdata2_in[i].count || obsdata[i].relhum != obsdata2_in[i].relhum ||
tst_h_dimscales2.c#566  hsize_t count[DIMS2] = {1, NUM_VALS};
#595  startNULLcountNULL) < 0) ERR;
#596  if ((mem_spaceid = H5Screate_simple(DIMS2countNULL)) < 0) ERR;
#617  startNULLcountNULL) < 0) ERR;
#618  if ((mem_spaceid = H5Screate_simple(DIMS2countNULL)) < 0) ERR;
tst_h_enums.c#156      hsize_t start[1] = {1}, count[1] = {1};
#199       startNULLcountNULL) < 0) ERR;
tst_h_files.c#176      hsize_t start[NDIMS], count[NDIMS];
#207      count[0] = SC;
#213  startNULLcountNULL) < 0) ERR;
#244      hsize_t start[MAX_DIMS],  count[MAX_DIMS];
#342      count[0] = 1;
#343      count[1] = 2097153;
#344      if (H5Sselect_hyperslab(file_spaceidH5S_SELECT_SETstartNULLcountNULL) < 0) ERR;
#345      if ((mem_spaceid = H5Screate_simple(NDIMS2countNULL)) < 0) ERR;
tst_h_par.c#68      hsize_t start[NDIMS], count[NDIMS];
#127  count[0] = SC1;
#129  startNULLcountNULL) < 0) ERR;
#186  count[0] = SC1;
#188  startNULLcountNULL) < 0)
tst_h_strings2.c#32      hsize_t xtend_size[NDIMS] = {2}, start[NDIMS] = {1}, count[NDIMS] = {1};
#94       startNULLcountNULL) < 0) ERR;
#97      if ((mem_spaceid = H5Screate_simple(NDIMScountNULL)) < 0) ERR;
#129      hsize_t start[NDIMS] = {1}, count[NDIMS] = {1};
#182       startNULLcountNULL) < 0) ERR;
#185      if ((mem_spaceid = H5Screate_simple(NDIMScountNULL)) < 0)
tst_h_vars.c#68      hsize_t start[MAX_DIMS], count[MAX_DIMS];
#146      count[0] = 1;
#147      count[1] = LAT_LEN;
#148      count[2] = LON_LEN;
#153       startNULLcountNULL) < 0) ERR;
tst_h_vars2.c#425     int count;
#458      if (f1.day != m.day || f1.elev != m.elev || f1.count != m.count ||
#466      if (f2.day != m.day || f2.elev != m.elev || f2.count != m.count ||
tst_knmi.c#90   size_t start[NDIMS3], count[NDIMS3];
tst_large.c#76    size_t start[NUMDIMS], count[NUMDIMS];
#90    count[0] = 1;
#91    count[1] = DIM2;
#93 if (nc_put_vara_schar(ncidvaridstartcountvals))
tst_large.c#32      size_t start[NUMDIMS] = {0, 0}, count[NUMDIMS] = {1, DIM2};
#48      if (nc_put_vara_schar(ncidvaridstartcountvals)) ERR;
tst_large2.c#35      size_t count[NDIMS] = {1, LAT_LENLON_LEN};
#71     if (nc_put_vara_float(ncidvaridstartcountdata)) ERR;
#80     if (nc_get_vara_float(ncidvaridstartcountdata)) ERR;
tst_nc4perf.c#38   size_t start[NDIMS1], count[NDIMS1];
#86      count[0] = DIMSIZE2;
#87      count[1] = DIMSIZE1 / mpi_size;
#97  if (nc_put_vara_float(ncidvarid1[i], startcountdata)) ERR;
tst_nofill2.c#36   size_t count[NDIMS4] = {TIME_LEN, 1, LAT_LENLON_LEN};
#70      if (nc_put_vara_float(ncidzonal_wnd_idstartcountzonal_wnd)) ERR;
tst_parallel.c#41    size_t start[NDIMS], count[NDIMS];
#123    count[0] = DIMSIZE/mpi_size;
#124    count[1] = DIMSIZE;
#125    count[2] = 1;
#139       if (nc_put_vara_int(ncidv1idstartcountslab_data)) ERR;
tst_parallel2.c#41    size_t count[NDIMS] = {1, DIMSIZEDIMSIZE};
#145       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
#186       if (nc_get_vara_int(ncidvaridstartcountdata_in)) ERR;
tst_parallel3.c#190   size_t count[NDIMS1];
#229   count[0] = DIMSIZE2;
#230   count[1] = DIMSIZE/mpi_size;
#235   if (!(data = malloc(sizeof(int)*count[1]*count[0]))) ERR;
#237   for (j = 0; j < count[0]; j++){
#238      for (i = 0; i < count[1]; i++)
#246   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#308   count[0] = DIMSIZE2;
#309   count[1] = DIMSIZE/mpi_size;
#315   if (!(rdata = malloc(sizeof(int)*count[1]*count[0]))) ERR;
#316   if (nc_get_vara_int(ncidrvidstartcountrdata)) ERR;
#319   for (j=0; j<count[0];j++){
#320      for (i=0; i<count[1]; i++){
#402   size_t count[NDIMS1];
#445   count[0] = DIMSIZE2;
#446   count[1] = DIMSIZE/mpi_size;
#452   data      = malloc(sizeof(int)*count[1]*count[0]);
#454   for(j = 0; j < count[0]; j++)
#455      for (i = 0; i < count[1]; i++)
#461   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#473   count[0] = DIMSIZE2;
#474   count[1] = DIMSIZE/mpi_size;
#579   size_t start[NDIMS1], count[NDIMS1];
#628         count[0] = DIMSIZE2/2;
#629         count[1] = count_atom;
#634         count[0] = DIMSIZE2/2;
#635         count[1] = count_atom;
#644         count[0] = DIMSIZE2/2;
#645         count[1] = count_atom;
#650         count[0] = DIMSIZE2/2;
#651         count[1] = count_atom;
#656   data      = malloc(sizeof(int)*count[1]*count[0]);
#658   for (j=0; j<count[0];j++){
#659      for (i=0; i<count[1]; i++){
#666   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#679   rdata      = malloc(sizeof(int)*count[1]*count[0]);
#681   if (nc_get_vara_int(ncidrvidstartcountrdata)) ERR;
#684   for (j=0; j<count[0];j++){
#685      for (i=0; i<count[1]; i++){
#713    size_t count[2];
#740    count[0] = 1;
#741    count[1] = rank;
#742    if (nc_put_vara_int(ncFilencVarVrtxstartcountvertices)) ERR;
tst_parallel4.c#45    size_t count[NDIMS] = {1, DIMSIZEDIMSIZE};
#149       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
#194       if (nc_get_vara_int(ncidvaridstartcountdata_in)) ERR;
tst_pnetcdf.c#30    size_t start[2], count[2];
#81            start[0] = 0; count[0] = NX;
#82            if (nc_put_vara_int(ncidvarid[i], startcountbuf)) ERR;
#86            count[0] = 1; count[1] = NX;
#87            if (nc_put_vara_int(ncidvarid[i], startcountbuf)) ERR;
#108            start[0] = 0; count[0] = NX;
#116            count[0] = 1; count[1] = NX;
#117            if (nc_get_vara_int(ncidvarid[i], startcountbuf)) ERR;
tst_put_vars.c#27    size_t count[NDIMS] = {X_LENY_LENZ_LEN};
#60    if ((retval = nc_put_vars_float(ncidvaridstartcountstridemydata)))
tst_put_vars_two_unlim_dim.c#17    size_t count = 5;
#49    if ((ret = nc_put_vars_double(ncidvar1id, &start, &countNULL, &vals[0])))  {
#55    if ((ret = nc_put_vars_double(ncidvar2id, &start, &countNULL, &vals[0])))  {
tst_rename.c#204              size_t count[] = {4};
#205              if (nc_put_vara(ncidlon_varstartcountlon_data)) ERR;
#210              size_t count[] = {4};
#211              if (nc_put_vara(g1_grpg1_lon_varstartcountg1_lon_data)) ERR;
tst_simplerw_coll_r.c#54    size_t count[NDIMS] = {1, DIMSIZEDIMSIZE};
#157       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
#204count[j] = 0;
#209       if (nc_get_vara_int(ncidvaridstartcountdata_in)) ERR;
tst_small.c#147   size_t istart[NDIMS], count[NDIMS];
#165   count[0] = 1;
#166   count[1] = STR_LEN;
#172      if ((stat=nc_put_vara_text(ncidvaridstartcountdata[start[0]]))!=NC_NOERRERR2;
#195   size_t istart[NDIMS], count[NDIMS];
#213   count[0] = 1;
#214   count[1] = STR_LEN;
#217      if (nc_put_vara_text(ncidvaridstartcountdata[start[0]])) ERR;
#240   size_t start[NDIMS], count[NDIMS];
#249   count[0] = 1;
#254   if (nc_put_vara_text(ncidvaridstartcount, &data)) ERR;
#278   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#313  count[0] = 1;
#316  if (nc_put_vara_text(ncidvaridstartcount, &data[r])) ERR;
#343   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#363      count[0] = 1;
#368      if (nc_put_vara_text(ncidvaridstartcount, &data[r])) ERR;
#399   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#429      count[0] = 1;
#434  if (nc_put_vara_text(ncidvarid[v], startcount, &data[r])) ERR;
#463   size_t start[NDIMS], count[NDIMS];
#473   count[0] = 1;
#478   if (nc_put_vara_text(ncidvaridstartcount, &data)) ERR;
tst_special_atts.c#71    int count;
#88       NC_COMPOUND_OFFSET(struct obs_tcount), NC_INT)) ERR;
tst_strings.c#171      size_t start[NDIMS_PRES], count[NDIMS_PRES];
#184      count[0] = SOME_PRES;
#185      if (nc_put_vara_string(ncidvaridstartcount, (const char **)data)) ERR;
#210      size_t start[NDIMS_PRES], count[NDIMS_PRES];
#225      count[0] = SOME_PRES;
#227      status = nc_put_vars_string(ncidvaridstartcountstride, (const char **)data);
#234      if (nc_get_vars_string(ncidvaridstartcountstridedata_in)) ERR;
tst_unlim_vars.c#35   size_t start[NDIMS], count[NDIMS];
#120   count[0] = NUM_TIMESTEPS;
#121   count[1] = LAT_LEN;
#122   count[2] = LON_LEN;
#123   if (nc_put_vara_float(ncid, 0, startcount, (float *)data_out)) ERR;
#146   if (nc_get_vara_float(ncid, 0, startcount, (float *)data_in)) ERR;
tst_varms.c#36   size_t start[2], count[2];
#74      count[0] = count[1] = 2;
#78      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#88      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#132      count[0] = DIM1_LEN;
#133      count[1] = DIM2_LEN;
#137      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#161      size_t start[3] = {0, 0, 0}, count[3] = {D0D1D2};
#192      if (nc_get_varm_float(ncid, 0, startcountstrideimap,
#220      size_t start[2] = {0, 0}, count[2] = {6, 4};
#243      if (nc_put_varm_float(ncid, 0, startcountstrideimap,
#245      count[0] = 4;
#246      count[1] = 6;
#247      if (nc_put_vara_float(ncid, 1, startcount,
tst_vars.c#82   size_t start[NDIMS_EX], count[NDIMS_EX];
#172   count[0] = 1;
#173   count[1] = NLVL;
#174   count[2] = NLAT;
#175   count[3] = NLON;
#187      if (nc_put_vara_float(ncidpres_varidstartcount,
#189      if (nc_put_vara_float(ncidtemp_varidstartcount,
tst_vars2.c#89         size_t start[NUM_DIMS], count[NUM_DIMS];
#104         count[0] = 1;
#105         if (nc_put_vara_schar(ncidvaridstartcount, &data)) ERR;
#109         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
#115         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
#138         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
#144         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
tst_vars3.c#239      size_t start[1] = {0}, count[1] = {1};
#259      if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_vlen_data.c#138       size_t start[VAR5_RANK], count[VAR5_RANK];
#140       count[0] = NROWS;
#141       if (nc_get_vara(ncidvaridstartcountvals_in)) ERR;
util.c#104reclaimattptrs(void* buf, long count)
#108    for(i=0;i<count;i++) {free((void*)ptrs[i]);}
#122       reclaimattptrs(asym->att.data,asym->att.count);
#676    int icount;
#677    for(count=0,i=dimset->ndims-1;i>=0;i--) {
#679     count++;
#681    return count;
utils.c#305    size_t count = 0;
#317 count = 1;
#319 return count;
#327     count = 1;
#330     count = 0;
#334 return count;
#340 count++;
#352     count += nc_inq_grpname_count(ncids[g], igrplgrpsgrpids);
#357    return count;
#369 size_t count = nc_inq_grpname_count(ncidiglgrpsgrpids);
#370 if(count == 0) {
#374 total += count;
#474    size_t count = 0;
#485 count++;
#499 count += nc_inq_varname_count(ncids[g], varname);
#503    return count;
#731    size_t count;
#735    count = 0;
#739     grpids[count] = grpid;
#740 count++;
#744 *numgrps = count;
xxdr.c#88int xxdr_getbytes(XXDRxdrs, char* memoryoff_t count)
#91    if(!xdrs->getbytes(xdrs,memory,count))
#161xxdr_opaque(XXDRxdr, char* memoff_t count)
#164    if(!xdr->getbytes(xdr,mem,count))
#283    int count;
#298        count = fread(addr, (size_t)len, (size_t)1, (FILE*)xdrs->data);
#299        if(count <= 0) {


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