ConvertUTF.c#295static Boolean isLegalUTF8(const UTF8 *source, int length) {
#297    const UTF8 *srcptr = source+length;
#298    switch (length) {
#327    int length = trailingBytesForUTF8[*source]+1;
#328    if (source+length > sourceEnd) {
#331    return isLegalUTF8(sourcelength);
bytebuffer.c#41  bb->length=0;
#57  if(bb->alloc > 0 && bb->length > 0 && bb->content != NULL) {
#58    memcpy((void*)newcontent,(void*)bb->content,sizeof(char)*bb->length);
#78  if(bb->length < sz) {
#81  bb->length = sz;
#90  for(i=0;i<bb->length;i++) bb->content[i] = fill;
#98  if(index >= bb->length) return -1;
#106  if(index >= bb->length) return bbFail();
#116  while(bb->length+1 >= bb->alloc) {
#120  bb->content[bb->length] = elem;
#121  bb->length++;
#122  bb->content[bb->length] = '\0';
#132    if(bb->length == 0) return bbFail();
#133    bb->length--;
#153  memcpy((void*)&bb->content[bb->length],(void*)elem,n);
#154  bb->length += n;
#155  bb->content[bb->length] = '\0';
#176  newlen = bb->length + n;
#195  for(j=newlen-1,i=index;i<bb->length;i++) {
#199  bb->length += n;
#213  if(bb->length == 0) return bbFail();
#217          sizeof(char)*(bb->length - 1));
#218  bb->length--;
#226  if(bb->length == 0) return bbFail();
#227  *pelem = bb->content[bb->length-1];
#228  bb->length--;
#236  if(bb->length == 0) return bbFail();
#245  if(bb->length == 0) return bbFail();
#246  *pelem = bb->content[bb->length - 1];
#253    char* result = (char*)emalloc(bb->length+1);
#254    memcpy((void*)result,(const void*)bb->content,bb->length);
#255    result[bb->length] = '\0'; /* just in case it is a string*/
#266    bb->length = 0;
#277    bb->length--;
bytebuffer.h#10  unsigned int length;
#48#define bbLength(bb) ((bb)?(bb)->length:0U)
#52#define bbClear(bb) ((void)((bb)?(bb)->length=0:0U))
#53#define bbNeed(bb,n) ((bb)?((bb)->alloc - (bb)->length) > (n):0U)
#54#define bbAvail(bb) ((bb)?((bb)->alloc - (bb)->length):0U)
constraints.c#420     slice->length = count * slice->stride;
#421     slice->last = (slice->first + slice->length) - 1;
#425 slice->length = (slice->last - slice->first) + 1;
#451 if(slice->length != dim->dim.declsize) return 0;
#809    slice->length = slice->count;
#810    slice->last = slice->length - 1;
dapodom.c#88 (size_t)odom->length[i]);
data.c#90    src->length = 0;
#103    src->length = list->length;
#116    src->length = 1;
#149    if(ds->index < ds->length)
#167    if(ds->index < ds->length)
#180    if(ds->index < ds->length) return 1;
#189    int len = ds->length;
#216    src->length = dl->length;
#241    if(ds->index >= ds->lengthPANIC("srcsetfill: no space");
#299    Datalistclone = builddatalist(dl->length);
#300    for(i=0;i<dl->length;i++) {
#312    vector = (NCConstant*)erealloc(dl1->data,sizeof(NCConstant)*(dl1->length+dl2->length));
#314    memcpy((void*)(vector+dl1->length),dl2->data,sizeof(NCConstant)*(dl2->length));
#325    vector = (NCConstant*)erealloc(dl->data,sizeof(NCConstant)*(dl->length+1));
#327    vector[dl->length] = *con;
#328    dl->length++;
#337    ASSERT(index < dl->length);
#346    if(ds == NULL || ds->length == 0) return 0;
#722    ci->length = 0;
#729    if(dl->length >= dl->allocdlextend(dl);
#731    dl->data[dl->length++] = *constant;
#740  d.lineno = (dl->length > 0?dl->data[0].lineno:0);
data.h#61    size_t  length; /* |data| */
#80    int length;
#102#define   datalistith(dl,i) ((dl)==NULL?NULL:((i) >= (dl)->length?NULL:&(dl)->data[i]))
#103#define   datalistlen(dl) ((dl)==NULL?0:(dl)->length)
#126#define srclen(s) ((s)==NULL?0:(s)->length)
dceconstraints.c#75    size_t last = (s->first+s->length)-1;
#77 prefix,s->first,s->stride,last,s->stop,s->length,s->count);
#211    sr.length    = (sr.last + 1) - sr.first;
#214    sr.count = (sr.length + (sr.stride - 1))/sr.stride;
#614     size_t last = (slice->first+slice->length)-1;
#914       || slice->length != slice->declsize) return 0;
#936    slice->length = declsize;
#939    slice->last = slice->length - 1;
#1064     (unsigned long)slice->length,
dceconstraints.h#25    size_t length;
dceparse.c#148    slice->length  = (slice->last - slice->first) + 1;
#149    slice->count  = slice->length / slice->stride;
#210    slice->length = 1;
dump.c#58    count = list->length;
#266    count = src->length;
#272        fprintf(stderr,"[%d/%d]",src->index,src->length);
#282        if(count < src->length) fprintf(stderr,"...");
dutf8proc.c#119  int length;
#124  length = utf8proc_utf8class[str[0]];
#125  if (!length) return UTF8PROC_ERROR_INVALIDUTF8;
#126  if (slen >= 0 && length > slen) return UTF8PROC_ERROR_INVALIDUTF8;
#127  for (i=1; i<lengthi++) {
#130  switch (length) {
#153  return length;
#413ssize_t utf8proc_reencode(int32_t *bufferssize_t length, int options) {
#420    for (rpos = 0; rpos < lengthrpos++) {
#422      if (uc == 0x000D && rpos < length-1 && buffer[rpos+1] == 0x000A) rpos++;
#445    length = wpos;
#455    for (rpos = 0; rpos < lengthrpos++) {
#514    length = wpos;
#519    for (rpos = 0; rpos < lengthrpos++) {
dv2i.c#532    long length
#537 if(length < 0) {
#542 status =  nc_def_dim(ncidname, (size_t)length, &dimid);
#571    long* length
#584 if(length != NULL)
#585 *length = (int) ll;
dvarget.c#333      size_t *length; /* edge lengths in bytes */
#374      length = stop + varndims;
#375      mystride = (ptrdiff_t *)(length + varndims);
#429  length[idim] = ((size_t)mymap[idim]) * myedges[idim];
#469  mymap[maxidim] = (ptrdiff_tlength[maxidim];
#496     size_t l = (length[idim] * (size_t)memtypelen);
dvarput.c#341      size_t *length = 0; /* edge lengths in bytes */
#382      length = stop + varndims;
#383      mystride = (ptrdiff_t *)(length + varndims);
#416  length[idim] = ((size_t)mymap[idim]) * myedges[idim];
#449  mymap[maxidim] = (ptrdiff_tlength[maxidim];
#477     size_t l = (length[idim] * (size_t)memtypelen);
ffio.c#42static int ncio_ffio_pad_length(ncio *nciopoff_t length);
#824ncio_ffio_pad_length(ncio *nciopoff_t length)
#838 status = fgrow2(nciop->fdlength);
genbin.c#288 ecdl->length = 1;
#444    len = list->length;
genc.c#1003        size_t length = 0;
#1005     length = bbLength(code);
#1010 (unsigned long)length);
#1017     length = 1;
#1018         for(i=0;i<rank;i++) length *= count[i];
#1025 (unsigned long)length);
#1075    size_t len = asym->data->length; /* default assumption */
#1107                        asym->data->length
genchar.c#95    for(i=0;i<data->length;i++) {
#142    for(i=0;i<data->length;i++) {
#189    if(fillsrc != NULL && fillsrc->length > 0) {
#307    for(i=0;i<data->length;i++) {
generate.c#66        generator->listbegin(generator,asym,NULL,LISTATTR,asym->data->length,codebuf,&uid);
#67        for(count=0;count<asym->data->length;count++) {
#173                generator->listbegin(generator,vsym,NULL,LISTDATA,vsym->data->length,code,&uid);
#245            generator->listbegin(generator,vsym,NULL,LISTDATA,list->length,code,&uid);
#311            ASSERT(fill->length == 1);
#354            ASSERT(fill->length == 1);
#371            generator->listbegin(generator,tsym,NULL,LISTVLEN,data->length,codebuf,&uid);
#372            for(count=0;count<data->length;count++) {
#472        ASSERT(fill->length == 1);
genf77.c#178 int count = gasym->data->length;
#188 int count = asym->data->length;
#857    size_t len = asym->data==NULL?0:asym->data->length;
genj.c#523    size_t len = asym->data == NULL?0:asym->data->length;
getvara.c#913    for(i=slice->first;i<slice->length;i+=slice->stride) {
list.c#33    l->length=0;
#55  if(sz <= 0) {sz = (l->length?2*l->length:DEFAULTALLOC);}
#58  if(newcontent != NULL && l->alloc > 0 && l->length > 0 && l->content != NULL) {
#59    memcpy((void*)newcontent,(void*)l->content,sizeof(void*)*l->length);
#72  l->length = sz;
#79  if(l == NULL || l->length == 0) return NULL;
#80  if(index >= l->length) return NULL;
#88  if(index >= l->length) return FALSE;
#99  if(index > l->length) return FALSE;
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#103  l->length++;
#111  if(l->length >= l->alloclistsetalloc(l,0);
#112  l->content[l->length] = elem;
#113  l->length++;
#120  if(l == NULL || l->length == 0) return NULL;
#121  l->length--;
#122  return l->content[l->length];
#128  if(l == NULL || l->length == 0) return NULL;
#129  return l->content[l->length - 1];
#137  if(l == NULL || (len=l->length) == 0) return NULL;
#141  l->length--;
#149    void** result = (void**)malloc(sizeof(void*)*(l->length+1));
#150    memcpy((void*)result,(void*)l->content,sizeof(void*)*l->length);
#151    result[l->length] = (void*)0;
#172  if(l == NULL || (len=l->length) == 0) return 0;
#177      l->length--;
#198    if(l == NULL || l->length == 0) return 1;
#199    len = l->length;
#210    l->length = len;
list.h#18  unsigned long length;
#60#define listlength(l)  ((l)==NULL?0:(int)(l)->length)
lookup3.c#185size_t          length,               /* the length of the key, in uint32_ts */
#191  a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
#194  while (length > 3)
#200    length -= 3;
#205  switch(length)                     /* all the case statements fall through */
#229size_t          length,               /* the length of the key, in uint32_ts */
#236  a = b = c = 0xdeadbeef + ((uint32_t)(length<<2)) + *pc;
#240  while (length > 3)
#246    length -= 3;
#251  switch(length)                     /* all the case statements fall through */
#277  size_t      length,    /* length of the key */
#285  a = b = c = 0xdeadbeef + ((uint32_t)length) + *pc;
#294    while (length > 12)
#300      length -= 12;
#316    switch(length)
#336    switch(length)
#360    while (length > 12)
#366      length -= 12;
#372    switch(length)
#406    while (length > 12)
#421      length -= 12;
#426    switch(length)                   /* all the case statements fall through */
#459hashbig( const void *key, size_t lengthuint32_t initval)
#465  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
#473    while (length > 12)
#479      length -= 12;
#495    switch(length)
#515    switch(length)                   /* all the case statements fall through */
#538    while (length > 12)
#553      length -= 12;
#558    switch(length)                   /* all the case statements fall through */
#610hashlittle( const void *key, size_t lengthuint32_t initval)
#616  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
#624    while (length > 12)
#630      length -= 12;
#646    switch(length)
#666    switch(length)
#690    while (length > 12)
#696      length -= 12;
#702    switch(length)
#736    while (length > 12)
#751      length -= 12;
#756    switch(length)                   /* all the case statements fall through */
#785hash_fast( const void *key, size_t length) {
#788    return hashlittle(keylengthNC_ARBITRARY_UINT);
#790    return hashbig(keylengthNC_ARBITRARY_UINT);
memio.c#92static int memio_pad_length(ncionciopoff_t length);
#428memio_pad_length(ncionciopoff_t length)
#440    if(length > memio->alloc) {
#442 off_t newsize = length;
#462    memio->size = length;
mmapio.c#108static int mmapio_pad_length(ncionciopoff_t length);
#417mmapio_pad_length(ncionciopoff_t length)
#429    if(length > mmapio->alloc) {
#431 off_t newsize = length;
#457    mmapio->size = length;
nc4internal.h#328extern uint32_t hash_fast(const void *key, size_t length);
nc_hashmap.c#15extern uint32_t hash_fast(const void *key, size_t length);
ncbytes.c#38  bb->length=0;
#54  if(bb->alloc > 0 && bb->length > 0 && bb->content != NULL) {
#55    memcpy((void*)newcontent,(void*)bb->content,sizeof(char)*bb->length);
#75  if(bb->length < sz) {
#78  bb->length = sz;
#87  for(i=0;i<bb->length;i++) bb->content[i] = fill;
#95  if(index >= bb->length) return -1;
#103  if(index >= bb->length) return ncbytesfail();
#113  while(bb->length+1 >= bb->alloc) {
#116  bb->content[bb->length] = (char)(elem & 0xFF);
#117  bb->length++;
#118  bb->content[bb->length] = '\0';
#131  if(bb->length == 0) return ncbytesfail();
#132  bb->length--;
#144  memcpy((void*)&bb->content[bb->length],(void*)elem,n);
#145  bb->length += n;
#146  bb->content[bb->length] = '\0';
#155  if(bb->length >= bb->alloc) if(!ncbytessetalloc(bb,0)) return ncbytesfail();
#159  bb->length++;
#166    char* result = (char*)malloc(bb->length+1);
#167    memcpy((void*)result,(const void*)bb->content,bb->length);
#168    result[bb->length] = '\0'; /* just in case it is a string*/
#177    bb->length = 0;
#189    bb->length = 0;
#201    bb->length--;
ncbytes.h#10  unsigned long length;
#51#define ncbyteslength(bb) ((bb)!=NULL?(bb)->length:0)
#55#define ncbytesclear(bb) ((bb)!=NULL?(bb)->length=0:0)
#56#define ncbytesavail(bb,n) ((bb)!=NULL?((bb)->alloc - (bb)->length) >= (n):0)
nccopy.c#727 size_t length;
#751 stat = nc_inq_dim(igrpidimidname, &length);
#760     NC_CHECK(nc_def_dim(ogrpnamelength, &odimid));
ncgeny.c#3326            if(list->length != 1)
#3384                special->nchunks = list->length;
#3462        for(i=0;i<list->length;i++,con++) {
#3528 switch (arglist->length) {
#3546 if(arglist->length == 2) {
ncio.c#128ncio_pad_length(ncionciopoff_t length)
#130    return nciop->pad_length(nciop,length);
ncio.h#78typedef int ncio_pad_lengthfunc(ncionciopoff_t length);
nclist.c#33    l->length=0;
#55  if(sz <= 0) {sz = (l->length?2*l->length:DEFAULTALLOC);}
#58  if(newcontent != NULL && l->alloc > 0 && l->length > 0 && l->content != NULL) {
#59    memcpy((void*)newcontent,(void*)l->content,sizeof(void*)*l->length);
#72  l->length = sz;
#79  if(l == NULL || l->length == 0) return NULL;
#80  if(index >= l->length) return NULL;
#88  if(index >= l->length) return FALSE;
#99  if(index > l->length) return FALSE;
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#103  l->length++;
#111  if(l->length >= l->allocnclistsetalloc(l,0);
#112  l->content[l->length] = elem;
#113  l->length++;
#120  if(l == NULL || l->length == 0) return NULL;
#121  l->length--;
#122  return l->content[l->length];
#128  if(l == NULL || l->length == 0) return NULL;
#129  return l->content[l->length - 1];
#137  if(l == NULL || (len=l->length) == 0) return NULL;
#141  l->length--;
#149    void** result = (void**)malloc(sizeof(void*)*(l->length+1));
#150    memcpy((void*)result,(void*)l->content,sizeof(void*)*l->length);
#151    result[l->length] = (void*)0;
#172  if(l == NULL || (len=l->length) == 0) return 0;
#177      l->length--;
#198    if(l == NULL || l->length == 0) return 1;
#199    len = l->length;
#210    l->length = len;
nclist.h#18  unsigned long length;
#60#define nclistlength(l)  ((l)==NULL?0:(l)->length)
ocbytes.c#38  bb->length=0;
#54  if(bb->alloc > 0 && bb->length > 0 && bb->content != NULL) {
#55    memcpy((void*)newcontent,(void*)bb->content,sizeof(char)*bb->length);
#75  if(bb->length < sz) {
#78  bb->length = sz;
#87  for(i=0;i<bb->length;i++) bb->content[i] = fill;
#95  if(index >= bb->length) return -1;
#103  if(index >= bb->length) return ocbytesfail();
#113  while(bb->length+1 >= bb->alloc) {
#116  bb->content[bb->length] = (char)elem;
#117  bb->length++;
#118  bb->content[bb->length] = '\0';
#128    if(bb->length == 0) return ocbytesfail();
#129    bb->length--;
#141  memcpy((void*)&bb->content[bb->length],(void*)elem,n);
#142  bb->length += n;
#143  bb->content[bb->length] = '\0';
#152  if(bb->length >= bb->alloc) if(!ocbytessetalloc(bb,0)) return ocbytesfail();
#156  bb->length++;
#163    char* result = (char*)malloc(bb->length+1);
#164    memcpy((void*)result,(const void*)bb->content,bb->length);
#165    result[bb->length] = '\0'; /* just in case it is a string*/
#174    bb->length = 0;
#186    bb->length = 0;
#198    bb->length--;
ocbytes.h#10  size_t length;
#51#define ocbyteslength(bb) ((bb)!=NULL?(bb)->length:0)
#55#define ocbytesclear(bb) ((bb)!=NULL?(bb)->length=0:0)
#56#define ocbytesavail(bb,n) ((bb)!=NULL?((bb)->alloc - (bb)->length) >= (n):0)
oclist.c#33    l->length=0;
#55  if(sz <= 0) {sz = (l->length?2*l->length:DEFAULTALLOC);}
#58  if(newcontent != NULL && l->alloc > 0 && l->length > 0 && l->content != NULL) {
#59    memcpy((void*)newcontent,(void*)l->content,sizeof(void*)*l->length);
#72  l->length = sz;
#79  if(l == NULL || l->length == 0) return NULL;
#80  if(index >= l->length) return NULL;
#88  if(index >= l->length) return FALSE;
#99  if(index > l->length) return FALSE;
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#103  l->length++;
#111  if(l->length >= l->allococlistsetalloc(l,0);
#112  l->content[l->length] = elem;
#113  l->length++;
#120  if(l == NULL || l->length == 0) return NULL;
#121  l->length--;
#122  return l->content[l->length];
#128  if(l == NULL || l->length == 0) return NULL;
#129  return l->content[l->length - 1];
#137  if(l == NULL || (len=l->length) == 0) return NULL;
#141  l->length--;
#149    void** result = (void**)malloc(sizeof(void*)*(l->length+1));
#152            memcpy((void*)result,(void*)l->content,sizeof(void*)*l->length);
#153        result[l->length] = (void*)0;
#175  if(l == NULL || (len=l->length) == 0) return 0;
#180      l->length--;
#201    if(l == NULL || l->length == 0) return 1;
#202    len = l->length;
#213    l->length = len;
oclist.h#18  size_t length;
#60#define oclistlength(l)  ((l)==NULL?0:(l)->length)
posixio.c#88static int ncio_px_pad_length(ncio *nciopoff_t length);
#1847ncio_px_pad_length(ncio *nciopoff_t length)
#1862  status = fgrow2(nciop->fdlength);
semantics.c#730 if(asym->data->length == 0) {
#736     emptystringconst(asym->lineno,&asym->data->data[asym->data->length]);
#761 if(asym->data->length == 0) {
#766     emptystringconst(asym->lineno,&asym->data->data[asym->data->length]);
#903    if(datalist->length == 0) {
#941    for(i=0;i<src->length;i++) {
#956    if(datalist == NULL || datalist->length == 0) return;
#1088    size_t length;
#1098        length = data->length;
#1099 unlimsize = length / xproduct;
#1100 if(length % xproduct != 0)
#1112 for(i=0;i<data->length;i++) {
#1123     length = 0;
#1124     for(i=0;i<data->length;i++) {
#1128     length++;
#1131     length += con->value.stringv.len;
#1141        length = data->length;
#1143 unlimsize = length / xproduct;
#1144 if(length % xproduct != 0)
#1182     for(j=0;j<var->data->length;j++) {
test_put.c#242    size_t length;
#263 err = nc_inq_dim(nciddimids[j], 0, &length);
#266 IF (length != var_shape[i][j])
#326    size_t length;
#347 err = nc_inq_dim(nciddimids[j], 0, &length);
#350 IF (length != var_shape[i][j])
#410    size_t length;
#431 err = nc_inq_dim(nciddimids[j], 0, &length);
#434 IF (length != var_shape[i][j])
#494    size_t length;
#515 err = nc_inq_dim(nciddimids[j], 0, &length);
#518 IF (length != var_shape[i][j])
#578    size_t length;
#599 err = nc_inq_dim(nciddimids[j], 0, &length);
#602 IF (length != var_shape[i][j])
#662    size_t length;
#683 err = nc_inq_dim(nciddimids[j], 0, &length);
#686 IF (length != var_shape[i][j])
#746    size_t length;
#767 err = nc_inq_dim(nciddimids[j], 0, &length);
#770 IF (length != var_shape[i][j])
#830    size_t length;
#851 err = nc_inq_dim(nciddimids[j], 0, &length);
#854 IF (length != var_shape[i][j])
#914    size_t length;
#935 err = nc_inq_dim(nciddimids[j], 0, &length);
#938 IF (length != var_shape[i][j])
#998    size_t length;
#1019 err = nc_inq_dim(nciddimids[j], 0, &length);
#1022 IF (length != var_shape[i][j])
#1082    size_t length;
#1103 err = nc_inq_dim(nciddimids[j], 0, &length);
#1106 IF (length != var_shape[i][j])
#1166    size_t length;
#1187 err = nc_inq_dim(nciddimids[j], 0, &length);
#1190 IF (length != var_shape[i][j])
#1249    size_t length;
#1259 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1264 IF (length != ATT_LEN(i,j))
#1266 assert(length <= MAX_NELS);
#1268 for (k = 0; k < lengthk++) {
#1277                if (nInExtRange == length && nInIntRange == length) {
#1284 for (k = 0; k < lengthk++) {
#1324    size_t length;
#1334 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1339 IF (length != ATT_LEN(i,j))
#1341 assert(length <= MAX_NELS);
#1343 for (k = 0; k < lengthk++) {
#1352                if (nInExtRange == length && nInIntRange == length) {
#1359 for (k = 0; k < lengthk++) {
#1399    size_t length;
#1409 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1414 IF (length != ATT_LEN(i,j))
#1416 assert(length <= MAX_NELS);
#1418 for (k = 0; k < lengthk++) {
#1427                if (nInExtRange == length && nInIntRange == length) {
#1434 for (k = 0; k < lengthk++) {
#1474    size_t length;
#1484 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1489 IF (length != ATT_LEN(i,j))
#1491 assert(length <= MAX_NELS);
#1493 for (k = 0; k < lengthk++) {
#1502                if (nInExtRange == length && nInIntRange == length) {
#1509 for (k = 0; k < lengthk++) {
#1549    size_t length;
#1559 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1564 IF (length != ATT_LEN(i,j))
#1566 assert(length <= MAX_NELS);
#1568 for (k = 0; k < lengthk++) {
#1577                if (nInExtRange == length && nInIntRange == length) {
#1584 for (k = 0; k < lengthk++) {
#1624    size_t length;
#1634 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1639 IF (length != ATT_LEN(i,j))
#1641 assert(length <= MAX_NELS);
#1643 for (k = 0; k < lengthk++) {
#1652                if (nInExtRange == length && nInIntRange == length) {
#1659 for (k = 0; k < lengthk++) {
#1699    size_t length;
#1709 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1714 IF (length != ATT_LEN(i,j))
#1716 assert(length <= MAX_NELS);
#1718 for (k = 0; k < lengthk++) {
#1727                if (nInExtRange == length && nInIntRange == length) {
#1734 for (k = 0; k < lengthk++) {
#1774    size_t length;
#1784 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1789 IF (length != ATT_LEN(i,j))
#1791 assert(length <= MAX_NELS);
#1793 for (k = 0; k < lengthk++) {
#1802                if (nInExtRange == length && nInIntRange == length) {
#1809 for (k = 0; k < lengthk++) {
#1849    size_t length;
#1859 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1864 IF (length != ATT_LEN(i,j))
#1866 assert(length <= MAX_NELS);
#1868 for (k = 0; k < lengthk++) {
#1877                if (nInExtRange == length && nInIntRange == length) {
#1884 for (k = 0; k < lengthk++) {
#1924    size_t length;
#1934 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#1939 IF (length != ATT_LEN(i,j))
#1941 assert(length <= MAX_NELS);
#1943 for (k = 0; k < lengthk++) {
#1952                if (nInExtRange == length && nInIntRange == length) {
#1959 for (k = 0; k < lengthk++) {
#1999    size_t length;
#2009 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#2014 IF (length != ATT_LEN(i,j))
#2016 assert(length <= MAX_NELS);
#2018 for (k = 0; k < lengthk++) {
#2027                if (nInExtRange == length && nInIntRange == length) {
#2034 for (k = 0; k < lengthk++) {
#2074    size_t length;
#2084 err = nc_inq_att(ncidiATT_NAME(i,j), &datatype, &length);
#2089 IF (length != ATT_LEN(i,j))
#2091 assert(length <= MAX_NELS);
#2093 for (k = 0; k < lengthk++) {
#2102                if (nInExtRange == length && nInIntRange == length) {
#2109 for (k = 0; k < lengthk++) {
test_read.c#478    size_t length;
#484 err = nc_inq_dim(BAD_IDiname, &length);
#487 err = nc_inq_dim(ncidBAD_DIMIDname, &length);
#493 err = nc_inq_dim(ncidiname, &length);
#498 else IF (dim_len[i] != length)
#499     error("size expected: %d, got: %d",dim_len[i],length);
#505 err = nc_inq_dim(ncidi, 0, &length);
#508 else IF (dim_len[i] != length)
#509     error("size expected: %d, got: %d",dim_len[i],length);
#523    size_t length;
#529 err = nc_inq_dimlen(BAD_IDi, &length);
#532 err = nc_inq_dimlen(ncidBAD_DIMID, &length);
#535 err = nc_inq_dimlen(ncidi, &length);
#538 else IF (dim_len[i] != length)
#539     error("size expected: %d, got: %d",dim_len[i],length);
test_write.c#98    size_t length;
#201    IF ((err = nc_inq_dim(nciddimidname, &length)))
#205    IF (length != sizehint)
#241    err = nc_inq_dim(nciddimidname, &length);
#246    IF (length != sizehint)
#469    size_t length;
#503    err = nc_inq_dimlen(nciddimid, &length);
#506    IF (length != 0)
#1311    size_t length; /* of att */
#1327     length = ATT_LEN(i,j);
#1328            err = nc_put_att(BAD_IDvaridnamedatatypelengthbuf);
#1331            err = nc_put_att(ncidvaridBAD_NAMEdatatypelengthbuf);
#1334            err = nc_put_att(ncidBAD_VARIDnamedatatypelengthbuf);
#1337     err = nc_put_att(ncidvaridnameBAD_TYPElengthbuf);
#1341     for (k = 0; k < lengthk++) {
#1350            err = nc_put_att(ncidvaridnamedatatypelengthbuf);
#1391    size_t length;              /* of att */
#1488     err = nc_inq_att(ncid_outi, "a", &datatype, &length);
#1493     IF (length != 1)
#1538    size_t length;
#1600            err = nc_inq_att(ncidvaridname, &datatype, &length);
#1605            IF (length != attlength)
tests.h#522    size_t length,
#528    size_t length,
utf8proc.h#341ssize_t utf8proc_reencode(int32_t *bufferssize_t length, int options);
util.c#455poolalloc(size_t length)
#462    if(length == 0) length = POOL_DEFAULT;
#464    pool[poolindex] = (char*)emalloc(length);
#563     for(i=0,con=list->data;i<list->length;i++,con++)
util.c#212    size_t length,
#218    if (length > 0) {
#219 for (i = length - 1; i > 0; i--) {
#242    size_t length,
#249    for (i = 1; i < lengthi++) {
#253    if (length > 0)
#902    size_t length;
#907 err = nc_inq_dim(ncidiname, &length);
#912 IF (length != dim_len[i])
#913     error("Unexpected length %d of dimension %d, expected %zu", lengthidim_len[i]);
#936    size_t length;
#951     err = nc_inq_dim(nciddimids[j], 0, &length);
#954     IF (length != var_shape[i][j])
#1017    size_t length;
#1030     err = nc_inq_att(ncidiname, &datatype, &length);
#1035     IF (length != ATT_LEN(i,j))
xxdr.c#79        where,arg,(long)xdr->pos,(long)xdr->length);
#295    if(xdrs->pos + len > xdrs->length)
#320    return (xdrs->length - xdrs->pos);
#330    if(pos > xdrs->length) {ok=0;goto done;}
#362 xdrs->length = (off_t)ftell(file);
#363 xdrs->length -= xdrs->base;
#392    if(xdrs->pos+len > xdrs->length) {ok=0; goto done;}
#412    return (xdrs->length - xdrs->pos);
#422    if(pos > xdrs->length) {ok=0; goto done;}
#447        xdrs->length = memsize - base;
xxdr.h#122  off_t length; /* total size of available data (relative to base)*/
#195#define xxdr_length(xdrs) ((xdrs)->length)


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