add.c#90     test->atts[ia].len = iatt->len;
#100    test->atts[test->natts].len = iatt->len;
#139 test->atts[ib-1].len =   test->atts[ib].len;
atttests.c#99       atts[ia].lenatts[ia].val) == -1) {
#118       &tmp.type, &tmp.len) == -1) {
#122 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#128 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#133 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#152       atts[ia].nameatts[ia].typeatts[ia].lenatts[ia].val)
#162       &tmp.type, &tmp.len) == -1) {
#166 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#172 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#177 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#192       atts[ia].lenatts[ia].val) == -1) {
#199 tmp.len = atts[ia].len;
#206       &tmp.type, &tmp.len) == -1) {
#210 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#216 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#221 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#230   atts[0].lenatts[0].val) != -1) {
#246   atts[0].len + 10, atts[0].val) != -1) {
#252       atts[0].lenatts[0].val) != -1) {
#259   atts[0].lenatts[0].val) != -1) {
#271       atts[ia].lenatts[ia].val) == -1) {
#279 tmp.len = atts[ia].len;
#285 if (ncattinq(cdfidww_idatts[ia+1].name, &tmp.type, &tmp.len)
#291 if (atts[ia].type != tmp.type || atts[ia].len != tmp.len) {
#297 tmp.val = emalloc(atts[ia].len * nctypelen(atts[ia].type));
#303 if (val_cmp(tmp.typetmp.lentmp.valatts[ia].val) != 0) {
#310    if (ncattput(cdfidtest.nvarsatts[0].nameatts[0].typeatts[0].len,
#320    if (ncattput(cdfidww_idatts[0].nameatts[0].typeatts[0].len,
#352    int len;
#366       &type, &len) == -1) {
#376 if (len != test.atts[ia].len) {
#400    if (ncattinq(cdfidvv_id, "nonesuch", &type, &len) != -1) {
#405    if (ncattinq(cdfidtest.nvarstest.atts[0].name, &type, &len) != -1) {
#412       &type, &len) == -1) {
#422 if (len != test.atts[ia].len) {
#436    if (ncattinq(cdfidNC_GLOBALtest.atts[0].name, &type, &len) != -1) {
#499   vmax.namevmax.typevmax.lenvmax.val)
#509       &tmp.type, &tmp.len) == -1) {
#518 if (tmp.len != test.atts[ia].len) {
#523 tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
#530 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#534   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#536     val_out(test.atts[ia].typetest.atts[ia].len,
#539     val_out(tmp.typetmp.lentmp.val);
#552       &tmp.type, &tmp.len) == -1) {
#562 if (tmp.len != test.atts[ia].len) {
#568 tmp.val = emalloc(tmp.len * nctypelen(tmp.type));
#575 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#579   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#581     val_out(test.atts[ia].typetest.atts[ia].len,
#584     val_out(tmp.typetmp.lentmp.val);
#665    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#678    if (ncattput(cdfidtt_idatt.nameatt.typeatt.lenatt.val) == -1) {
#692    if (ncattput(cdfidtu_idatt.nameatt.typeatt.lenatt.val) == -1) {
#729    if (ncattinq(cdfid2NC_GLOBALatt.name, &tmp.type, &tmp.len) == -1) {
#733    if (att.type != tmp.type || att.len != tmp.len) {
#738    tmp.val = emalloc(att.len * nctypelen(att.type));
#743    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#755    if (ncattinq(cdfid2tu2_idatt.name, &tmp.type, &tmp.len) == -1) {
#759    if (att.type != tmp.type || att.len != tmp.len) {
#764    tmp.val = emalloc(att.len * nctypelen(att.type));
#769    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#785    if (ncattput(cdfidNC_GLOBALatt2.nameatt2.typeatt2.lenatt2.val)
#798    if (ncattinq(cdfid2tu2_idatt2.name, &tmp.type, &tmp.len) == -1) {
#802    if (att2.type != tmp.type || att2.len != tmp.len) {
#807    tmp.val = emalloc(att2.len * nctypelen(att2.type));
#812    if (val_cmp(tmp.typetmp.lentmp.valatt2.val) != 0) {
#827    if (ncattinq(cdfidtu_idatt2.name, &tmp.type, &tmp.len) == -1) {
#831    if (att2.type != tmp.type || att2.len != tmp.len) {
#836    tmp.val = emalloc(att2.len * nctypelen(att2.type));
#841    if (val_cmp(tmp.typetmp.lentmp.valatt2.val) != 0) {
#984    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val)
#1125    if (ncattput(cdfidNC_GLOBALatty.nameatty.typeatty.len,
#1132    if (ncattput(cdfidNC_GLOBALattz.nameattz.typeattz.len,
#1146    if (ncattinq(cdfidNC_GLOBALnewname, &tmp.type, &tmp.len) == -1) {
#1150    if (atty.type != tmp.type || atty.len != tmp.len) {
#1155    tmp.val = emalloc(atty.len * nctypelen(atty.type));
#1160    if (val_cmp(tmp.typetmp.lentmp.valatty.val) != 0) {
#1165    if (ncattinq(cdfidNC_GLOBALatty.name, &tmp.type, &tmp.len) != -1) {
#1207    if (val_cmp(tmp.typetmp.lentmp.valatty.val) != 0) {
#1274    if (ncattput(cdfidNC_GLOBALyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1288    if (ncattput(cdfidyav_idyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1322    if (ncattinq(cdfidNC_GLOBALyaa.name, &atmp.type, &atmp.len) != -1) {
#1343    if (ncattinq(cdfidyav_idyaa.name, &atmp.type, &atmp.len) != -1) {
#1349    if (ncattput(cdfidNC_GLOBALyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1354    if (ncattput(cdfidyav_idyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
bindata.c#38        size_t len;
#40        bytes=makebytestring(con->value.opaquev.stringv,&len);
#41        bbAppendn(buf,(void*)bytes,len);
#84        int len = (size_t)con->value.stringv.len;
#85 if(len == 0 && con->value.stringv.stringv == NULL) {
#89     ptr = (char*)malloc(len+1);
#90     memcpy(ptr,con->value.stringv.stringv,len);
#91     ptr[len] = '\0';
#142    ptr.len = count;
#158    ptr.len = bbLength(vlenmem);
bm_file.c#203   size_t lenlen2typelen;
#211   if ((ret = nc_inq_att(ncid1varidname, &typeid, &len)))
#215   if (len != len2 || typeid != typeid2)
#221   if (len)
#223      if(!(d = malloc(typelen * len)))
#225      if(!(d2 = malloc(typelen * len)))
#236      if (memcmp(dd2typelen * len))
#259   size_t lenlen2;
#321      if ((ret = nc_inq_dim(ncid1dname, &len)))
#325      if (len != len2 || strcmp(namename2))
#472   size_t len;
#542  if ((ret = nc_inq_dim(ncid_indname, &len)))
#546     if ((ret = nc_def_dim(ncid_outnamelenNULL)))
#552   (d == unlimdimid) ? NC_UNLIMITED : len,
bytebuffer.h#51#define bbExtend(bb,lenbbSetalloc((bb),(len)+(bb->alloc))
cdata.c#86 if(con->value.stringv.len == 0 && con->value.stringv.stringv == NULL) {
#90  '"',con->value.stringv.len);
#100 bslen=(4*con->value.opaquev.len);
cdf.c#75    unsigned int i,len;
#92    len = nclistlength(allvarnodes);
#93    for(i=0;i<len;i++) {
#105    for(i=0;i<len;i++) {
#118    for(i=0;i<len;i++) {
#915        size_t len = strlen(ocname);
#916        if(len >= NC_MAX_NAMElen = NC_MAX_NAME-1;
#917        node->ocname = (char*)malloc(len+1);
#919 memcpy(node->ocname,ocname,len);
#920 node->ocname[len] = '\0';
cdftests.c#174    if (ncattput(ncid0NC_GLOBAL, "title", NC_CHARtitle.lentitle.val)
#289   aa_units.typeaa_units.len, (void *) aa_units.val) == -1) {
#380    if (ncattput(ncidbb_idbb_range.namebb_range.typebb_range.len,
#577       cc_units.len, (void *) cc_units.val) == -1) {
#688   dd_fill_val.len, (void *) dd_fill_val.val) == -1) {
#806    if (ncattput(ncidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#821    if (ncattinq(ncidNC_GLOBALatt.name, &att.type, &att.len) != -1) {
cdm_sea_soundings.c#35      data[i].temp_vl.len = i + 1;
cvt.c#433    tmp.stringv.len = src->value.stringv.len;
#434    tmp.stringv.stringv = (char*)malloc(src->value.stringv.len+1);
#437           tmp.stringv.len);
#438    tmp.stringv.stringv[tmp.stringv.len] = '\0';
#444    tmp.stringv.len = nulllen(stmp);
#449    tmp.stringv.len = nulllen(stmp);
#454    tmp.stringv.len = nulllen(stmp);
#459    tmp.stringv.len = nulllen(stmp);
#464    tmp.stringv.len = nulllen(stmp);
#469    tmp.stringv.len = nulllen(stmp);
#474    tmp.stringv.len = nulllen(stmp);
#479    tmp.stringv.len = nulllen(stmp);
#484    tmp.stringv.len = nulllen(stmp);
#489    tmp.stringv.len = nulllen(stmp);
#494    tmp.stringv.len = nulllen(stmp);
#543    tmp.opaquev.stringv = (char*)malloc(src->value.opaquev.len+1);
#544    memcpy(tmp.opaquev.stringv,src->value.opaquev.stringv,src->value.opaquev.len);
#545    tmp.opaquev.len = src->value.opaquev.len;
#546    tmp.opaquev.stringv[tmp.opaquev.len] = '\0';
#551    tmp.stringv.len = 0;
#573setprimlength(NCConstantprim, unsigned long len)
#577        if(prim->value.stringv.len == len) {
#579        } else if(prim->value.stringv.len > len) { /* truncate*/
#580     prim->value.stringv.stringv[len] = '\0';
#581     prim->value.stringv.len = len;
#584            s = (char*)emalloc(len+1);
#585     memset(s,NC_FILL_CHAR,len);
#586     s[len] = '\0';
#587     memcpy(s,prim->value.stringv.stringv,prim->value.stringv.len);
#590            prim->value.stringv.len = len;
#595 ASSERT((len % 2) == 0);
#596        if(prim->value.opaquev.len == len) {
#598        } else if(prim->value.opaquev.len > len) { /* truncate*/
#599     prim->value.opaquev.stringv[len] = '\0';
#600     prim->value.opaquev.len = len;
#603     s = (char*)emalloc(len+1);
#604     memset(s,'0',len);
#605     memcpy(s,prim->value.opaquev.stringv,prim->value.opaquev.len);
#606     s[len] = '\0';
#609     prim->value.opaquev.len = len;
#623    slen = str->value.stringv.len;
dapalign.c#39    size_t len;
#200    int len = strlen(name);
#201    if(len > MAXlen = MAX;
#205    strncpy(s,name,len);
dapattr.c#428    int len = strlen(name);
#431    if(len < glen) return 0;
#432    p = name + (len - glen);
dapdump.c#60     size_t len = typesize*nvalues;
#61     char* values = (char*)malloc(len+1);/* for null terminate*/
#65     values[len] = '\0';
#68     size_t len = typesize*nvalues;
#69     char* values = (char*)malloc(len);
dapparse.c#205    int len = strlen(name);
#208    if(len < glen) return 0;
#209    p = name + (len - glen);
#218    size_t len = strlen(name);
#220    if(len < glen) return 0;
#406    unsigned int len = oclistlength(list);
#408    for(i=0;i<len;i++) {
#411        for(j=i+1;j<len;j++) {
#417 len--;
#446    size_t lensuffixlenprefixlen;
#452    len = strlen(state->lexstate->input);
#454    prefixlen = (len - suffixlen);
#455    tmp = (char*)ocmalloc(len+1);
daputil.c#240    unsigned long len;
#242    len = ncbyteslength(buf);
#243    pad = nccpadding(len,alignment);
#249    ncbytessetlength(buf,len+pad);
#315    unsigned int i,len,found;
#316    len = nclistlength(l2);
#318    for(i=0;i<len;i++) {
#328    unsigned int len,found;
#330    len = nclistlength(l);
#331    for(i=len-1;i>=0;i--) {
#373    int i,len,first;
#391    len = nclistlength(ocpath);
#392    assert(len > 0); /* dataset at least */
#395    for(first=1,i=1;i<len;i++) { /* start at 1 to skip dataset name */
#414    int i,len,first;
#419    len = nclistlength(path);
#420    ASSERT(len > 0); /* dataset at least */
#422    if(len == 1) {/* dataset only */
#428    for(first=1,i=0;i<len;i++) {
#474    size_t len;
#477    for(len=0,i=0;i<nclistlength(names);i++) {
#479 len += strlen(name);
#480 len += strlen(separator);
#482    len++; /* null terminator */
#483    result = (char*)malloc(len);
data.c#189    int len = ds->length;
#191    if(len == 0) return 0;
#192    if(index >= lenindex = len-1;
#277 s = (char*)emalloc(newcon.value.stringv.len+1);
#278 memcpy(s,newcon.value.stringv.stringv,newcon.value.stringv.len);
#279 s[newcon.value.stringv.len] = '\0';
#283 s = (char*)emalloc(newcon.value.opaquev.len+1);
#284 memcpy(s,newcon.value.opaquev.stringv,newcon.value.opaquev.len);
#285 s[newcon.value.opaquev.len] = '\0';
#664    c->value.stringv.len = 0;
data.h#39 int len;
#43 int len; /* length as originally written (rounded to even number)*/
dattput.c#51   size_t len, const char** value)
#57   len, (void*)valueNC_STRING);
#139 size_t len, const char *value)
#144   return ncp->dispatch->put_att(ncidvaridnameNC_CHARlen,
#230    size_t len, const void *value)
#235   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#241  nc_type xtype, size_t len, const signed char *value)
#246   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#252  nc_type xtype, size_t len, const unsigned char *value)
#257   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#263  nc_type xtype, size_t len, const short *value)
#268   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#274        nc_type xtype, size_t len, const int *value)
#279   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#285 nc_type xtype, size_t len, const long *value)
#290   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#296  nc_type xtype, size_t len, const float *value)
#301   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#307   nc_type xtype, size_t len, const double *value)
#312   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#318  nc_type xtype, size_t len, const unsigned char *value)
#323   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#329   nc_type xtype, size_t len, const unsigned short *value)
#334   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#340 nc_type xtype, size_t len, const unsigned int *value)
#345   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#351     nc_type xtype, size_t len,
#357   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#363      nc_type xtype, size_t len,
#369   return ncp->dispatch->put_att(ncidvaridnamextypelen,
dceconstraints.c#958    int len = nclistlength(list1);
#959    if(len != nclistlength(list2)) return 0;
#960    for(i=0;i<len;i++) {
dcelex.c#44    int len;
#141    len = ncbyteslength(lexstate->yytext);
#142    if(len > MAX_TOKEN_LENGTHlen = MAX_TOKEN_LENGTH;
#143    strncpy(lexstate->lasttokentext,ncbytescontents(lexstate->yytext),len);
#144    lexstate->lasttokentext[len] = '\0';
dcopy.c#485   size_t len;
#493   if ((res = nc_inq_att(ncid_invarid_inname, &xtype, &len)))
#499      if (len)
#504  if (!(data = malloc(len * size)))
#511   lendata);
#512      if (len)
#520      if (!(str_data = malloc(sizeof(char *) * len)))
#524  res = nc_put_att_string(ncid_outvarid_outnamelen,
#526      nc_free_string(lenstr_data);
#552     if (!(vldata = malloc(sizeof(nc_vlen_t) * len)))
#557  lenvldata)))
#559     for (i = 0; i < leni++)
#566     if (!(data = malloc(size * len)))
#570        res = nc_put_att(ncid_outvarid_outnamextype_outlendata);
ddim.c#124nc_def_dim(int ncid, const char *name, size_t len, int *idp)
#130    return ncp->dispatch->def_dim(ncidnamelenidp);
dump.c#201 if(con->value.stringv.len > 0 && con->value.stringv.stringv != NULL)
#207 if(con->value.opaquev.len > 0 && con->value.opaquev.stringv != NULL)
dumplib.c#178#define SAFEBUF_EXPR(sbuf) (*(int *)((sbuf)->buf + (sbuf)->len))
#189    size_t len = SAFEBUF_INIT_LEN;
#192    sb->buf = (char *)emalloc(len + sizeof(int));
#193    sb->len = len;
#206sbuf_grow(safebuf_t *sb, size_t len) {
#207    size_t m = sb->len;
#210    if (len <= m)
#216    while(len > m) {
#220    memcpy(tmpsb->bufsb->len);
#221    sb->len = m;
#235    strncpy(sb->bufs2sb->len);
#248    res = strlcat(sb->buf + sb->cls2sb->len);
#249    assert( res < sb->len );
#264    res = strlcat(s1->buf + s1->cls2->bufs1->len);
#265    assert( res < s1->len );
#687    size_t v1len = ((nc_vlen_t *)v1p)->len;
#688    size_t v2len = ((nc_vlen_t *)v2p)->len;
#1054    size_t len = ((nc_vlen_t *)valp)->len;
#1063    for(i = 0; i < leni++) {
#1066 if(i < len - 1) {
#1082    size_t len, /* number of characters */
#1088    char *sout = (char *)emalloc(4*len + 5); /* max len of string */
#1093    sp = vals + len;
#1094    while (len != 0 && *--sp == '\0')
#1095 len--;
#1096    for (iel = 0; iel < leniel++) {
dv2i.c#181 size_t len;
#182 status = nc_inq_dimlen(nciddimids[id], &len);
#185 size *= (int)len;
#213 size_t len;
#214 status = nc_inq_dimlen(nciddimids[id], &len);
#217 sizes[id] = len;
#993    int len,
#997 const int status = nc_put_att(ncidvaridnamedatatypelenvalue);
#1013    int* len
#1026 if(len != NULL)
#1027 *len = (int) ll;
dvar.c#609nc_free_string(size_t len, char **data)
#612   for (i = 0; i < leni++)
dvlen.c#52nc_free_vlens(size_t lennc_vlen_t vlens[])
#57   for(i = 0; i < leni++)
#148nc_put_vlen_element(int ncid, int typeid1, void *vlen_element, size_t len, const void *data)
#153    return ncp->dispatch->put_vlen_element(ncid,typeid1,vlen_element,len,data);
#177     size_t *len, void *data)
#183    lendata);
escapes.c#30    size_t len = strlen(name);
#36    newname = (char *) emalloc(len + 1);
#55    strncpy(namenewnamelen+1); /* watch out for trailing null*/
#111escapify(char* s0, int quote, size_t len)
#115    result = poolalloc(1+4*len); /* overkill to support maximal expansion*/
#117    for(i=0;i<len;i++) {
#347xescapify(char* s0, int quote, size_t len)
#352    for(i=0;i<len;i++) {
#423jescapify(char* s0, int quote, size_t len)
#434    s16 = emalloc((1+len)*sizeof(UTF16));
#437    status = ConvertUTF8toUTF16((const UTF8**)&s8,s8+len,&tmp16,tmp16+len,lenientConversion);
f77data.c#64     bbAppendn(buf,ci->value.stringv.stringv,ci->value.stringv.len);
ffio.c#77fgrow(const int fd, const off_t len)
#83 if (len < sb.st_size)
#91 if (ffseek(fdlen-sizeof(dumb), SEEK_SET) < 0)
#109fgrow2(const int fd, const off_t len)
#115 if (len <= sb.st_size)
#124     if (ffseek(fdlen-1, SEEK_SET) < 0)
genbin.c#434    size_t len;
#444    len = list->length;
#451        stat = nc_put_att_schar(grpid,varid,asym->name,typid,len,data);
#470        stat = nc_put_att_short(grpid,varid,asym->name,typid,len,data);
#475                stat = nc_put_att_int(grpid,varid,asym->name,typid,len,data);
#480                stat = nc_put_att_float(grpid,varid,asym->name,typid,len,data);
#485                stat = nc_put_att_double(grpid,varid,asym->name,typid,len,data);
#498                stat = nc_put_att_uchar(grpid,varid,asym->name,typid,len,data);
#503                stat = nc_put_att_ushort(grpid,varid,asym->name,typid,len,data);
#508                stat = nc_put_att_uint(grpid,varid,asym->name,typid,len,data);
#513                stat = nc_put_att_longlong(grpid,varid,asym->name,typid,len,data);
#518                stat = nc_put_att_ulonglong(grpid,varid,asym->name,typid,len,data);
#528         len,(void*)data);
genc.c#1075    size_t len = asym->data->length; /* default assumption */
#1083        len = bbLength(code); /* presumably before quoting */
#1085 if(len == 0) len++;
#1132   len,
#1146   len,
#1169   len,
#1187   len,
#1207         len,
genchar.c#21static NCConstantmakeconst(int lineno, int len, char* str);
#170        constsize = con->value.stringv.len;
#172                         con->value.stringv.len);
#194            if(ccon->value.stringv.len > 0) {
#257     int len = 0;
#264     if(len == 0)
#266     accum[len] = con->value.charv;
#267     len++;
#269     if(len > 0) {
#270 con = makeconst(lineno,len,accum);
#271 len = 0;
#278     if(len > 0) {
#279 con = makeconst(lineno,len,accum);
#280 len = 0;
#339makeconst(int lineno, int len, char* str)
#345    con->value.stringv.len = len;
#347    con->value.stringv.stringv = (char*)malloc(len+1);
#348    memcpy((void*)con->value.stringv.stringv,(void*)str,len);
#349    con->value.stringv.stringv[len] = '\0';
generate.c#446    if(prim->value.opaquev.len == nnibs) {
#448    } else if(prim->value.opaquev.len > nnibs) { /* truncate*/
#450        prim->value.opaquev.len = nnibs;
#455        memcpy(s,prim->value.opaquev.stringv,prim->value.opaquev.len);
#459        prim->value.opaquev.len = nnibs;
genf77.c#857    size_t len = asym->data==NULL?0:asym->data->length;
#878 len,
#884 len = bbLength(code);
#886 if(len==0) len++;
#891 len);
genj.c#523    size_t len = asym->data == NULL?0:asym->data->length;
#530        len = bbLength(code);
#531        if(len == 0) {
#532     bbAppend(code,'\0'); len++;
#535     len++;
#563 len);
genlib.c#71     atts[iatt].typeatts[iatt].len,
#76    atts[iatt].len,
#81     atts[iatt].typeatts[iatt].len,
#86     atts[iatt].typeatts[iatt].len,
#91     atts[iatt].typeatts[iatt].len,
#96     atts[iatt].typeatts[iatt].len,
#310     (unsigned long) atts[iatt].len);
#398 val_string = cstrstr((char *) atts[iatt].valatts[iatt].len);
#404 (unsigned long) atts[iatt].len,
#410 for (jatt = 0; jatt < atts[iatt].len ; jatt++) {
#428 (unsigned long) atts[iatt].len,
#713 if (atts[iatt].len > max_atts[(int) atts[iatt].type]) {
#714     max_atts[(int)atts[iatt].type] = atts[iatt].len;
#800 val_string = fstrstr((char *) atts[iatt].valatts[iatt].len);
#806 (unsigned long) atts[iatt].len,
#812 for (jatt = 0; jatt < atts[iatt].len ; jatt++) {
#829 (unsigned long) atts[iatt].len,
#873    int len = (int) strlen(stmnt);
#886    while (len > 0) {
#891 len -= 66;
#892 if (len > 0)
#1096     size_t len) /* number of characters in valp */
#1103    if(4*len+3 != (unsigned)(4*len+3)) {
#1107    sp = cp = (char *) emalloc(4*len+3);
#1109    if(len == 1 && *valp == 0) { /* empty string */
#1114    istr0 = istr = (char *) emalloc(len + 1);
#1115    for(ii = 0; ii < lenii++) {
#1118    istr[len] = '\0';
#1121    for(ii = 0; ii < lenii++) {
#2018 size_t jlen;
#2025 len = strlcat(sprepls[j], newlen);
#2026 assert(len < newlen);
#2044    size_t len = strlen(name);
#2050    newname = (char *) emalloc(len + 1);
#2069    strncpy(namenewnamelen);
genlib.h#72extern char* xescapify(char* s0, int quote, size_t len);
#73extern char* jescapify(char* s0, int quote, size_t len);
#89extern void setprimlength(NCConstantprim, unsigned long len);
genlib.h#32extern char* cstrstr ( const char* valp, size_t len );
getfill.c#168        value->value.stringv.len = (int)strlen(NC_FILL_STRING);
#170 if(value->value.stringv.len == 0)
#171     value->value.stringv.len = 1;
#174        value->value.opaquev.len = 2;
jdata.c#83  '"',con->value.stringv.len);
list.c#135  unsigned long len;
#137  if(l == NULL || (len=l->length) == 0) return NULL;
#138  if(i >= len) return NULL;
#140  for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#169  unsigned long len;
#172  if(l == NULL || (len=l->length) == 0) return 0;
#176      for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#196    unsigned long i,j,k,len;
#199    len = l->length;
#201    for(i=0;i<len;i++) {
#202        for(j=i+1;j<len;j++) {
#205                for(k=j+1;k<len;k++) content[k-1] = content[k];
#206 len--;
#210    l->length = len;
list.h#58#define listextend(l,lenlistsetalloc((l),(len)+(l->alloc))
lookup3.c#891  uint32_t len;
#948  len = 0xdeadbeef;
#950  hashword2(&len, 1, &i, &j);
#951  if (hashword(&len, 1, 47) != i)
#953    ihashword(&len, 1, 47));
#960      len = i;
#964      ref = hashlittle(blen, (uint32_t)1);
#967      x = hashlittle(blen, (uint32_t)1);
#968      y = hashlittle(blen, (uint32_t)1);
nc3dispatch.c#459     size_t len, const void *data)
#466     size_t *len, void *data)
nc3dispatch.h#109NC3_def_dim(int ncid, const char *name, size_t len, int *idp);
#150    size_t len, const void *valuenc_type);
nc3internal.c#237 index += (*vpp)->len;
#301 index += (*vpp)->len;
#304 if( ncp->recsize > X_UINT_MAX - (*vpp)->len )
#309 if((*vpp)->len != UINT32_MAX) /* flag for vars >= 2**32 bytes */
#310     ncp->recsize += (*vpp)->len;
#318     if(ncp->recsize == last->len) { /* exactly one record variable, pack value */
#320     } else if(last->len == UINT32_MAX) { /* huge last record variable */
#499 status = fill_NC_var(ncp, *varpp, (*varpp)->len, 0);
#542     size_t varsize = numrecvars == 1 ? gnu->recsize :  gnu_varp->len;
#570 const int status = fill_NC_var(gnugnu_varpgnu_varp->len, 0);
#623  old_varp->len, 0);
#671                old_varp->len, 0);
#913     varsize = last_fix->len;
#914     if(last_fix->len == X_UINT_MAX) { /* huge last fixed var */
nc3internal.h#187 size_t len; /* the total length originally allocated */
nc4attr.c#91   if (data && att->len &&
#98      *lenp = att->len;
#106   if (!att->len)
#116   if (data && att->len && mem_type != att->nc_typeid &&
#121      if (!(bufr = malloc((size_t)(att->len * type_size))))
#125      mem_type, (size_t)att->len, &range_error,
#162  for (i = 0; i < att->leni++)
#164     vldest[i].len = att->vldata[i].len;
#165     if (!(vldest[i].p = malloc(vldest[i].len * base_typelen)))
#167     memcpy(vldest[i].patt->vldata[i].pvldest[i].len * base_typelen);
#172  for (i = 0; i < att->leni++)
#192     for (i = 0; i < att->leni++)
#196     memcpy(databufr, (size_t)(att->len * type_size));
#211     nc_type file_typenc_type mem_type, size_t len, int is_long,
#231 namefile_typemem_typelen));
#234   if (len && !data)
#295         len * nc4typelen(file_type) > (size_t)att->len * nc4typelen(att->nc_typeid))
#341      for (i = 0; i < att->leni++)
#349      for (i = 0; i < att->leni++)
#355   att->len = len;
#373      if (att->len != 1)
#420          fv_vlen->len = in_vlen->len;
#421          if (!(fv_vlen->p = malloc(size * in_vlen->len)))
#423          memcpy(fv_vlen->pin_vlen->pin_vlen->len * size);
#447   if(att->len)
#471         if (!(att->vldata = (nc_vlen_t*)malloc(att->len * sizeof(hvl_t))))
#473         for (i = 0; i < att->leni++)
#475            att->vldata[i].len = vldata1[i].len;
#476            if (!(att->vldata[i].p = malloc(base_typelen * att->vldata[i].len)))
#478            memcpy(att->vldata[i].pvldata1[i].pbase_typelen * att->vldata[i].len);
#484        if (!(att->stdata = malloc(sizeof(char *) * att->len))) {
#496        for (i = 0; i < att->leni++)
#512         if (!(att->data = malloc(att->len * type_size)))
#517            memcpy(att->datadatalen * type_size);
#522                                           len, &range_errorNULL,
#828        nc_type mem_type, int mem_type_is_long, size_t len,
#838 "mem_type %d len %d", ncidvaridnamefile_typemem_typelen));
#842   if((unsigned long) len > X_INT_MAX)
#870   return nc4_put_att(ncidncvaridnamefile_typemem_typelen,
#886 int len;
#895 len = strlen(propdata);
#896 if(lenp) *lenp = len;
#897 if(datastrncpy((char*)data,propdata,len+1);
nc4dim.c#58NC4_def_dim(int ncid, const char *name, size_t len, int *idp)
#69 (int)len));
#85      if (len == NC_UNLIMITED)
#107      if(len > X_UINT_MAX) /* Backward compat */
#125   dim->len = len;
#126   if (len == NC_UNLIMITED)
#230     *lenp = dim->len;
nc4dispatch.h#80NC4_def_dim(int ncid, const char *name, size_t len, int *idp);
#121    size_t len, const void *valuenc_type);
nc4file.c#622      new_dim->len = NC_MAX_UINT;
#626      new_dim->len = scale_size;
#648            size_t len = 0, *lenp = &len;
#652            new_dim->len = *lenp;
#1017        __func__att->attnumatt->name, (int)att->nc_typeidatt->len));
#1097   att->len = dims[0];
#1108  if (!(att->vldata = malloc((unsigned int)(att->len * sizeof(hvl_t)))))
#1115  if (!(att->stdata = calloc(att->len, sizeof(char *))))
#1134     if (!(contig_buf = malloc(att->len * fixed_size * sizeof(char))))
#1147     for (i = 0; i < att->leni++)
#1169  if (!(att->data = malloc((unsigned int)(att->len * type_size))))
#2563      att->len = att_count;
#2568      if (!(att->data = malloc(att_type_size * att->len)))
#2715        dim->len = dim_len;
#2717        dim->len = *dimsize;
#2755  att->len = att_count;
#2762  if (!(att->data = malloc(att_type_size * att->len))) {
nc4hdf.c#260          fv_vlen->len = in_vlen->len;
#261          if (!(fv_vlen->p = malloc(size * in_vlen->len)))
#267          memcpy(fv_vlen->pin_vlen->pin_vlen->len * size);
#562  size_t len = 1;
#675          len *= countp[d2];
#677           var->type_info->nc_typeidlen));
#687      if(len > 0)
#688        if (!(bufr = malloc(len * file_type_size)))
#743              if (start[d2] + count[d2] > dim->len)
#745                  dim->len = start[d2] + count[d2];
#751              xtend_size[d2] = (long long unsigned)dim->len;
#807                                     len, &range_errorvar->fill_value,
#891  size_t len = 1;
#1063              len *= countp[d2];
#1065               var->type_info->nc_typeidlen));
#1070          if(len > 0)
#1071            if (!(bufr = malloc(len * file_type_size)))
#1122                                         len, &range_errorvar->fill_value,
#1302       att->nc_typeidatt->len));
#1329  dims[0] = att->len;
#1378      if (!att->len)
#1657          dimsize[d] = dim->unlimited ? NC_HDF5_UNLIMITED_DIMSIZE : dim->len;
#1658          maxdimsize[d] = dim->unlimited ? H5S_UNLIMITED : (hsize_t)dim->len;
#1679                if (!dim->unlimited && chunksize[d] > dim->len)
#1680                  chunksize[d] = dim->len;
#2387      dims[0] = dim->len;
#2388      max_dims[0] = dim->len;
#2428      sprintf(dimscale_wo_var, "%s%10d", DIM_WITHOUT_VARIABLE, (int)dim->len);
#2459       new_size[d1] = v1->dim[d1]->len;
#2664                 const size_t len, int *range_error,
#2684       __func__lensrc_typedest_typesrc_longdest_long));
#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++)
#3753                    if ((dim->len == h5dimlen[d]) &&
#3777                      dim->len = h5dimlen[d];
#3801                    size_t *len)
#3807  assert(len);
#3815      *len = sizeof(char);
#3819      *len = sizeof(short);
#3824        *len = sizeof(long);
#3826        *len = sizeof(int);
#3829      *len = sizeof(float);
#3832      *len = sizeof(double);
#3836      *len = sizeof(long long);
#3839      *len = sizeof(char *);
#3850  *len = type->size;
#3928    ssize_t len;
#3931    len = H5Iget_name(idnameMAXNAME);
#3932    if(len < 0) return;
#3933    name[len] = '\0';
#3942 len = H5Aget_name(idMAXNAMEname);
#3943        if(len < 0) len = 0;
#3944 name[len] = '\0';
#4085    ssize_t len;
#4098        len = H5Gget_objname_by_idx(gid,(hsize_t)i,name,(size_t)NC_HDF5_MAX_NAME);
#4099        if(len < 0) return len;
#4118                    ssize_t len = H5Aget_name(aidNC_HDF5_MAX_NAMEname);
#4119                    if(len < 0) return len;
nc4info.c#49    size_t len;
#57    len = strlen(text);
#58    if(len == 0) return NC_NOERR;
#59    propdata = (char*)malloc(len+1);
#61    memcpy(propdata,text,len+1);
#62    propdata[len] = '\0'; /* guarantee */
nc4internal.c#496nc4_find_dim_len(NC_GRP_INFO_T *grp, int dimid, size_t **len)
#502   assert(grp && len);
#508      if ((retval = nc4_find_dim_len(gdimidlen)))
#521     **len = **len > mylen ? **len : mylen;
#1248      for (i = 0; i < att->leni++)
#1257      for (i = 0; i < att->leni++)
#1473    tabsatt->attnumatt->nameatt->nc_typeidatt->len));
#1477    tabsdim->dimiddim->namedim->lendim->unlimited));
#1496       tabsatt->attnumatt->nameatt->nc_typeidatt->len));
nc4internal.h#120   size_t len;
#135   int len;
#332 int is_long, size_t *len);
#335      const size_t len, int *range_error,
#366int nc4_find_dim_len(NC_GRP_INFO_T *grp, int dimid, size_t **len);
nc4type.c#728     size_t len, const void *data)
#731   tmp->len = len;
#739     size_t *len, void *data)
#744   *len = tmp->len;
#745   memcpy(datatmp->ptmp->len * type_size);
nc4var.c#259  num_values *= (float)var->dim[d]->len;
#296        1.0/(double)(var->ndims - num_unlim)) * var->dim[d]->len - .5);
#297  if (suggested_size > var->dim[d]->len)
#298     suggested_size = var->dim[d]->len;
#333       num_chunks = (var->dim[d]->len + var->chunksizes[d] - 1) / var->chunksizes[d];
#335    overhang = (num_chunks * var->chunksizes[d]) - var->dim[d]->len;
#920     if(var->dim[d]->len > 0 && chunksizes[d] > var->dim[d]->len)
ncbytes.h#54#define ncbytesextend(bb,lenncbytessetalloc((bb),(len)+(bb->alloc))
nccomps.h#93    size_t len;
nccopy.c#943 size_t len;
#944 NC_CHECK(nc_inq_dimlen(igrpdimids[dim], &len));
#945 nvals *= len;
ncd2dispatch.c#1212    int i,len;
#1257        if(sscanf(value,"%d",&len) && len > 0) dfaltseqlim = len;
#1264        if(sscanf(value,"%d",&len) && len > 0) dfaltstrlen = len;
#1279            if(sscanf(value,"%d",&len) && len > 0) var->maxstringlength = len;
#1296            if(sscanf(value,"%d",&len) && len > 0)
#1297 var->sequencelimit = len;
#2219NCD2_def_dim(int ncid, const char* name, size_t len, int* idp)
#2226    size_t len, const void* valuenc_type t)
ncd2dispatch.h#82NCD2_def_dim(int ncid, const char *name, size_t len, int *idp);
#123    size_t len, const void *valuenc_type);
ncdump.c#413    size_t len,
#425    sp = cp + len - 1;
#426    while (len != 0 && *sp-- == '\0')
#427 len--;
#428    for (iel = 0; iel < leniel++)
#483     size_t len,
#496    sp = cp + len - 1;
#497    while (len != 0 && *sp-- == '\0')
#498 len--;
#499    for (iel = 0; iel < leniel++)
#549    size_t len,
#572 pr_att_string(kindlencp);
#576    for (iel = 0; iel < leniel++) {
#577 if (iel == len - 1)
#674     size_t len,
#691    if (len == 0)
#693    for (iel = 0; iel < leniel++) {
#704     (void) strlcat(attvalsiel < len-1 ? " " : "", attvalslen);
#713     (void) strlcat(attvalsiel < len-1 ? " " : "", attvalslen);
#720     (void) strlcat(attvalsiel < len-1 ? " " : "", attvalslen);
#727     (void) strlcat(attvalsiel < len-1 ? " " : "", attvalslen);
#735     (void) strlcat(attvalsiel < len-1 ? " " : "", attvalslen);
#743     (void) strlcat(attvalsiel < len-1 ? " " : "", attvalslen);
#772    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#801    if (att.len == 0) { /* show 0-length attributes as empty strings */
#806 att.valgp = (void *) emalloc((att.len + 1) * att.tinfo->size );
#809     ((char *)att.valgp)[att.len] = '\0';
#811        pr_att_valgs(kindatt.typeatt.lenatt.valgp);
#826     nc_free_string(att.lenatt.valgp);
#847       data = emalloc((att.len + 1) * sizeof(nc_vlen_t));
#850       data = emalloc((att.len + 1) * type_size);
#854       data = emalloc((att.len + 1) * sizeof(int64_t));
#857       data = emalloc((att.len + 1) * type_size);
#873    for (i = 0; i < att.leni++) {
#875        printf("%s%s", souti < att.len-1 ? ", " : "");
#883    for (i = 0; i < att.leni++) {
#918        printf("%s", i < att.len-1 ? ", " : "");
#1085    size_t len;
#1092    stat = nc_inq_att(ncid,NC_GLOBAL,NCPROPS,NULL,&len);
#1094 char* propdata = (char*)malloc(len+1);
#1101            propdata[len] = '\0';
#1107    stat = nc_inq_att(ncid,NC_GLOBAL,SUPERBLOCKATT,NULL,&len);
#1108    if(stat == NC_NOERR && len == 1) {
#1117    stat = nc_inq_att(ncid,NC_GLOBAL,ISNETCDF4ATT,NULL,&len);
#1118    if(stat == NC_NOERR && len == 1) {
#1153    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#1159 attvals = (char *) emalloc(att.len + 1);
#1160 attvalslen = att.len;
#1161 attvals[att.len] = '\0';
#1168 attvals = (char *) emalloc(att.len + 1);
#1169 attvals[att.len] = '\0';
#1183 att.vals = (double *) emalloc((att.len + 1) * sizeof(double));
#1185 attvalslen = PRIM_LEN * att.len; /* max chars for each value and blank separator */
#1187 pr_att_valsx(att.typeatt.lenatt.valsattvalsattvalslen);
#1424    nc_status = nc_inq_att(ncid,varid,_FillValue,&att.type,&att.len);
#1427       att.type == vp->type && att.len == 1) {
#1714  size_t len;
#1716  NC_CHECKnc_inq_grpname_full(locid, &lenNULL) );
#1717  locname = emalloc(len + 1);
#1718  NC_CHECKnc_inq_grpname_full(locid, &lenlocname) );
#1798      size_t len;
#1799      NC_CHECKnc_inq_dimlen(ncidvar.dims[id], &len) );
#1800      if(len == 0) {
#1803      vdims[id] = len;
ncgen.h#53    size_t len;
ncgenl.c#322YY_BUFFER_STATE ncg_scan_bytes (yyconst char *bytes,yy_size_t len  );
#1610{int len;
#1623 len = unescape(bbContents(lextext),
#1625 if(len < 0) {
#1629 bbSetlength(lextext,len);
#1639 int len = ncgleng - 2;
#1641         bbAppendn(lextext,p,len);
#1642         if((len % 2) == 1) bbAppend(lextext,'0');
#1859{ char* id; int len;
#1864     len = unescape(id,id,bbLength(lextext),ISIDENT);
#1865     bbSetlength(lextext,len);
ncgentab.c#1843    size_t len = strlen(termstring);
#1844    if (len == 0) /* need null if that's only value */
#1845        len = 1;
#1846    (void)strncpy(char_valp,termstring,len);
#1847    valnum += len;
#1848    char_valp += len;
#2073    size_t len = strlen(termstring);
#2075    if(valnum + len > var_len) {
#2078   valnum+lenvar_len);
#2083    var_len += rec_len * (len + valnum - var_len)/rec_len;
#2094    (void)strncpy(char_valp,termstring,len);
#2098        for (i =len;i<sl;i++)
#2100        if (sl < len)
#2101    sl = len;
#2105        valnum += len;
#2106        char_valp += len;
#2580    atts[natts].len = valnum;
ncgeny.c#3100     size_t len;
#3101     len = bbLength(lextext);
#3102     con.value.stringv.len = len;
#3118     int len;
#3119     len = bbLength(lextext);
#3120     s = (char*)emalloc(len+1);
#3121     strncpy(s,bbContents(lextext),len);
#3122     s[len] = '\0';
#3124     con.value.opaquev.len = len;
#3138     con.value.stringv.len = 0;
ncgenyy.c#321YY_BUFFER_STATE ncg_scan_bytes (yyconst char *bytes,int len  );
nchashmap.c#64    size_t offset,len;
#71    len = nclistlength(seq);
#73    for(i=0;i<len;i+=2,list+=2) {
#88    size_t offset,len;
#95    len = nclistlength(seq);
#97    for(i=0;i<len;i+=2,list+=2) {
#112    size_t offset,len;
#119    len = nclistlength(seq);
#121    for(i=0;i<len;i+=2,list+=2) {
#147    size_t offset,len;
#154    len = nclistlength(seq);
#156    for(i=0;i<len;i+=2,list+=2) {
#171 int len = nclistlength(seq) / 2;
#172 if(len == 0) continue;
#173 if((index - len) < 0) {
#178 index -= len;
nciter.c#203 size_t len;
#204 NC_CHECK(nc_inq_dimlen(nciddimids[dim], &len));
#205 nvalues *= len;
#206 iterp->dimsizes[dim] = len;
nclist.c#135  unsigned long len;
#137  if(l == NULL || (len=l->length) == 0) return NULL;
#138  if(i >= len) return NULL;
#140  for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#169  unsigned long len;
#172  if(l == NULL || (len=l->length) == 0) return 0;
#176      for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#196    unsigned long i,j,k,len;
#199    len = l->length;
#201    for(i=0;i<len;i++) {
#202        for(j=i+1;j<len;j++) {
#205                for(k=j+1;k<len;k++) content[k-1] = content[k];
#206 len--;
#210    l->length = len;
nclist.h#58#define nclistextend(l,lennclistsetalloc((l),(len)+(l->alloc))
ncpdispatch.c#321NCP_def_dim(int ncid, const char* name, size_t len, int* idp)
#334    return ncmpi_def_dim(nc->int_ncidnamelenidp);
#482 size_t len,
#495    if(((unsigned long) len) > X_INT_MAX)
#501    mpilen = len;
#1439     size_t len, const void *data)
#1446     size_t *len, void *data)
nctime0.c#81    stat = nc_inq_att(ncidvaridCF_CAL_ATT_NAME, &catt.type, &catt.len);
#82    if(stat == NC_NOERR && catt.type == NC_CHAR && catt.len > 0) {
#83 char *calstr = (char *)emalloc(catt.len + 1);
#86 calstr[catt.len] = '\0';
#88     if(strncmp(calstrcalmap[itype].attnamecatt.len) == 0) {
#206    nc_status = nc_inq_att(ncidvarid, "units", &uatt.type, &uatt.len);
#208 units = emalloc(uatt.len + 1);
#210 units[uatt.len] = '\0';
#295    assert (att->len > 0); /* should already be eliminated by caller */
#328 for (iel = 0; iel < att->leniel++) {
#331     if (iel < att->len - 1) /* add comma, except for final value */
#336            wrap = (att->len > 2); /* specify line wrap variations:     */
ncuri.c#71ncstrndup(const char* s, size_t len)
#75    dup = (char*)malloc(len+1);
#77    memcpy((void*)dup,s,len);
#78    dup[len] = '\0';
#447    size_t len = 0;
#470    if(prefix != NULLlen += NILLEN(prefix);
#471    len += (NILLEN(duri->protocol)+NILLEN("://"));
#473 len += (NILLEN(duri->user)+NILLEN(duri->password)+NILLEN(":@"));
#475    len += (NILLEN(duri->host));
#477 len += (NILLEN(":")+NILLEN(duri->port));
#483    len += (NILLEN(tmpfile));
#489        len += (NILLEN(tmpsuffix));
#496        len += (NILLEN("?")+NILLEN(tmpquery));
#511 len += paramslen;
#512 len += 3*nparams; /* for brackets for every param plus possible = */
#514     len += strlen("#");
#517    len += 1; /* null terminator */
#519    newuri = (char*)malloc(len);
netcdf.h#667    size_t len; /**< Length of VL data (in base type units) */
#694nc_free_vlens(size_t lennc_vlen_t vlens[]);
#699     size_t len, const void *data);
#703     size_t *len, void *data);
#710nc_free_string(size_t len, char **data);
#720    size_t len, const void *op);
#947nc_def_dim(int ncid, const char *name, size_t len, int *idp);
#996 size_t len, const char *op);
#1003   size_t len, const char **op);
#1010  size_t len, const unsigned char *op);
#1017  size_t len, const signed char *op);
#1024  size_t len, const short *op);
#1031        size_t len, const int *op);
#1038 size_t len, const long *op);
#1045  size_t len, const float *op);
#1052   size_t len, const double *op);
#1059   size_t len, const unsigned short *op);
#1066 size_t len, const unsigned int *op);
#1073  size_t len, const long long *op);
#1080      size_t len, const unsigned long long *op);
#1681  size_t len, const unsigned char *op);
#1864ncdimdef(int ncid, const char *name, long len);
#1877 int len, const void *op);
ocbytes.h#54#define ocbytesextend(bb,lenocbytessetalloc((bb),(len)+(bb->alloc))
occompile.c#348     unsigned int len;
#352     if(!xxdr_uint(xxdrs,&len)) {ocstat = OC_EXDR; goto fail;}
#353     lenz = (off_t)len;
occurlflags.c#256  size_t len = 0;
#272    len = maxflag;
#273    if(maxflag == -1) len += 2; else len += 1;
#274    flagindices = (struct OCCURLFLAG**)calloc(1,len*sizeof(struct OCCURLFLAG*));
ocdata.c#402     off_t len;
#406     if(!xxdr_string(xdrs,sp,&len))
ocdump.c#53    int bol,len,pad;
#54    len = ocbyteslength(buffer);
#56    for(bol=len-1;;bol--) {
#61    len = (len - bol);
#62    pad = (pos - len);
#246    int len,rem;
#249    len = strlen(field);
#250    rem = (align - len);
#327typedmemorydump(char* memory, size_t len, int fromxdr)
#334    assert(memory[len] == 0);
#348    count = (len / sizeof(int));
#349    rem = (len % sizeof(int));
#368simplememorydump(char* memory, size_t len, int fromxdr)
#375    assert(memory[len] == 0);
#384    count = (len / sizeof(int));
#385    rem = (len % sizeof(int));
#407ocdumpmemory(char* memory, size_t len, int xdrencoded, int level)
#412        typedmemorydump(memory,len,xdrencoded);
#416        simplememorydump(memory,len,xdrencoded);
#425    size_t len;
#450    len = stats.st_size;
#451    len -= datastart;
#453    mem = (char*)calloc(len+1,1);
#457    red = fread(mem,1,len,file);
#458    if(red < len) {
#470    if(lenp) *lenp = len;
#482    size_t len;
#487                       &len)) {
#493        ocdumpmemory(mem,len,xdrencoded,level);
#498        len = root->tree->data.datasize;
#499        len -= root->tree->data.bod;
#500        ocdumpmemory(mem,len,xdrencoded,level);
ocdump.h#12extern void ocdumpmemory(char* memory, size_t len, int xdrencoded, int level);
ochttp.c#97 size_t len;
#155 len = ocbyteslength(buf);
#157 ocbytessetlength(buflen); /* dont count null in buffer size*/
#241 len = strlen(url);
#242 encoded = ocmalloc(len*4+1); /* should never be larger than this*/
ocinternal.c#381    int len;
#383    len =
#387    path = (char*)malloc(len+1);
#389    occopycat(path,len,3,ocglobalstate.tempdir,"/",DATADDSFILE);
#545    size_t len;
#551    len = strlen(url);
#552    eurl = ocmalloc(1+3*len); /* worst case: c -> %xx */
#598        size_t len = strlen(DFALTUSERAGENT) + strlen(VERSION) + 1;
#599 char* agent = (char*)malloc(len+1);
#600 if(occopycat(agent,len,2,DFALTUSERAGENT,VERSION))
oclist.c#135  size_t len;
#137  if(l == NULL || (len=l->length) == 0) return NULL;
#138  if(i >= len) return NULL;
#140  for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#172  size_t len;
#175  if(l == NULL || (len=l->length) == 0) return 0;
#179      for(i+=1;i<len;i++) l->content[i-1] = l->content[i];
#199    size_t i,j,k,len;
#202    len = l->length;
#204    for(i=0;i<len;i++) {
#205        for(j=i+1;j<len;j++) {
#208                for(k=j+1;k<len;k++) content[k-1] = content[k];
#209 len--;
#213    l->length = len;
oclist.h#58#define oclistextend(l,lenoclistsetalloc((l),(len)+(l->alloc))
ocnode.c#82    int slen,i,len;
#85    len = oclistlength(path);
#86    if(len == 0) return NULL;
#87    for(i=0,slen=0;i<len;i++) {
#92    slen += ((len-1)*strlen(separator));
#97    for(i=0;i<len;i++) {
#392     size_t len =   strlen(attnode->name)
#396     char* newname = (char*)malloc(len);
ocrc.c#68    int len = 0;
#73 len += strlen(uri->host);
#75 len += strlen(uri->port);
#76    hp = (char*)malloc(len+1);
#80        occopycat(hp,len+1,1,uri->host);
#82        occopycat(hp,len+1,3,uri->host,":",uri->port);
#128    size_t len;
#131    len = strlen(text);
#137    len = strlen(text);
#139    if(len > 0) {
#140        for(i=(len-1);i>=0;i--) {
ocread.c#180    size_t len;
#189    len = oclistlength(packet);
#193 written = fwrite(ocbytescontents(packet),1,len,stream);
#194 if(written != len) {
#197 (unsigned long)written,(unsigned long)len);
#202    if(sizep != NULL) *sizep = len;
ocuri.c#441    size_t len = 0;
#464    if(prefix != NULLlen += NILLEN(prefix);
#465    len += (NILLEN(duri->protocol)+NILLEN("://"));
#467 len += (NILLEN(duri->userpwd)+NILLEN("@"));
#468    len += (NILLEN(duri->host));
#470 len += (NILLEN(":")+NILLEN(duri->port));
#476    len += (NILLEN(tmpfile));
#482        len += (NILLEN(tmpsuffix));
#489        len += (NILLEN("?")+NILLEN(tmpquery));
#504 len += paramslen;
#505 len += 3*nparams; /* for brackets for every param plus possible = */
#507     len += strlen("#");
#510    len += 1; /* null terminator */
#512    newuri = (char*)malloc(len);
ocutil.c#28ocstrndup(const char* s, size_t len)
#32    dup = (char*)ocmalloc(len+1);
#34    memcpy((void*)dup,s,len);
#35    dup[len] = '\0';
#42ocstrncmp(const char* s1, const char* s2, size_t len)
#48    for(p=s1,q=s2;len > 0;p++,q++,len--) {
#137    size_t len = ocbyteslength(buffer);
#145        for(i=0;i<len;i++) {
#146     if((i+tlen) <= len
#431    size_t len;
#439    len = xxdr_length(xdrs);
#440    if(len < strlen(ERRTAG))
#445    contents = (char*)malloc(len+1);
#446    (void)xxdr_getbytes(xdrs,contents,(off_t)len);
#447    contents[len] = '\0';
#449    for(i=0;i<len;i++) {
#453     for(j=i;j<len;j++) {
ocutil.h#12extern char* ocstrndup(const char* s, size_t len);
#13extern int ocstrncmp(const char* s1, const char* s2, size_t len);
offsets.c#42    size_t len;
#204    int len = strlen(name);
#205    if(len > MAXlen = MAX;
#209    strncpy(s,name,len);
posixio.c#192fgrow(const int fd, const off_t len)
#197 if (len < sb.st_size)
#206     if (lseek(fdlen-sizeof(dumb), SEEK_SET) < 0)
#223fgrow2(const int fd, const off_t len)
#238  if(len <= file_len)
#247     if (lseek(fdlen-1, SEEK_SET) < 0)
putget.c#516 const int status = fill_NC_var(ncp, *varpp, (*varpp)->lenrecno);
#573 + (off_t)(varp->len - varp->xsz);
#9531 if(varp->ndims == 1 && ncp->recsize <= varp->len)
#10380        if(varp->ndims == 1 && nc3->recsize <= varp->len)
#10513            && nc3->recsize <= varp->len)
rec.c#74 long len;
#75 (void) ncdiminq(nciddimids[id], 0, &len);
#76 size *= len;
semantics.c#534 int len;
#544 len = strlen(en->name);
#545 if(strncmp(ident,en->name,len) == 0) {
#548     if(*(ident+len) != '.') continue;
#549     ec = checkeconst(en,ident+len+1); /* +1 for the dot */
#1131     length += con->value.stringv.len;
t_dap.c#114    size_t len;
#129    len = strlen("file://") + strlen(topsrcdir) + strlen("/ncdap_test/testdata3/test.02") + 1;
#131    len += strlen("[log][show=fetch]");
#133    url = (char*)malloc(len);
t_dap3a.c#115    size_t len;
#130    len = strlen("file://") + strlen(topsrcdir) + strlen("/ncdap_test/testdata3/test.02") + 1;
#132    len += strlen("[log][show=fetch]");
#134    url = (char*)malloc(len);
t_nc.c#60 size_t len;
#504 assert( nc_inq_att(idNC_GLOBALadesc->mnem, &(adesc->type), &(adesc->len))== NC_NOERR);
#506 assert( adesc->len == strlen(fname) );
#508 buf[adesc->len] = 0;
#560 if( nc_inq_att(idiireqattr[0], &(adesc->type), &(adesc->len))
#563 assert( adesc->len == strlen(tvp->units) );
#565 buf[adesc->len] = 0;
#570 nc_inq_att(idiireqattr[1], &(adesc->type), &(adesc->len))
#574 assert( adesc->len == 1 );
#580 nc_inq_att(idiireqattr[2], &(adesc->type), &(adesc->len))
#584 assert( adesc->len == 1 );
#590 nc_inq_att(idiireqattr[3], &(adesc->type), &(adesc->len))
#594 assert( adesc->len ==1 );
#600 nc_inq_att(idiireqattr[4], &(adesc->type), &(adesc->len))
#604 assert( adesc->len == 1 );
#609 if( nc_inq_att(idiireqattr[5], &(adesc->type), &(adesc->len))== NC_NOERR)
#612 assert( adesc->len == strlen(tvp->fieldnam) );
#614 buf[adesc->len] = 0;
test_cvt.c#114    size_t len;
#129    len = strlen("file://") + strlen(topsrcdir) + strlen("/ncdap_test/testdata3/test.02") + 1;
#131    len += strlen("[log][show=fetch]");
#133    url = (char*)malloc(len);
test_read.c#1460    size_t len;
#1467 err = nc_inq_attlen(ncidi, "noSuch", &len);
#1471            err = nc_inq_attlen(BAD_IDiATT_NAME(i,j), &len);
#1474            err = nc_inq_attlen(ncidBAD_VARIDATT_NAME(i,j), &len);
#1477            err = nc_inq_attlen(ncidiATT_NAME(i,j), &len);
#1481 IF (len != ATT_LEN(i,j))
testcdf.h#36    int len;
tst_ar4.c#98   size_t len;
#158   if (nc_inq_dim(ncidLON_DIMIDname_in, &len)) ERR;
#159   if (strcmp(name_in, "lon") || len != LON_LENERR;
#160   if (nc_inq_dim(ncidLAT_DIMIDname_in, &len)) ERR;
#161   if (strcmp(name_in, "lat") || len != LAT_LENERR;
#162   if (nc_inq_dim(ncidBNDS_DIMIDname_in, &len)) ERR;
#163   if (strcmp(name_in, "bnds") || len != BNDS_LENERR;
#164   if (nc_inq_dim(ncidTIME_DIMIDname_in, &len)) ERR;
#165   if (strcmp(name_in, "time") || len != TIME_LENERR;
tst_ar4_3d.c#106   size_t len;
#166   if (nc_inq_dim(ncidLON_DIMIDname_in, &len)) ERR;
#167   if (strcmp(name_in, "lon") || len != LON_LENERR;
#168   if (nc_inq_dim(ncidLAT_DIMIDname_in, &len)) ERR;
#169   if (strcmp(name_in, "lat") || len != LAT_LENERR;
#170   if (nc_inq_dim(ncidBNDS_DIMIDname_in, &len)) ERR;
#171   if (strcmp(name_in, "bnds") || len != BNDS_LENERR;
#172   if (nc_inq_dim(ncidTIME_DIMIDname_in, &len)) ERR;
#173   if (strcmp(name_in, "time") || len != TIME_LENERR;
tst_ar4_4d.c#212   size_t len;
#276   if (nc_inq_dim(ncidLON_DIMIDname_in, &len)) ERR;
#277   if (strcmp(name_in, "lon") || len != LON_LENERR;
#278   if (nc_inq_dim(ncidLAT_DIMIDname_in, &len)) ERR;
#279   if (strcmp(name_in, "lat") || len != LAT_LENERR;
#280   if (nc_inq_dim(ncidDEPTH_DIMIDname_in, &len)) ERR;
#281   if (strcmp(name_in, "depth") || len != DEPTH_LENERR;
#282   if (nc_inq_dim(ncidBNDS_DIMIDname_in, &len)) ERR;
#283   if (strcmp(name_in, "bnds") || len != BNDS_LENERR;
#284   if (nc_inq_dim(ncidTIME_DIMIDname_in, &len)) ERR;
#285   if (strcmp(name_in, "time") || len != TIME_LENERR;
tst_atts1.c#86   int len[NUM_ATTS] = {0, 2, 3, 3, 3, 3, 1, 1};
#98   if (nc_put_att_text(ncidNC_GLOBALname[0], len[0], NULL)) ERR;
#99   if (nc_put_att_schar(ncidNC_GLOBALname[1], NC_BYTElen[1], b)) ERR;
#100   if (nc_put_att_short(ncidNC_GLOBALname[2], NC_SHORTlen[2], s)) ERR;
#101   if (nc_put_att_int(ncidNC_GLOBALname[3], NC_INTlen[3], i)) ERR;
#102   if (nc_put_att_float(ncidNC_GLOBALname[4], NC_FLOATlen[4], f)) ERR;
#103   if (nc_put_att_double(ncidNC_GLOBALname[5], NC_DOUBLElen[5], d)) ERR;
#104   if (nc_put_att_int(ncidNC_GLOBALname[6], NC_INTlen[6], &att_name_dashes)) ERR;
#105   if (nc_put_att_int(ncidNC_GLOBALname[7], NC_INTlen[7], &att_name_dots)) ERR;
#708      size_t len;
#713      if (nc_inq_att(ncidNC_GLOBALATT_TEXT_NAME, &xtype, &len)) ERR;
#714      if (len || xtype != NC_CHARERR;
#716      if (nc_inq_att(ncidNC_GLOBALATT_SCHAR_NAME, &xtype, &len)) ERR;
#717      if (len || xtype != NC_BYTEERR;
#719      if (nc_inq_att(ncidNC_GLOBALATT_UCHAR_NAME, &xtype, &len)) ERR;
#720      if (len || xtype != NC_UBYTEERR;
#722      if (nc_inq_att(ncidNC_GLOBALATT_SHORT_NAME, &xtype, &len)) ERR;
#723      if (len || xtype != NC_SHORTERR;
#725      if (nc_inq_att(ncidNC_GLOBALATT_INT_NAME, &xtype, &len)) ERR;
#726      if (len || xtype != NC_INTERR;
#728      if (nc_inq_att(ncidNC_GLOBALATT_FLOAT_NAME, &xtype, &len)) ERR;
#729      if (len || xtype != NC_FLOATERR;
#731      if (nc_inq_att(ncidNC_GLOBALATT_DOUBLE_NAME, &xtype, &len)) ERR;
#732      if (len || xtype != NC_DOUBLEERR;
tst_atts3.c#90   int len[NUM_ATTS] = {0, 2, 3, 3, 3, 3, 1, 1};
#106   if (nc_put_att_text(ncidNC_GLOBALname[0], len[0], NULL)) ERR;
#107   if (nc_put_att_schar(ncidNC_GLOBALname[1], NC_BYTElen[1], b)) ERR;
#108   if (nc_put_att_short(ncidNC_GLOBALname[2], NC_SHORTlen[2], s)) ERR;
#109   if (nc_put_att_int(ncidNC_GLOBALname[3], NC_INTlen[3], i)) ERR;
#110   if (nc_put_att_float(ncidNC_GLOBALname[4], NC_FLOATlen[4], f)) ERR;
#111   if (nc_put_att_double(ncidNC_GLOBALname[5], NC_DOUBLElen[5], d)) ERR;
#112   if (nc_put_att_int(ncidNC_GLOBALname[6], NC_INTlen[6], &att_name_dashes)) ERR;
#113   if (nc_put_att_int(ncidNC_GLOBALname[7], NC_INTlen[7], &att_name_dots)) ERR;
#445      size_t len;
#454      if (nc_inq_att(ncidNC_GLOBALATT_TEXT_NAME, &xtype, &len)) ERR;
#455      if (len || xtype != NC_CHARERR;
#457      if (nc_inq_att(ncidNC_GLOBALATT_SCHAR_NAME, &xtype, &len)) ERR;
#458      if (len || xtype != NC_BYTEERR;
#460      if (nc_inq_att(ncidNC_GLOBALATT_SHORT_NAME, &xtype, &len)) ERR;
#461      if (len || xtype != NC_SHORTERR;
#463      if (nc_inq_att(ncidNC_GLOBALATT_INT_NAME, &xtype, &len)) ERR;
#464      if (len || xtype != NC_INTERR;
#466      if (nc_inq_att(ncidNC_GLOBALATT_FLOAT_NAME, &xtype, &len)) ERR;
#467      if (len || xtype != NC_FLOATERR;
#469      if (nc_inq_att(ncidNC_GLOBALATT_DOUBLE_NAME, &xtype, &len)) ERR;
#470      if (len || xtype != NC_DOUBLEERR;
tst_compounds.c#245      size_t sizelen;
#295      if (nc_inq_att(ncidNC_GLOBALSERVICE_RECORD, &xtype, &len)) ERR;
#296      if (len != 3) ERR;
#497      size_t sizelen;
#595      if (nc_inq_att(ncidNC_GLOBAL, "HR_Records", &xtype, &len)) ERR;
#596      if (len != DIM_LENERR;
#833      size_t len;
#886      if (nc_inq_att(ncidNC_GLOBAL, "HR_Records", &xtype, &len)) ERR;
#887      if (len != DIM1_LENERR;
#899      size_t len;
#955      if (nc_inq_att(ncidNC_GLOBAL, "HR_Records", &xtype, &len)) ERR;
#956      if (len != DIM1_LENERR;
tst_compounds2.c#27      size_t len;
#82      if (nc_inq_att(ncidNC_GLOBAL, "a1", &xtype, &len)) ERR;
#83      if (len != DIM1_LENERR;
#96      size_t len;
#147      if (nc_inq_att(ncidNC_GLOBAL, "a1", &xtype, &len)) ERR;
#148      if (len != DIM1_LENERR;
#176      size_t len;
#250      if (nc_inq_att(ncidNC_GLOBALATT_NAME, &outer_typeid, &len)) ERR;
#251      if (len != DIM1_LENERR;
tst_create_files.c#205  data[i].len = i+1;
tst_create_files.c#104       size_t len;
#126       if (nc_inq_dim(ncid, 0, name_in, &len)) ERR;
#127       if (strcmp(name_inDIM_NAME) || len != DIMLENERR;
#150       size_t len;
#178      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
#181 if (nc_def_dim(nciddim_namelen, &dimids[d])) ERR;
#262       size_t len;
#290      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
#293 if (nc_def_dim(nciddim_namelen, &dimids[d])) ERR;
tst_dims3.c#39      size_t len;
#61      if (nc_inq_dimlen(ncidtime_dim, &len)) ERR;
#62      if (len != NUM_TIMESERR;
#65      if (nc_inq_dimlen(grpidtime_dim, &len)) ERR;
#66      if (len != NUM_TIMESERR;
#75      if (nc_inq_dimlen(ncidtime_dim, &len)) ERR;
#76      if (len != NUM_TIMESERR;
#79      if (nc_inq_dimlen(grpidtime_dim, &len)) ERR;
#80      if (len != NUM_TIMESERR;
tst_empty_vlen_unlim.c#107    data[0].len = VLEN0;
#110    data[1].len = VLEN1;
#113    data[2].len = VLEN2;
#199    data[0].len = VLEN0;
#202    data[1].len = VLEN1;
#205    data[2].len = VLEN2;
tst_fileinfo.c#79 size_t len;
#114 if(nc_inq_att(root,NC_GLOBAL,NCPROPS,&xtype,&len)!=0) ERR;
#119 if(strlen(ncprops) != lenERR;
#129 if(nc_inq_attlen(root,NC_GLOBAL,NCPROPS,&len)!=0) ERR;
#130 if(len != strlen(ncprops)) ERR;
#143 if(nc_inq_att(root,NC_GLOBAL,SUPERBLOCKATT,&xtype,&len)!=0) ERR;
#145 if(len != 1) ERR;
#156 if(nc_inq_attlen(root,NC_GLOBAL,SUPERBLOCKATT,&len)!=0) ERR;
#157 if(len != 1) ERR;
#170 if(nc_inq_att(root,NC_GLOBAL,ISNETCDF4ATT,&xtype,&len)!=0) ERR;
#172 if(len != 1) ERR;
#183 if(nc_inq_attlen(root,NC_GLOBAL,ISNETCDF4ATT,&len)!=0) ERR;
#184 if(len != 1) ERR;
tst_fillbug.c#87 size_t dimsizelen;
#141 if( nc_inq_dimlen(ncidvardims[id], &len) ) ERR;
#142 vdims[id] = len;
tst_grps.c#231      size_t len;
#243      if (nc_inq_grpname_full(ncid, &lenfull_name_in)) ERR;
#244      if (len != 1 || strcmp(full_name_infull_name)) ERR;
#245      if (nc_inq_grpname_len(ncid, &len)) ERR;
#246      if (len != 1) ERR;
#259      if (nc_inq_grpname_full(grpid_in[0], &lenfull_name_in)) ERR;
#260      if (len != strlen(HENRY_VII) + 1 || strcmp(full_name_infull_name)) ERR;
#272      if (nc_inq_grpname_full(grpid_in[0], &lenfull_name_in)) ERR;
#273      if (len != strlen(full_name) || strcmp(full_name_infull_name)) ERR;
#285      if (nc_inq_grpname_full(grpid_in[0], &lenfull_name_in)) ERR;
#286      if (len != strlen(full_name) || strcmp(full_name_infull_name)) ERR;
#298      if (nc_inq_grpname_full(grpid_in[0], &lenfull_name_in)) ERR;
#299      if (len != strlen(full_name) || strcmp(full_name_infull_name)) ERR;
#311      if (nc_inq_grpname_full(grpid_in[0], &lenfull_name_in)) ERR;
#312      if (len != strlen(full_name) || strcmp(full_name_infull_name)) ERR;
tst_h_atts3.c#71     cvc_out[i].data[j].len = i + 1;
#72     if (!(cvc_out[i].data[j].p = calloc(sizeof(struct s1), cvc_out[i].data[j].len))) ERR;
#73     for (k = 0; k < cvc_out[i].data[j].lenk++)
#215  vc_out[i].len = i + 1;
#216  if (!(vc_out[i].p = calloc(sizeof(int), vc_out[i].len))) ERR;
#217  for (k = 0; k < vc_out[i].lenk++)
tst_h_atts4.c#71  vc_out[i].len = i + 1;
#72  if (!(vc_out[i].p = calloc(sizeof(struct s1), vc_out[i].len))) ERR;
#73  for (k = 0; k < vc_out[i].lenk++)
tst_h_scalar.c#98    size_t len;
#112    if (nc_inq_attlen(ncidobjVSTR_ATT1_NAME, &len)) ERR_GOTO;
#113    if (len != 1) ERR_GOTO;
#122    if (nc_inq_attlen(ncidobjVSTR_ATT2_NAME, &len)) ERR_GOTO;
#123    if (len != 1) ERR_GOTO;
#132    if (nc_inq_attlen(ncidobjVSTR_ATT3_NAME, &len)) ERR_GOTO;
#133    if (len != 1) ERR_GOTO;
#143    if (nc_inq_attlen(ncidobjVSTR_ATT4_NAME, &len)) ERR_GOTO;
#144    if (len != 1) ERR_GOTO;
#154    if (nc_inq_attlen(ncidobjFSTR_ATT_NAME, &len)) ERR_GOTO;
#155    if (len != 10) ERR_GOTO;
#164    if (nc_inq_attlen(ncidobjINT_ATT_NAME, &len)) ERR_GOTO;
#165    if (len != 1) ERR_GOTO;
#268        size_t len;
tst_h_strbug.c#133 size_t len;
#136 if (nc_inq_att(ncidNC_GLOBALVS_ATT_NAME, &type, &len)) ERR;
#138 if (len != 1) ERR;
#150 size_t len;
#153 if (nc_inq_att(ncidNC_GLOBALFS_ATT_NAME, &type, &len)) ERR;
#155 if (len != FSTR_LENERR;
#156 if (!(data_in = malloc(len))) ERR;
tst_h_vl.c#37  data[i].len = i+1;
#73  if (data[i].len != i+1) ERR;
tst_knmi.c#83   size_t len;
tst_nofill.c#429        size_t len;
#430        if (nc_inq_dimlen(ncid1dimids[dim], &len)) ERR;
#431        nvals *= len;
tst_parallel3.c#777   int len = -1;
#791  len = strlen(env);
#792  MPI_Bcast(&len, 1, MPI_INTrootcomm);
#793  MPI_Bcast(envlenMPI_CHARrootcomm);
#797  MPI_Bcast(&len, 1, MPI_INTrootcomm);
#801      MPI_Bcast(&len, 1, MPI_INTrootcomm);
#802      if(len >= 0)
#805     env = (char*) malloc(len+1);
#806  else if(strlen(env) < len)
#807     env = (char*) realloc(envlen+1);
#809  MPI_Bcast(envlenMPI_CHARrootcomm);
#810  env[len] = '\0';
tst_vl.c#51  data[i].len = i+1;
#76  if (data_in[i].len != i + 1) ERR;
#77  for (j = 0; j < data_in[i].lenj++)
#123  data[i].len = i+1;
#142  for (j=0; j<data_in[i].lenj++)
#177  data[i].len = i+1;
#200  if (data_in[i].len != i + 1) ERR;
#201  for (j = 0; j < data_in[i].lenj++)
tst_vlen_data.c#63   missing_val.len = 1;
#82       ragged_data[i].len = NROWS - i;
#114   if (val_in.len != ATT5_LENERR;
#126       if (val_in.len != NROWS - iERR;
#128       for (j = 0; j < val_in.lenj++) {
#143    for (j = 0; j < vals_in[i].lenj++) {
tst_xplatform2.c#99      if (data_in[i].len != data_out[i].lenERR;
#100      for (j = 0; j < data_in[i].lenj++)
#212  if (data_in[i].data[j].len != data_in[i].data[j].lenERR;
#213  for (k = 0; k < data_out[i].data[j].lenk++)
#276  if (data_in[i].data[j].len != data_in[i].data[j].lenERR;
#277  for (k = 0; k < data_out[i].data[j].lenk++)
#309      vlen_of_comp_out[i].len = i + 1;
#310      if (!(vlen_of_comp_out[i].p = malloc(sizeof(struct s1) * vlen_of_comp_out[i].len)))
#312      for (j = 0; j < vlen_of_comp_out[i].lenj++)
#333  comp_array_of_vlen_of_comp_out[i].data[j].len = i + 1;
#334  if (!(comp_array_of_vlen_of_comp_out[i].data[j].p = malloc(sizeof(struct s1) * comp_array_of_vlen_of_comp_out[i].data[j].len)))
#336  for (k = 0; k < comp_array_of_vlen_of_comp_out[i].data[j].lenk++)
util.c#15    int len = (s1?strlen(s1):0)+(s2?strlen(s2):0);
#16    char* result = (char*)emalloc(len+1);
#415    int len,i;
#416    if((len=listlength(x1)) != listlength(x2)) return 0;
#419    for(i=0;i<len;i++) {
#542 if(con->value.stringv.len > 0 && con->value.stringv.stringv != NULL)
#546 if(con->value.opaquev.len > 0 && con->value.opaquev.stringv != NULL)
utils.c#424 size_t len; /* length of full group name for grpid */
#427 if ( (status = nc_inq_grpname_full(grpid, &lenNULL)) != NC_NOERR ) {
#431 groupname = (char *)emalloc(len + 1);
#432 if ( (status = nc_inq_grpname_full(grpid, &lengroupname)) == NC_NOERR ) {
utils.h#26    size_t len; /* current length of buffer */
v1hpg.c#964 status = v1h_put_size_t(psp, &varp->len);
#1028 status = v1h_get_size_t(gsp, &varp->len);
#1220 if((*vpp)->len == UINT32_MAX &&
#1224     ncp->recsize += (*vpp)->len;
#1234 ncp->begin_rec = (*vpp)->begin + (off_t)(*vpp)->len;
#1246 if(ncp->recsize == first_rec->len)
val.c#17val_fill(typelenvals)
#19     long len; /* number of elements to fill with */
#23    long half = len/2;
#37 for (iel = 0; iel < leniel++)
#42 for (iel = 0; iel < leniel++)
#47 for (iel = 0; iel < leniel++)
#52 for (iel = 0; iel < leniel++)
#57 for (iel = 0; iel < leniel++)
#68val_fill_zero(typelenvals)
#70     long len; /* number of elements to fill with */
#87 for (iel = 0; iel < leniel++)
#92 for (iel = 0; iel < leniel++)
#97 for (iel = 0; iel < leniel++)
#102 for (iel = 0; iel < leniel++)
#107 for (iel = 0; iel < leniel++)
#122val_cmp (typelenv1v2)
#124     long len; /* number of elements of type to compare */
#143 for (iel = 0; iel < leniel++) {
#153 for (iel = 0; iel < leniel++) {
#163 for (iel = 0; iel < leniel++) {
#173 for (iel = 0; iel < leniel++) {
#183 for (iel = 0; iel < leniel++) {
#199val_out(typelenvals)
#201     long len; /* number of elements to fill with */
#219 for (iel = 0; iel < leniel++)
#220   (void)fprintf(stderr,"%d%s",*gp.cp++,iel<len-1 ? ", " : "");
#224 for (iel = 0; iel < leniel++)
#225   (void)fprintf(stderr,"%d%s",*gp.sp++,iel<len-1 ? ", " : "");
#229 for (iel = 0; iel < leniel++)
#230   (void)fprintf(stderr,"%d%s",*gp.lp++,iel<len-1 ? ", " : "");
#234 for (iel = 0; iel < leniel++)
#235   (void)fprintf(stderr,"%g%s",*gp.fp++,iel<len-1 ? ", " : "");
#239 for (iel = 0; iel < leniel++)
#240   (void)fprintf(stderr,"%g%s",*gp.dp++,iel<len-1 ? ", " : "");
var.c#110 varp->len = 0;
#175 varp->len = rvarp->len;
#481         varp->len = product * varp->xsz;
#487         if( varp->len%4 != 0 )
#489         varp->len += 4 - varp->len%4; /* round up */
#499         varp->len = X_UINT_MAX;
vardata.c#44set_max_len(int len) {
#45    max_line_len = len-2;
#223    size_t len = ap->len; /* number of values to print */
#227    for (iel = 0; iel < len - 1; iel++) {
#230 sbuf_cat(sbiel == len - 1 ? "" : ", ");
#325     size_t len, /* number of values to print */
#335    sp = vals + len;
#336    while (len != 0 && *--sp == '\0')
#337 len--;
#338    for (iel = 0; iel < leniel++) {
#616     size_t len, /* number of values to print */
#630    sp = vals + len;
#631    while (len != 0 && *--sp == '\0')
#632 len--;
#633    for (iel = 0; iel < leniel++) {
#682     size_t len, /* number of values to print */
#695    for (iel = 0; iel < len-1; iel++) {
vardata.h#32extern void set_max_len ( int len );
xxdr.c#176    unsigned int len;
#177    if(!xxdr_uint(xdrs,&len)) return 0;
#178    s = (char*)malloc((size_t)len+1);
#180    if(!xxdr_opaque(xdrs,s,(off_t)len)) {
#184    s[len] = '\0'; /* make sure it is null terminated */
#186    if(lenp) *lenp = len;
#223xxdr_skip(XXDRxdrsoff_t len)
#227    pos = (pos + len);
#280xxdr_filegetbytes(XXDRxdrs, char* addroff_t len)
#285xxdrtrace(xdrs,"getbytes",len);
#286    if(len < 0) len = 0;
#295    if(xdrs->pos + len > xdrs->length)
#297    if(len > 0) {
#298        count = fread(addr, (size_t)len, (size_t)1, (FILE*)xdrs->data);
#304    xdrs->pos += len;
#386xxdr_memgetbytes(XXDRxdrs, char* addroff_t len)
#390xxdrtrace(xdrs,"getbytes",len);
#391    if(len < 0) len = 0;
#392    if(xdrs->pos+len > xdrs->length) {ok=0; goto done;}
#393    if(len > 0) {
#394        memcpy(addr,(char*)xdrs->data+xdrs->base+xdrs->pos, (size_t)len);
#396    xdrs->pos += len;
xxdr.h#185extern int xxdr_skip(XXDRxdrsoff_t len); /* WARNING: will skip exactly len bytes;


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