add.c#37    test->dims[test->ndims].size = idim->size;
#40    if (idim->size == NC_UNLIMITED)
#164    if (start[0] + edges[0] > test->dims[test->xdimid].size)
#165      test->dims[test->xdimid].size = start[0] + edges[0];
#205      (long)cdfp->dims[varp->dims[id]].size,
atttests.c#713     test.dims[id].size)) == -1) {
bindata.c#102bin_listbegin(GeneratorgeneratorSymboltsym, void* liststateListClass lc, size_t sizeBytebufferbuf, int* uidp, ...)
cdata.c#124c_listbegin(GeneratorgeneratorSymbolsym, void* liststateListClass lc, size_t sizeBytebuffercodebuf, int* uidp, ...)
cdftests.c#270    if ((ii_dim = ncdimdef(ncidii.nameii.size)) == -1) {
#360    if ((jj_dim = ncdimdef(ncidjj.namejj.size)) == -1 ||
#361 (kk_dim = ncdimdef(ncidkk.namekk.size)) == -1) {
#547 if ((dimids[id] = ncdimdef(nciddims[id].namedims[id].size))
#556    if ((rec_dim = ncdimdef(ncidrec.namerec.size)) == -1) {
#671    if ((ll_dim = ncdimdef(ncid0ll.namell.size)) == -1) {
dapdump.c#88                   &hdr->dims[i].size);
#91 i,hdr->dims[i].name,(unsigned long)hdr->dims[i].size);
#496  ncalign->size,ncalign->alignment,ncalign->offset);
dapdump.h#11    size_t size;
dapodom.c#43     const ptrdiff_tstride, const size_t* size)
#54 icount = (count != NULL ? count[i] : (size != NULL ? size[i] : 1));
#57 ideclsize = (size != NULL ? size[i]: (istop - istart));
#157 count *= odom->size[i];
dapodom.h#27 const ptrdiff_tstride, const size_t* size);
dapparse.c#138dap_arraydecl(DAPparsestatestateObject nameObject size)
#142    if(!check_int32(size,&value)) {
dapparselex.h#61extern Object dap_arraydecl(DAPparsestate*,Object nameObject size);
daputil.c#257    size_t size = 1;
#259    if(dimensions == NULL) return size;
#262 size *= dim->dim.declsize;
#264    return size;
dcompound.c#63nc_def_compound(int ncid, size_t size, const char *name,
#69   return ncp->dispatch->def_compound(ncid,size,name,typeidp);
dcopy.c#501         size_t size = NC_atomictypelen(xtype);
#503         assert(size > 0);
#504  if (!(data = malloc(len * size)))
#533      size_t size;
#545  if ((res = nc_inq_user_type(ncid_inxtypeNULL, &size,
#566     if (!(data = malloc(size * len)))
debug.c#31chkcalloc(size_t size, size_t nelems)
#33    return chkmalloc(size*nelems);
#37chkmalloc(size_t size)
#39    void* memory = calloc(size,1); /* use calloc to zero memory*/
#43    memset(memory,0,size);
#48chkrealloc(void* ptr, size_t size)
#50    void* memory = realloc(ptr,size);
dfile.c#138 if(meminfo == NULL || meminfo->size < MAGIC_NUMBER_LEN)
#760nc_open_mem(const char* path, int mode, size_t size, void* memory, int* ncidp)
#766    if(memory == NULL || size < MAGIC_NUMBER_LEN || path == NULL)
#771    meminfo.size = size;
#1578nc_inq_type(int ncidnc_type xtype, char *name, size_t *size)
#1592            if(size) *size = NC_atomictypelen(xtype);
#1597      return ncp->dispatch->inq_type(ncid,xtype,name,size);
dim.c#40 dimp->size = 0;
#51new_NC_dim(const char *uname, size_t size)
#71 dimp->size = size;
#80 return new_NC_dim(dimp->name->cpdimp->size);
#103  && (*loc)->size != NC_UNLIMITEDdimid++, loc++)
#318NC3_def_dim(int ncid, const char *name, size_t size, int *dimidp)
#339     if((sizeof(size_t) > 4) && (size > X_UINT64_MAX - 3)) /* "- 3" handles rounded-up size */
#342     if((sizeof(size_t) > 4) && (size > X_UINT_MAX - 3)) /* "- 3" handles rounded-up size */
#345     if(size > X_INT_MAX - 3)
#349 if(size == NC_UNLIMITED)
#366 dimp = new_NC_dim(namesize);
#430 if(dimp->size == NC_UNLIMITED)
#433 *sizep = dimp->size;
dimtests.c#53    if (ncdimdef(cdfidmm.namemm.size) != -1) {
#63    if ((dimid = ncdimdef(cdfidmm.namemm.size)) == -1) {
#76    if (ncdimdef(cdfidmm.namemm.size) != -1) {
#91 if (ncdimdef(cdfidrec.namerec.size) == -1) {
#98    if (ncdimdef(cdfid, "rec2", rec.size) != -1) {
#111    if (ncdimdef(cdfid, "rec2", rec.size) != -1) {
#154    if ((nn_dim = ncdimdef(cdfidnn.namenn.size)) == -1) {
#227 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#238 if (dim.size != test.dims[dimid].size) {
#240 pnamedim.sizetest.dims[dimid].sizedimid);
#250 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#261 if (dim.size != test.dims[dimid].size) {
#263 pnamedim.sizetest.dims[dimid].sizedimid);
#268    if (ncdiminq(cdfid, -1, dim.name, &dim.size) != -1 ||
#269 ncdiminq(cdfidtest.ndimsdim.name, &dim.size) != -1) {
#284 if (ncdiminq (cdfid, 0, dim.name, &dim.size) != -1) {
#333    if ((pp_dim = ncdimdef(cdfidpp.namepp.size)) == -1) {
#338    if (ncdimdef(cdfidqq.nameqq.size) == -1) {
#350    if (ncdiminq(cdfidpp_dimdim.name, &dim.size) == -1) {
dopaque.c#33nc_def_opaque(int ncid, size_t size, const char *namenc_type *xtypep)
#38    return ncp->dispatch->def_opaque(ncid,size,name,xtypep);
dtype.c#135nc_inq_user_type(int ncidnc_type xtype, char *name, size_t *size,
#141    return ncp->dispatch->inq_user_type(ncidxtypenamesize,
dumplib.c#673    size_t nbytes = this->size;
#692 size_t base_size = this->size;
#733 v1elem = (char *)v1elem + finfo->size;
#734 v2elem = (char *)v1elem + finfo->size;
#1017ncopaque_val_as_hex(size_t size, char *sout, const void *valp) {
#1026    for(i = 0; i < sizei++) {
#1033    return 2*size + prelen;
#1041    char* sout = (char *) emalloc(2 * typ->size + strlen("0X") + 1);
#1042    (void) ncopaque_val_as_hex(typ->sizesoutvalp);
#1053    size_t base_size = base_info->size;
#1177     vp = (char *)vp + finfo->size;
#1537 tp->size = sizes[i];
#1590   NC_CHECKnc_inq_user_type(ncidtypeids[t], type_name, &tinfo->size,
#1598       tinfo->size = sizeof(nc_vlen_t); /* not size of base type */
dumplib.h#77extern int ncopaque_val_as_hex ( size_t size, char *buf, const void *valp );
dv2i.c#61static void* nvmalloc(off_t size) {
#62  if(size < 0)
#65  return malloc(size);
#161    int size;
#179    size = nctypelen(type);
#185 size *= (int)len;
#187    *recsizep = (size_t)size;
dvar.c#547nc_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
#553    return ncp->dispatch->set_var_chunk_cache(ncidvaridsize,
emalloc.c#15emalloc (size) /* check return from malloc */
#16     size_t size;
#20    if (size > (unsigned long)32767) {
#21        error ("absurd arg to emalloc: %lu", (unsigned long) size);
#24    if (size == 0)
#26    p = (void *) malloc (size);
#35erealloc (ptrsize) /* check return from realloc */
#37     size_t size;
#41    if (size >  (unsigned long)32767) {
#42        error ("absurd arg to erealloc %lu", (unsigned long) size);
#45    p = (void *) realloc (ptrsize);
emalloc.h#24        size_t size
#29        size_t size
f77data.c#82f77_listbegin(GeneratorgeneratorSymbolsym, void* liststateListClass lc, size_t sizeBytebuffercodebuf, int* uidp, ...)
genbin.c#271      tsym->typ.size,
#314        tsym->typ.size,
#333      unsigned int size = efield->typ.dimset.dimsyms[j]->dim.declsize;
#334      dimsizes[j] = size;
genc.c#710 cname(tsym), tsym->typ.size);
#792 tsym->typ.size,
generate.c#536        normalizeopaquelength(&target,basetype->typ.size);
generr.c#160nprintf(char* buffer, size_t size, const char *fmt, ...)
#163nprintf(buffer,size,fmt)
#164    char* buffer; size_t size; const char* fmtva_dcl
#170    written = vsnprintf(buffer,size,fmt,args);
#171    if(written < 0 || written >= size) {
generr.h#31extern void nprintf(char* buffer, size_t size, const char *fmt, ...);
#41extern void nprintf(buffer,size,fmt)
#42 char* buffer; size_t size; const char* fmtva_dcl;
genlib.c#50 stat = nc_def_dim(nciddims[idim].namedims[idim].size, &dimid);
#247     if (dims[idim].size == NC_UNLIMITED) {
#253 (unsigned long) dims[idim].size);
#623     if (dims[idim].size == NC_UNLIMITED) {
#629 (unsigned long) dims[idim].size);
#752 if (dims[idim].size == NC_UNLIMITED)
#757                    dims[idim].name, (unsigned long) dims[idim].size,
#1415            if (used_in_rec_var(idim) && dims[idim].size != NC_UNLIMITED) {
#1419                        dims[idim].lname, (unsigned long) dims[idim].size);
#1508                        rec_len *= dims[v->dims[idim]].size;
#1661 size_t size)
#1665    p = (void *) malloc (size);
#1675 size_t size)
#1679    p = (void *) calloc (size, 1);
#1690     size_t size) /* if 0, this is really a free */
#1694    p = (void *) realloc (ptrsize);
#1696    if (p == 0 && size != 0) {
genlib.h#42extern void *emalloc ( size_t size );
#43extern void *ecalloc ( size_t size );
#44extern void *erealloc ( void *ptr, size_t size );
getfill.c#122    unsigned int size = dim->dim.declsize;
#123    int isunlimited = (size == 0);
#138     for(i=0;i<size;i++) filllist(basetype,sublist);
#140     for(i=0;i<size;i++) {
getvara.c#699        ASSERT((odom->size[i] != 0));
#701           || odom->count[i] != odom->size[i])
jdata.c#102j_listbegin(GeneratorgeneratorSymbolsym, void* liststateListClass lc, size_t sizeBytebuffercodebuf, int* uidp, ...)
load.c#540     count[0] = dims[vars[varnum].dims[0]].size;
#546 count[idim] = dims[vars[varnum].dims[idim]].size;
memio.c#82    off_t size;
#165    memio->size = minsize;
#320 filesize = meminfo->size;
#368        red = memio->size;
#416    if(filesizep != NULL) *filesizep = memio->size;
#462    memio->size = length;
#500     off_t written = memio->size;
#535    if(memio->size < endpoint)
#536 memio->size = endpoint;
mmapio.c#97    off_t size;
#166    mmapio->size = 0;
#228    mmapio->size = 0;
#359    mmapio->size = filesize;
#405    if(filesizep != NULL) *filesizep = mmapio->size;
#457    mmapio->size = length;
#503    if(mmapio->size < endpoint)
#504 mmapio->size = endpoint;
nc3dispatch.c#376NC3_inq_user_type(int ncidnc_type typeid, char *name, size_t *size,
#383NC3_def_compound(int ncid, size_t size, const char *namenc_type *typeidp)
#472NC3_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
nc3internal.c#1616NC3_inq_type(int ncidnc_type typeid, char *name, size_t *size)
#1648   if (size)
#1649      *size = NC_atomictypelen(typeid);
#1657NC3_set_content(int ncid, size_t size, void* memory)
#1670    status = memio_set_content(nc3->nciopsizememory);
nc3internal.h#72  unsigned long size;
#83 size_t size;
nc4attr.c#368      int size;
#405        size = sizeof(hvl_t);
#407        size = sizeof(char *);
#409        size = type_size;
#411      if (!(var->fill_value = calloc(1, size)))
#421          if (!(fv_vlen->p = malloc(size * in_vlen->len)))
#423          memcpy(fv_vlen->pin_vlen->pin_vlen->len * size);
nc4file.c#144nc_set_chunk_cache(size_t size, size_t nelems, float preemption)
#148   nc4_chunk_cache_size = size;
#172nc_set_chunk_cache_ints(int size, int nelems, int preemption)
#174   if (size <= 0 || nelems <= 0 || preemption < 0 || preemption > 100)
#176   nc4_chunk_cache_size = size;
#283   if(meminfo->size < MAGIC_NUMBER_LEN)
#971      (*type_info)->size = nc_type_size_g[t];
#1471               if ((retval = nc4_enum_member_add(&type->u.e.enum_membertype->size,
#1693            assert(var->type_info->size);
#1694     if (!(var->fill_value = malloc(var->type_info->size)))
#2315       if((nc4_info->hdfid = H5LTopen_file_image(meminfo->memory,meminfo->size,
#2496      type_info->size = nc_type_size_g[t];
#2645      var->type_info->size = var_type_size;
nc4hdf.c#232  size_t size;
#237    size = sizeof(nc_vlen_t);
#239    size = sizeof(char *);
#242      if ((retval = nc4_get_typelen_mem(h5var->type_info->nc_typeid, 0, &size)))
#245  assert(size);
#248  if (!((*fillp) = calloc(1, size)))
#261          if (!(fv_vlen->p = malloc(size * in_vlen->len)))
#267          memcpy(fv_vlen->pin_vlen->pin_vlen->len * size);
#280        memcpy((*fillp), var->fill_valuesize);
#681      assert(var->type_info->size);
#682      file_type_size = var->type_info->size;
#1003  assert(var->type_info->size);
#1004  file_type_size = var->type_info->size;
#1668                  type_size = var->type_info->size;
#1810  if (var->type_info->size)
#1811    chunk_size_bytes *= var->type_info->size;
#1850      if ((type->hdf_typeid = H5Tcreate(H5T_COMPOUNDtype->size)) < 0)
#1904      if ((type->hdf_typeid = H5Tcreate(H5T_OPAQUEtype->size)) < 0)
#3850  *len = type->size;
#3852  LOG((5, "type->size: %d", type->size));
#4067    size_t size;
nc4info.c#101    size_t size;
#122        size = H5Tget_size(atype);
#123 if(size == 0) goto done;
#124 text = (char*)malloc(size+1);
#130 text[size] = '\0';
#149    size_t size;
nc4internal.c#802nc4_type_list_add(NC_GRP_INFO_T *grp, size_t size, const char *name,
#816   new_type->size = size;
#880nc4_enum_member_add(NC_ENUM_MEMBER_INFO_T **list, size_t size,
#886   assert(name && size > 0 && value);
#887   LOG((4, "%s: size %d name %s", __func__sizename));
#892   if (!(member->value = malloc(size))) {
#903   memcpy(member->valuevaluesize);
#1508    type->hdf_typeidtype->size, (int)type->committedtype->name,
nc4internal.h#231   size_t size;                 /* Size of the type in memory, in bytes */
#393int nc4_type_list_add(NC_GRP_INFO_T *grp, size_t size, const char *name,
#403int nc4_enum_member_add(NC_ENUM_MEMBER_INFO_T **list, size_t size,
nc4type.c#186add_user_type(int ncid, size_t size, const char *namenc_type base_typeid,
#200 __FUNCTION__ncidsizenorm_namebase_typeid));
#219 &size)))
#222   else if (size <= 0)
#230   if ((retval = nc4_type_list_add(grpsizenorm_name, &type)))
#262NC4_inq_type(int ncidnc_type typeid1, char *name, size_t *size)
#280      if (size)
#281 *size = atomic_size[typeid1];
#296   if (size)
#299  *size = sizeof(nc_vlen_t);
#301  *size = 1;
#303  *size = type->size;
#311NC4_def_compound(int ncid, size_t size, const char *namenc_type *typeidp)
#313   return add_user_type(ncidsizename, 0, NC_COMPOUNDtypeidp);
#373NC4_inq_user_type(int ncidnc_type typeid1, char *name, size_t *size,
#402   if (size)
#405  *size = sizeof(nc_vlen_t);
#407  *size = 1;
#409  *size = type->size;
#676      memcpy(valueenum_member->valuetype->size);
#717   if ((retval = nc4_enum_member_add(&type->u.e.enum_membertype->size,
nc4var.c#72NC4_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
#104   var->chunk_cache_size = size;
#117nc_set_var_chunk_cache_ints(int ncid, int varid, int size, int nelems,
#124   if (size >= 0)
#125       real_size = ((size_t) size) * MEGABYTE;
#245      type_size = var->type_info->size;
#445 &type_info->size)))
#753             assert(var->type_info->size);
#754             memcpy(fill_valuepvar->fill_valuevar->type_info->size);
nc_hashmap.c#62  unsigned long size = hm->size;
#67  hm->size = findPrimeGreaterThan(size<<1);
#68  hm->table = (hEntry*)calloc(sizeof(hEntry), hm->size);
#71  while(size > 0) {
#72    --size;
#73    if (table[size].flags == ACTIVE) {
#74      NC_dim *elem = ncap->value[table[size].data-1];
#75      NC_hashmapAddDim(ncaptable[size].data-1, elem->name->cp);
#76      assert(NC_hashmapGetDim(ncapelem->name->cp) == table[size].data-1);
#87  unsigned long size = hm->size;
#92  hm->size = findPrimeGreaterThan(size<<1);
#93  hm->table = (hEntry*)calloc(sizeof(hEntry), (size_t)hm->size);
#96  while(size > 0) {
#97    --size;
#98    if (table[size].flags == ACTIVE) {
#99      NC_var *elem = ncap->value[table[size].data-1];
#100      NC_hashmapAddVar(ncaptable[size].data-1, elem->name->cp);
#101      assert(NC_hashmapGetVar(ncapelem->name->cp) == table[size].data-1);
#122  hm->size = startsize;
#133  if (hash->size*3/4 <= hash->count) {
#140    unsigned long index = key % hash->size;
#141    unsigned long step = (key % MAX(1,(hash->size-2))) + 1;
#143    for (i = 0; i < hash->sizei++)
#165      index = (index + step) % hash->size;
#180  if (hash->size*3/4 <= hash->count) {
#187    unsigned long index = key % hash->size;
#188    unsigned long step = (key % MAX(1,(hash->size-2))) + 1;
#190    for (i = 0; i < hash->sizei++)
#212      index = (index + step) % hash->size;
#228  unsigned long index = key % hash->size;
#229  unsigned long step = (key % (hash->size-2)) + 1;
#231  for (i = 0; i < hash->sizei++)
#253    index = (index + step) % hash->size;
#265  unsigned long index = key % hash->size;
#266  unsigned long step = (key % (hash->size-2)) + 1;
#268  for (i = 0; i < hash->sizei++)
#290    index = (index + step) % hash->size;
#305    unsigned long index = key % hash->size;
#306    unsigned long step = (key % (hash->size-2)) + 1;
#308    for (i = 0; i < hash->sizei++)
#323      index = (index + step) % hash->size;
#339    unsigned long index = key % hash->size;
#340    unsigned long step = (key % (hash->size-2)) + 1;
#342    for (i = 0; i < hash->sizei++)
#357      index = (index + step) % hash->size;
ncaux.c#33    size_t size;
#44    size_t size;
#163    status = nc_def_compound(cmpd->ncidcmpd->sizecmpd->nameidp);
#359 status = nc_inq_type(cmpd->ncid,field->fieldtype,NULL,&field->size);
#362 field->size *= totaldimsize;
#388        offset += field->size;
#390    cmpd->size = offset;
nccommon.h#235    unsigned long    size; /* size of single instance of this type*/
nccomps.h#11    size_t size;
#50    size_t size;            /* like sizeof, even for user-defined types */
nccopy.c#255    size_t size;
#260    NC_CHECK(nc_inq_vlen(igrpitypename, &size, &ibasetype));
#287    size_t size;
#289    NC_CHECK(nc_inq_opaque(igrpitypename, &size));
#290    NC_CHECK(nc_def_opaque(ogrpsizename, &otype));
#328    size_t size;
#333    NC_CHECK(nc_inq_compound(igrpitypename, &size, &nfields));
#334    NC_CHECK(nc_def_compound(ogrpsizename, &otype));
ncd2dispatch.c#1961     unsigned long size = cdftotalsize(ncdims);
#1962     size *= nctypesizeof(var->etype);
#1965 makecdfpathstring(var,"."),rank,size);
#1967     var->estimatedsize = size;
ncdispatch.h#106    size_t size;
ncdump.c#329    off_t size = 0;
#350    size = lseek(fd,0,SEEK_END);
#351    if(size < 0) {status = errno; goto done;}
#354    mem = malloc(size);
#359    red = size;
#383      if(sizep) *sizep = size;
#806 att.valgp = (void *) emalloc((att.len + 1) * att.tinfo->size );
#1034    if(varp->tinfo->size > 1) /* Endianness is meaningless for 1-byte types */
#1425    fillvalp = emalloc(vp->tinfo->size + 1);
#1606      stat = nc_inq_dim(nciddimiddims[d_grp].name, &dims[d_grp].size);
#1619       (unsigned long)dims[d_grp].size);
#1621       printf ("%lu ;\n", (unsigned long)dims[d_grp].size);
#1626       (unsigned int)dims[d_grp].size);
#1628       printf ("%u ;\n", (unsigned int)dims[d_grp].size);
#1638      NC_CHECKnc_inq_dim(nciddimiddims[dimid].name, &dims[dimid].size) );
#1645   (unsigned int)dims[dimid].size);
#1647   printf ("%llu ;\n", (unsigned long long)dims[dimid].size);
#1944 NC_CHECKnc_inq_dim(nciddimiddims[dimid].name, &dims[dimid].size) );
#1947  dims[dimid].name, (int)dims[dimid].size);
#1950   dims[dimid].name, (int)dims[dimid].size);
#1981 (isrecvar(ncid,varid) && dims[xdimid].size == 0)
#2286 size_t size = 0;
#2288 nc_status = fileopen(path,&mem,&size);
#2290             nc_status = nc_open_mem(path,NC_DISKLESS|NC_INMEMORY,size,mem,&ncid);
ncgen.h#166        size_t   size;     /* for opaque, compound, etc.*/
ncgen.h#29    size_t size;
ncgenl.c#308YY_BUFFER_STATE ncg_create_buffer (FILE *file,int size  );
#320YY_BUFFER_STATE ncg_scan_buffer (char *base,yy_size_t size  );
#2630    YY_BUFFER_STATE ncg_create_buffer  (FILE * file, int  size )
#2638 b->yy_buf_size = size;
#2836YY_BUFFER_STATE ncg_scan_buffer  (char * baseyy_size_t  size )
#2840 if ( size < 2 ||
#2841      base[size-2] != YY_END_OF_BUFFER_CHAR ||
#2842      base[size-1] != YY_END_OF_BUFFER_CHAR )
#2850 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
#3096void *ncgalloc (yy_size_t  size )
#3098 return (void *) malloc( size );
#3101void *ncgrealloc  (void * ptryy_size_t  size )
#3110 return (void *) realloc( (char *) ptrsize );
ncgentab.c#1591      dims[ndims].size = int_val;
#1606        dims[ndims].size = (size_t) double_val;
#1617      dims[ndims].size = NC_UNLIMITED;
#1917    var_len = dims[vars[varnum].dims[0]].size;
#1920  var_len = var_len*dims[vars[varnum].dims[dimnum]].size;
#2097        sl = dims[vars[varnum].dims[ld]].size;
ncgeny.c#334unsigned long  size; /* allow for zero size to indicate e.g. UNLIMITED*/
#1894                (yyvsp[(3) - (6)].sym)->typ.size = (yyvsp[(1) - (6)].sym)->typ.size;
#1957                    (yyvsp[(5) - (5)].sym)->typ.size=int32_val;
#1972                    (yyvsp[(5) - (5)].sym)->typ.size=VLENSIZE;
#3016    sym->typ.size = ncsize(nctype);
ncgeny.h#156unsigned long  size; /* allow for zero size to indicate e.g. UNLIMITED*/
ncgenyy.c#307YY_BUFFER_STATE ncg_create_buffer (FILE *file,int size  );
#319YY_BUFFER_STATE ncg_scan_buffer (char *base,yy_size_t size  );
#1980    YY_BUFFER_STATE ncg_create_buffer  (FILE * file, int  size )
#1988 b->yy_buf_size = size;
#2186YY_BUFFER_STATE ncg_scan_buffer  (char * baseyy_size_t  size )
#2190 if ( size < 2 ||
#2191      base[size-2] != YY_END_OF_BUFFER_CHAR ||
#2192      base[size-1] != YY_END_OF_BUFFER_CHAR )
#2200 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
#2447void *ncgalloc (yy_size_t  size )
#2449 return (void *) malloc( size );
#2452void *ncgrealloc  (void * ptryy_size_t  size )
#2461 return (void *) realloc( (char *) ptrsize );
nchashmap.c#78    hm->size++;
#102    hm->size++;
#125     hm->size--;
#191    if(hm->size == 0) {
#194        keys = (nchashid*)malloc(sizeof(nchashid)*hm->size);
nchashmap.h#24  size_t size; /* # of pairs still in table*/
#56#define nchashsize(hm) ((hm)?(hm)->size:0)
ncpdispatch.c#308NCP_inq_type(int ncidnc_type typeid, char* name, size_t* size)
#315    if(size)
#316        *size = NC_atomictypelen(typeid);
#1356NCP_inq_user_type(int ncidnc_type typeid, char *name, size_t *size,
#1363NCP_def_compound(int ncid, size_t size, const char *namenc_type *typeidp)
#1452NCP_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
ncstdio.c#55ncstdio_read(ncstdioiop, void* memory, const size_t size, size_t* actual)
#58    return iop->ops.read(iop,memory,size,actual);
#62ncstdio_write(ncstdioiop, const void* memory, const size_t size, size_t* actual)
#65    return iop->ops.write(iop,memory,size,actual);
nctime0.c#330     valp += att->tinfo->size; /* increment value pointer, by type */
netcdf.h#589nc_def_compound(int ncid, size_t size, const char *namenc_type *typeidp);
#604nc_inq_type(int ncidnc_type xtype, char *name, size_t *size);
#714nc_inq_user_type(int ncidnc_type xtype, char *name, size_t *size,
#761nc_def_opaque(int ncid, size_t size, const char *namenc_type *xtypep);
#881nc_set_chunk_cache(size_t size, size_t nelems, float preemption);
#889nc_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
netcdf_f.h#30nc_set_chunk_cache_ints(int size, int nelems, int preemption);
#36nc_set_var_chunk_cache_ints(int ncid, int varid, int size, int nelems,
netcdf_mem.h#33EXTERNL int nc_open_mem(const char* path, int mode, size_t size, void* memory, int* ncidp);
ocdebug.c#35occalloc(size_t size, size_t nelems)
#37    return ocmalloc(size*nelems);
#41ocmalloc(size_t size)
#43    void* memory = calloc(size,1); /* use calloc to zero memory*/
ocdebug.h#77extern void* occalloc(size_t size, size_t nelems);
#78extern void* ocmalloc(size_t size);
ochttp.c#19 size_t size;
#66 fetchdata.size = 0;
#75     oclog(OCLOGNOTE,"filesize: %lu bytes",fetchdata.size);
#78 *sizep = fetchdata.size;
#177WriteFileCallback(void* ptr, size_t size, size_t nmemb, void* data)
#179 size_t realsize = size * nmemb;
#185 count = fwrite(ptrsizenmembfetchdata->stream);
#187 fetchdata->size += (count * size);
#198WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
#200 size_t realsize = size * nmemb;
ocutil.c#596occopycat(char* dst, size_t size, size_t n, ...)
#599    size_t avail = size - 1;
#605 if(size > 0)
#607 return (size > 0 ? 1: 0);
#642occoncat(char* dst, size_t size, size_t n, ...)
#651    if(dstused >= size)
#657    size -= dstused;
#658    avail = size - 1;
#660 if(size > 0)
#662 return (size > 0 ? 1: 0);
ocutil.h#15extern int occopycat(char* dst, size_t size, size_t n, ...);
#16extern int occoncat(char* dst, size_t size, size_t n, ...);
rec.c#64    long size;
#72    size = nctypelen(type);
#76 size *= len;
#78    return size;
semantics.c#609     tsym->typ.size = ncsize(tsym->typ.typecode);
#614     tsym->typ.size = ncsize(tsym->typ.typecode);
#624     tsym->typ.size = tsym->typ.basetype->typ.size;
#648              offset += field->typ.size;
#655     tsym->typ.size = offset;
#661         tsym->typ.size = tsym->typ.basetype->typ.size * totaldimsize;
#665         tsym->typ.size = tsym->typ.basetype->typ.size;
slabs.c#148 dimids[idim] = ncdimdef(cdfiddims[idim].namedims[idim].size);
#202     edge[idim] = dims[idim].size;
#219     corner[idim] = dims[idim].size/2;
#236 corner[jdim] = dims[jdim].size/2;
#241     edge[idim] = dims[idim].size - 2;
#260     corner[kdim] = dims[kdim].size/2;
#266 edge[idim] = dims[idim].size - 2;
#267 edge[jdim] = dims[jdim].size - 2;
#297 corner[ldim] = dims[ldim].size/2;
#304     edge[idim] = dims[idim].size - 2;
#305     edge[jdim] = dims[jdim].size - 2;
#306     edge[kdim] = dims[kdim].size - 2;
t_nc.c#125 size_t size;
#129 assert( nc_inq_dim(cdfidiicp, &size) == NC_NOERR);
#130 if( size != *sizes)
#132 ii, (unsigned long)size, (unsigned long)*sizes);
#133 assert( size == *sizes);
testcdf.h#21    long size;
testnc3perf.c#43    long size;
#231 dims[idim].size = sizes[idim];
#243 dimids[idim] = ncdimdef(nciddims[idim].namedims[idim].size);
#297     edge[idim] = dims[idim].size;
#318     corner[idim] = dims[idim].size/2;
#343     edge[idim] = dims[idim].size;
#371 edge[idim] = dims[idim].size;
#372 edge[jdim] = dims[jdim].size;
#409     edge[idim] = dims[idim].size;
#410     edge[jdim] = dims[jdim].size;
#411     edge[kdim] = dims[kdim].size;
#446     edge[idim] = dims[idim].size;
tst_camrun.c#673   unsigned size; /*       total program size */
#686      fscanf(pf, "%u %u %u %u %u %u", &size, &resident, &share,
tst_compounds.c#34      size_t size;
#53      if (nc_inq_compound(ncidtypeidname, &size, &nfields)) ERR;
#54      if (size != sizeof(struct s1) || strcmp(nameSVC_REC) || nfieldsERR;
#74      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#75      if (nfields != 2 || size != sizeof(struct s1) || strcmp(nameSVC_REC)) ERR;
#78      if (nc_inq_compound_size(ncidxtype, &size)) ERR;
#79      if (size != sizeof(struct s1)) ERR;
#107      size_t size;
#138      if (nc_inq_compound(ncidtypeidname, &size, &nfields)) ERR;
#139      if (size != sizeof(struct s1) || strcmp(nameSVC_REC) || nfieldsERR;
#160      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#161      if (nfields != 2 || size != sizeof(struct s1) || strcmp(nameSVC_REC)) ERR;
#164      if (nc_inq_compound_size(ncidxtype, &size)) ERR;
#165      if (size != sizeof(struct s1)) ERR;
#245      size_t sizelen;
#297      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#298      if (nfields != 2 || size != 8 || strcmp(nameSVC_REC)) ERR;
#321      size_t size;
#381  if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#382  if (nfields != 5 || size != sizeof(struct sf_med_rec) || strcmp(name, "SFMedRec")) ERR;
#418      size_t size;
#475      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#476      if (nfields != 2 || size != sizeof(struct dim_rec) || strcmp(name, "SFDimRec")) ERR;
#497      size_t sizelen;
#597      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#598      if (nfields != 6 || size != sizeof(struct hr_rec) || strcmp(name, "SF_HR_Record")) ERR;
tst_compounds3.c#43      size_t size;
#78      if (nc_inq_compound(ncidtypeidname_in, &size, &nfields)) ERR;
#79      if (size != sizeof(struct s1_packed) || strcmp(name_inS1_PACKED_NAME) || nfieldsERR;
#97      if (nc_inq_compound(ncidxtypename_in, &size, &nfields)) ERR;
#98      if (nfields != 2 || size != sizeof(struct s1) || strcmp(name_inS1_PACKED_NAME)) ERR;
tst_files2.c#61      unsigned size; /*       total program size */
#68      fscanf(pf, "%u %u %u %u %u %u", &size, &resident, &share,
tst_files3.c#174      unsigned size; /*       total program size */
#181      fscanf(pf, "%u %u %u %u %u %u", &size, &resident, &share,
tst_grps.c#1087      size_t size;
#1112      if (nc_inq_compound(ncidtypeidname, &size, &nfields)) ERR;
#1113      if (size != sizeof(struct s1) || strcmp(nameCMP1_NAME) || nfieldsERR;
#1134      if (nc_inq_compound(ncidtypeid2name, &size, &nfields)) ERR;
#1135      if (size != sizeof(struct s2) || strcmp(nameCMP2_NAME) || nfieldsERR;
tst_h_atts.c#45   hssize_t size;
#201      if ((size = H5Sget_simple_extent_npoints(spaceid)) < 0) ERR;
#202      if (size != 1) ERR;
#252      if ((size = H5Sget_simple_extent_npoints(spaceid)) < 0) ERR;
#253      if (size != 0) ERR;
#277      if ((size = H5Sget_simple_extent_npoints(spaceid)) < 0) ERR;
#278      if (size != 0) ERR;
tst_h_enums.c#59      size_t size;
#110      size = H5Tget_size(typeid);
#111      if (size != 2) ERR;
#158      size_t size;
#224      size = H5Tget_size(typeid);
#225      if (size != sizeof(short)) ERR;
tst_h_files3.c#34      unsigned size; /*       total program size */
#41      fscanf(pf, "%u %u %u %u %u %u", &size, &resident, &share,
tst_h_files4.c#174      ssize_t size;
#191  if ((size = H5Lget_name_by_idx(grpid, ".", idx_fieldH5_ITER_INCi,
#194 obj_namesize+1, H5P_DEFAULT) < 0) ERR;
tst_h_vars2.c#37      ssize_t size;
#85  if ((size = H5Lget_name_by_idx(grpid, ".", H5_INDEX_CRT_ORDERH5_ITER_INCi,
#88 namesize+1, H5P_DEFAULT);
#115      ssize_t size;
#158  if ((size = H5Lget_name_by_idx(grpid, ".", H5_INDEX_CRT_ORDERH5_ITER_INCi,
#161 namesize+1, H5P_DEFAULT) < 0) ERR;
#183      ssize_t size;
#244      if ((size = H5Lget_name_by_idx(grpid, ".", H5_INDEX_CRT_ORDERH5_ITER_INC, 0,
#247                         namesize+1, H5P_DEFAULT);
tst_h_vl.c#27      size_t size;
#49      if (!(size = H5Tget_size(typeid))) ERR;
#50      if (size < 8) ERR;
tst_mem.c#35      unsigned size; /*       total program size */
#42      fscanf(pf, "%u %u %u %u %u %u", &size, &resident, &share,
utils.c#37 size_t size)
#41    p = (void *) malloc (size==0 ? 1 : size); /* malloc(0) not portable */
utils.h#68extern void*    emalloc ( size_t size );
v1hpg.c#415 status = v1h_put_size_t(psp, &dimp->size);
#441 status = v1h_get_size_t(gsp, &dimp->size);
var.c#449 *op = dimp->size;
vardata.c#229 valp += ap->tinfo->size; /* next value according to type */
#481 valp += vp->tinfo->size; /* next value according to type */
#580    vals = emalloc(ncols * vp->tinfo->size);
#697 valp += vp->tinfo->size; /* next value according to type */
#755    vals = emalloc(ncols * vp->tinfo->size);
vardef.c#155 if ((di_id[id] = ncdimdef(cdfiddi[id].namedi[id].size)) == -1) {
#157   pnamedi[id].namedi[id].size);
varget.c#88 hc.cor[mqv] = test.dims[dim].size; /* try big coordinate, should fail */
#95 hc.edg[mqv] = test.dims[dim].size + 1; /* try big edge, should fail */
vargetg.c#89 hc.cor[id] = test.dims[id].size; /* try big coordinate, should fail */
#96 hc.edg[id] = test.dims[id].size + 1; /* try big edge, should fail */
varput.c#92 hc.cor[mqv] = test.dims[dim].size; /* try big coordinate, should fail */
#100 hc.edg[mqv] = test.dims[dim].size + 1; /* try big edge, should fail */
varputg.c#92 hc.cor[id] = test.dims[id].size; /* try big coordinate, should fail */
#99 hc.edg[id] = test.dims[id].size + 1; /* try big edge, should fail */
vartests.c#275     dsize = (int) test.dims[test.vars[iv].dims[id]].size;
#417   test.dims[test.vars[iv].dims[test.vars[iv].ndims/2]].size;
#505   test.dims[test.vars[iv].dims[test.vars[iv].ndims/2]].size;
vputget.c#58     int dsize = (int)test.dims[test.vars[iv].dims[id]].size;
vputgetg.c#65     (test.dims[test.vars[varid].dims[id]].size == NC_UNLIMITED \
#67test.dims[test.vars[varid].dims[id]].size)


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