bm_file.c#264   void *data = NULL, *data2 = NULL;
#400      if (!(data = malloc(slice_len * type_size)))
#413  if (nc_get_vara(ncid1vstartcountdata)) ERR;
#435     if (memcmp(datadata2slice_len * type_size))
#444      if (data) free(data);
#642      void *data = NULL;
#704      if (!(data = malloc(slice_len * type_size)))
#724  if ((ret = nc_get_vara(ncid_invstartcountdata)))
#746     if ((ret = nc_put_vara(ncid_outvstartcountdata)))
#770      if (data) free(data);
bm_many_atts.c#29    int data[] = {42};
#63     if (nc_put_att_int(grpNC_GLOBALanameNC_INT, 1, data)) ERR;
bm_many_objs.c#27    int data[] = {42};
#53 if(nc_put_var(grpvardata)) ERR;
#85     if(nc_put_var(grpvardata)) ERR;
bm_netcdf4_recs.c#28    int data[] = {42};
cdm_sea_soundings.c#25   } data[DIM_LEN];
#31      if (!(data[i].temp_vl.p = malloc(sizeof(float) * (i + 1))))
#34  ((float *)(data[i].temp_vl.p))[j] = 23.5 - j;
#35      data[i].temp_vl.len = i + 1;
#63   if (nc_put_var(ncidvariddata)) ERR;
#72       free(data[i].temp_vl.p);
dapdump.c#152dumpdata1(nc_type nctype, size_t index, char* data)
#156 fprintf(stdout,"'%c' %hhd",data[index],data[index]);
#159 fprintf(stdout,"%hdB",((signed char*)data)[index]);
#162 fprintf(stdout,"%huB",((unsigned char*)data)[index]);
#165 fprintf(stdout,"%hdS",((short*)data)[index]);
#168 fprintf(stdout,"%hdUS",((unsigned short*)data)[index]);
#171 fprintf(stdout,"%d",((int*)data)[index]);
#174 fprintf(stdout,"%uU",((unsigned int*)data)[index]);
#177 fprintf(stdout,"%#gF",((float*)data)[index]);
#180 fprintf(stdout,"%#gD",((double*)data)[index]);
#183 fprintf(stdout,"\"%s\"",((char**)data)[index]);
dapdump.h#42extern void dumpdata1(nc_type nctype, size_t index, char* data);
#55extern void dumpdata1(nc_type nctype, size_t index, char* data);
data.c#88    src->data = NULL;
#101    src->data = list->data;
#114    src->data = con;
#127    con.lineno = list->data[0].lineno;
#150 return &ds->data[ds->index];
#168 return &ds->data[ds->index++];
#193    return ds->data[index].lineno;
#215    src->data = dl->data;
#242    if(ds->data[ds->index].nctype != NC_FILLVALUEPANIC("srcsetfill: not fill");
#243    ds->data[ds->index].nctype = NC_COMPOUND;
#244    ds->data[ds->index].value.compoundv = list;
#301 clone->data[i] = cloneconstant(dl->data+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));
#315    dl1->data = vector;
#325    vector = (NCConstant*)erealloc(dl->data,sizeof(NCConstant)*(dl->length+1));
#329    dl->data = vector;
#339    dl->data[index] = *con;
#347    return ds->data[0].lineno;
#701        newdata = (NCConstant*)erealloc((void*)dl->data,sizeof(NCConstant)*newalloc);
#707    dl->data = newdata;
#719    ci->data = (NCConstant*)emalloc(sizeof(NCConstant)*initial);
#720    memset((void*)ci->data,0,sizeof(NCConstant)*initial);
#731    dl->data[dl->length++] = *constant;
#740  d.lineno = (dl->length > 0?dl->data[0].lineno:0);
data.h#63    NCConstant*     data; /* actual list of constants constituting the datalist*/
#78    NCConstant*    data;     /* duplicate pointer; so do not free.*/
#87    char* data;
#102#define   datalistith(dl,i) ((dl)==NULL?NULL:((i) >= (dl)->length?NULL:&(dl)->data[i]))
#162#define srcpeek(ds) ((ds)==NULL || (ds)->index >= (ds)->max?NULL:(ds)->data+(ds)->index)
dcopy.c#261   void *data = NULL;
#378   if (!(data = malloc(reclen * type_size))) {
#392        (signed char *)data);
#395   (const signed char *)data);
#399       (char *)data);
#402  (char *)data);
#406        (short *)data);
#409   (short *)data);
#413      (int *)data);
#416 (int *)data);
#420        (float *)data);
#423   (float *)data);
#427 (double *)data);
#430    (double *)data);
#434        (unsigned char *)data);
#437   (unsigned char *)data);
#441 (unsigned short *)data);
#444    (unsigned short *)data);
#448       (unsigned int *)data);
#451  (unsigned int *)data);
#455   (long long *)data);
#458      (long long *)data);
#462    (unsigned long long *)data);
#465       (unsigned long long *)data);
#473   if (data) free(data);
#486   void *data=NULL;
#504  if (!(data = malloc(len * size)))
#508      res = nc_get_att(ncid_invarid_innamedata);
#511   lendata);
#513  free(data);
#534      void *data;
#566     if (!(data = malloc(size * len)))
#568     res = nc_get_att(ncid_invarid_innamedata);
#570        res = nc_put_att(ncid_outvarid_outnamextype_outlendata);
#571     free(data);
dparallel.c#22   NC_MPI_INFO data;
#30   data.comm = comm;
#31   data.info = info;
#32   return NC_create(pathcmode, 0, 0, NULL, 1, &datancidp);
dump.c#59    for(dp=list->data,i=0;i<count;i++,dp++) {
#275     dumpconstant1(&src->data[i]);
#280     dumpconstant1(&src->data[i]);
dvar.c#609nc_free_string(size_t len, char **data)
#613      free(data[i]);
dvlen.c#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);
genbin.c#169                if(vsym->data != NULL) {
#367    if(vsym->data == NULL) return;
#397    char* data = bbContents(memory);
#420        stat = nc_put_var1(vsym->container->ncidvsym->ncidcountdata);
#422        stat = nc_put_vara(vsym->container->ncidvsym->ncidstartcountdata);
#443    list = asym->data;
#450        signed char* data = (signed char*)bbContents(databuf);
#451        stat = nc_put_att_schar(grpid,varid,asym->name,typid,len,data);
#455        char* data = (char*)bbContents(databuf);
#462          data = (char*)bbContents(databuf);
#465        stat = nc_put_att_text(grpid,varid,asym->name,slen,data);
#469        short* data = (short*)bbContents(databuf);
#470        stat = nc_put_att_short(grpid,varid,asym->name,typid,len,data);
#474                int* data = (int*)bbContents(databuf);
#475                stat = nc_put_att_int(grpid,varid,asym->name,typid,len,data);
#479                float* data = (float*)bbContents(databuf);
#480                stat = nc_put_att_float(grpid,varid,asym->name,typid,len,data);
#484                double* data = (double*)bbContents(databuf);
#485                stat = nc_put_att_double(grpid,varid,asym->name,typid,len,data);
#490 const char** data;
#491         data = (const char**)bbContents(databuf);
#494          data);
#497                unsigned char* data = (unsigned char*)bbContents(databuf);
#498                stat = nc_put_att_uchar(grpid,varid,asym->name,typid,len,data);
#502                unsigned short* data = (unsigned short*)bbContents(databuf);
#503                stat = nc_put_att_ushort(grpid,varid,asym->name,typid,len,data);
#507                unsigned int* data = (unsigned int*)bbContents(databuf);
#508                stat = nc_put_att_uint(grpid,varid,asym->name,typid,len,data);
#512                long long* data = (long long*)bbContents(databuf);
#513                stat = nc_put_att_longlong(grpid,varid,asym->name,typid,len,data);
#517                unsigned long long* data = (unsigned long long*)bbContents(databuf);
#518                stat = nc_put_att_ulonglong(grpid,varid,asym->name,typid,len,data);
#525 const char* data;
#526 data = (const char*)bbContents(databuf);
#528         len,(void*)data);
genc.c#408                if(vsym->data != NULLgenc_definevardata(vsym);
#935    if(vsym->data == NULL) return;
#1075    size_t len = asym->data->length; /* default assumption */
#1107                        asym->data->length
genchar.c#57gen_chararray(Dimsetdimset, int dimindexDatalistdataBytebuffercharbufDatalistfillsrc)
#67 gen_leafchararray(dimset,0,data,charbuf,fillchar);
#72    gen_leafchararray(dimset,dimindex,data,charbuf,fillchar);
#79               BytebufferdatabufDatalistdata, int fillchar,
#95    for(i=0;i<data->length;i++) {
#96        NCConstantc = datalistith(data,i);
#116        semwarn(data->data[0].lineno,"character data list too long; expected %d character constant, found %d: ",expectedsize,bbLength(databuf));
#129gen_charattr(DatalistdataBytebufferdatabuf)
#131    gen_charvlen(data,databuf);
#135gen_charvlen(DatalistdataBytebufferdatabuf)
#142    for(i=0;i<data->length;i++) {
#143        c = datalistith(data,i);
#190        NCConstantccon = fillsrc->data;
#217gen_leafchararray(Dimsetdimset, int dimindexDatalistdata,
#249 for(i=0;i<datalistlen(data);i++) {
#250     NCConstantcon = datalistith(data,i);
#258     Datalistnewlist = builddatalist(datalistlen(data));
#261     for(i=0;i<datalistlen(data);i++) {
#262         con = datalistith(data,i);
#285     data = newlist;
#307    for(i=0;i<data->length;i++) {
#308        NCConstantc = datalistith(data,i);
#326        semwarn(data->data[0].lineno,"character data list too long; expected %d character constant, found %d: ",expectedsize,bbLength(charbuf));
generate.c#62 gen_charattr(asym->data,codebuf);
#66        generator->listbegin(generator,asym,NULL,LISTATTR,asym->data->length,codebuf,&uid);
#67        for(count=0;count<asym->data->length;count++) {
#68            NCConstantcon = datalistith(asym->data,count);
#90    if(vsym->data == NULL) return;
#97        NCConstantc0 = datalistith(vsym->data,0);
#151            gen_chararray(dimset,0,vsym->data,charbuf,filler);
#173                generator->listbegin(generator,vsym,NULL,LISTDATA,vsym->data->length,code,&uid);
#175                    NCConstantcon = datalistith(vsym->data,i+offset);
#191            generate_arrayr(vsym,code,vsym->data,
#293    Datalistdata;
#312            con = &fill->data[0];
#330        data = con->value.compoundv;
#332        dllen = datalistlen(data);
#340            con = datalistith(data,i);
#355            con = &fill->data[0];
#364        data = con->value.compoundv;
#368            gen_charvlen(data,vlenbuf);
#371            generator->listbegin(generator,tsym,NULL,LISTVLEN,data->length,codebuf,&uid);
#372            for(count=0;count<data->length;count++) {
#375                con = datalistith(data,count);
#406    Datalistdata;
#412        data = con->value.compoundv;
#414        data = NULL;
#418        gen_chararray(dimset,0,data,charbuf,filler);
#426            con = (data == NULL ? NULL : datalistith(data,i));
genf77.c#140     if(vsym->data == NULL) continue;
#178 int count = gasym->data->length;
#188 int count = asym->data->length;
#325                if(vsym->data == NULL) continue;
#342                if(vsym->data != NULL
#857    size_t len = asym->data==NULL?0:asym->data->length;
genj.c#193                if(vsym->data != NULLgenj_definevardata(vsym);
#396    ASSERT(asym->data != NULL);
#408    if(vsym->data == NULL) return;
#523    size_t len = asym->data == NULL?0:asym->data->length;
getvara.c#95     void *data,
#246    ncstat = makegetvar(dapcomm,cdfvar,data,dsttype,&varainfo);
#416    ncstat = moveto(dapcomm,varainfo,varainfo->cache->datadds,data);
#993makegetvar(NCDAPCOMMONnccommCDFnodevar, void* datanc_type dsttypeGetvara** getvarp)
#1005       getvar->memory = data;
#1207     void* data,
#1262  data,dsttype0));
#1344 void* dataoffset = (void*)(((char*)data) + (externsize*voffset));
#1363 void* dataoffset = (void*)(((char*)data) + (externsize*voffset));
nc3dispatch.c#459     size_t len, const void *data)
#466     size_t *len, void *data)
nc3internal.h#65  long data;
#244extern void NC_hashmapAddDim(const NC_dimarray*, long data, const char *name);
#253extern void NC_hashmapAddVar(const NC_vararray*, long data, const char *name);
#423#define NC3_DATA_SET(nc,data) ((nc)->dispatchdata = (void*)(data))
nc4attr.c#31     int *attnum, int is_long, void *data)
#67 return nc4_get_att_special(h5norm_namextypemem_typelenpattnumis_longdata);
#91   if (data && att->len &&
#116   if (data && att->len && mem_type != att->nc_typeid &&
#124      if ((retval = nc4_convert_type(att->databufratt->nc_typeid,
#139      bufr = att->data;
#146   if (data)
#151  hvl_t *vldest = data;
#177                if (!(((char **)data)[i] = strdup(att->stdata[i])))
#181                ((char **)data)[i] = att->stdata[i];
#189     long *lp = data;
#196     memcpy(databufr, (size_t)(att->len * type_size));
#212     const void *data)
#234   if (len && !data)
#418          nc_vlen_t *in_vlen = (nc_vlen_t *)data, *fv_vlen = (nc_vlen_t *)(var->fill_value);
#427          if(NULL != (*(char **)data))
#429              if (!(*(char **)(var->fill_value) = malloc(strlen(*(char **)data) + 1)))
#431              strcpy(*(char **)var->fill_value, *(char **)data);
#437        memcpy(var->fill_valuedatatype_size);
#455      assert(data);
#470         vldata1 = data;
#491        if (!new_att && att->data) {
#492          free(att->data);
#493          att->data = NULL;
#498            if(NULL != ((char **)data)[i]) {
#499              LOG((5, "copying string %d of size %d", i, strlen(((char **)data)[i]) + 1));
#500              if (!(att->stdata[i] = strdup(((char **)data)[i])))
#504              att->stdata[i] = ((char **)data)[i];
#511            free (att->data);
#512         if (!(att->data = malloc(att->len * type_size)))
#517            memcpy(att->datadatalen * type_size);
#521            if ((retval = nc4_convert_type(dataatt->datamem_typefile_type,
#877                    int* attnump, int is_long, void* data)
#897 if(datastrncpy((char*)data,propdata,len+1);
#909 if(data)
#911 case NC_BYTE: *((char*)data) = (char)iv; break;
#912 case NC_SHORT: *((short*)data) = (short)iv; break;
#913 case NC_INT: *((int*)data) = (int)iv; break;
#914 case NC_UBYTE: *((unsigned char*)data) = (unsigned char)iv; break;
#915 case NC_USHORT: *((unsigned short*)data) = (unsigned short)iv; break;
#916 case NC_UINT: *((unsigned int*)data) = (unsigned int)iv; break;
#917 case NC_INT64: *((long long*)data) = (long long)iv; break;
#918 case NC_UINT64: *((unsigned long long*)data) = (unsigned long long)iv; break;
nc4file.c#1169  if (!(att->data = malloc((unsigned int)(att->len * type_size))))
#1171  if (H5Aread(attidatt->native_hdf_typeidatt->data) < 0)
#2568      if (!(att->data = malloc(att_type_size * att->len)))
#2572      if (SDreadattr(h5->sdidaatt->data))
#2762  if (!(att->data = malloc(att_type_size * att->len))) {
#2768  if (SDreadattr(var->sdsidaatt->data)) {
nc4hdf.c#546             const size_t *countpnc_type mem_nc_type, int is_long, void *data)
#693    bufr = data;
#806      if ((retval = nc4_convert_type(databufrmem_nc_typevar->type_info->nc_typeid,
#868             const size_t *countpnc_type mem_nc_type, int is_long, void *data)
#1048        if (!(*(char **)data = malloc(1 + fstring_len)))
#1050        bufr = *(char **)data;
#1077       bufr = data;
#1121          if ((retval = nc4_convert_type(bufrdatavar->type_info->nc_typeidmem_nc_type,
#1208      filldata = (char *)data + real_data_size;
#1296  void *data;
#1338    data = &phoney_data;
#1339  else if (att->data)
#1340    data = att->data;
#1342    data = att->stdata;
#1344    data = att->vldata;
#1400  if (H5Awrite(attidfile_typeiddata) < 0)
nc4internal.c#1229   if (att->data)
#1230      free(att->data);
nc4internal.h#141   void *data;
#428#define NC4_DATA_SET(nc,data) ((nc)->dispatchdata = (void*)(data))
nc4type.c#728     size_t len, const void *data)
#732   tmp->p = (void *)data;
#739     size_t *len, void *data)
#745   memcpy(datatmp->ptmp->len * type_size);
nc4var.c#1329   const size_t *countpnc_type mem_nc_type, int is_long, void *data)
#1350   if (SDreaddata(var->sdsidstart32NULLedge32data))
nc_hashmap.c#74      NC_dim *elem = ncap->value[table[size].data-1];
#75      NC_hashmapAddDim(ncaptable[size].data-1, elem->name->cp);
#76      assert(NC_hashmapGetDim(ncapelem->name->cp) == table[size].data-1);
#99      NC_var *elem = ncap->value[table[size].data-1];
#100      NC_hashmapAddVar(ncaptable[size].data-1, elem->name->cp);
#101      assert(NC_hashmapGetVar(ncapelem->name->cp) == table[size].data-1);
#128void NC_hashmapAddDim(const NC_dimarrayncap, long data, const char *name)
#149     strncmp(namencap->value[entry.data-1]->name->cp,
#150     ncap->value[entry.data-1]->name->nchars) == 0)
#152   hash->table[index].data = data+1;
#159 hash->table[index].data = data+1;
#175void NC_hashmapAddVar(const NC_vararrayncap, long data, const char *name)
#196     strncmp(namencap->value[entry.data-1]->name->cp,
#197     ncap->value[entry.data-1]->name->nchars) == 0)
#199   hash->table[index].data = data+1;
#206 hash->table[index].data = data+1;
#233    if (hash->table[index].data > 0)
#237   strncmp(namencap->value[entry.data-1]->name->cp,
#238   ncap->value[entry.data-1]->name->nchars) == 0)
#244   return hash->table[index].data-1;
#270    if (hash->table[index].data > 0)
#274   strncmp(namencap->value[entry.data-1]->name->cp,
#275   ncap->value[entry.data-1]->name->nchars) == 0)
#281   return hash->table[index].data-1;
#312   strncmp(namencap->value[entry.data-1]->name->cp,
#313   ncap->value[entry.data-1]->name->nchars) == 0)
#316   return entry.data-1;
#346   strncmp(namencap->value[entry.data-1]->name->cp,
#347   ncap->value[entry.data-1]->name->nchars) == 0)
#350   return entry.data-1;
nccommon.h#341#define NCD2_DATA_SET(nc,data) ((nc)->dispatchdata = (void*)(data))
ncd2dispatch.c#1690    OCdatanode data = NULL;
#1700    ocstat = oc_data_getroot(conn,xroot->tree->ocroot,&data);
#1727     ocstat = oc_data_ithfield(conn,data,index,&nextdata);
#1729     oc_data_free(conn,data);
#1730     data = nextdata; /* set up for next loop iteration */
#1739     ocstat = oc_data_recordcount(conn,data,&recordcount);
#1741     oc_data_free(conn,data); /* reclaim */
ncdap.h#121     void *data,
ncdump.c#838       void *data;
#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);
#863       NC_CHECKnc_get_att(ncidvaridatt.namedata));
#867    pr_any_att_vals(&attdata);
#868    free(data);
#872    unsigned char *cp = data;
#888    value = *((char *)data + i);
#891    value = *((unsigned char *)data + i);
#894    value = *((short *)data + i);
#897    value = *((unsigned short *)data + i);
#900    value = *((int *)data + i);
#903    value = *((unsigned int *)data + i);
#906    value = *((int64_t *)data + i);
#909    value = *((uint64_t *)data + i);
#923    pr_any_att_vals(&attdata);
#924    free(data);
#1263    int64_t data;     /* space for data of any primitive type */
#1285 NC_CHECKnc_inq_enum_member(ncidtypeidfmemname, &data) );
#1288     memval = *(char *)&data;
#1291     memval = *(short *)&data;
#1294     memval = *(int *)&data;
#1297     memval = *(unsigned char *)&data;
#1300     memval = *(unsigned short *)&data;
#1303     memval = *(unsigned int *)&data;
#1306     memval = *(int64_t *)&data;
#1309     memval = *(uint64_t *)&data;
ncgen.h#207        struct Datalistdata; /* shared by variables and attributes*/
ncgeny.c#292static Symbolmakespecial(int tagSymbolvsymSymboltsym, void* data, int isconst);
#2540    {(yyvsp[(1) - (3)].sym)->data = (yyvsp[(3) - (3)].datalist);;}
#3225makespecial(int tagSymbolvsymSymboltsym, void* data, int isconst)
#3251 con = (NCConstant*)data;
#3253        dlappend(list,(NCConstant*)data);
#3255        list = (Datalist*)data;
#3256        con = (NCConstant*)list->data;
#3388                    convert1(&list->data[i],&iconst);
#3411 Datalistdata,
#3415    asym->data = data;
#3432    if(containsfills(data)) {
#3461        NCConstantcon = list->data;
#3530     if(arglist->data[1].nctype != NC_STRING) {
#3536     if(arglist->data[0].nctype != NC_STRING) {
#3547     timekind = arglist->data[0].value.stringv.stringv;
#3548            timevalue = arglist->data[1].value.stringv.stringv;
#3550            timevalue = arglist->data[0].value.stringv.stringv;
ncpdispatch.c#30#define NCP_DATA_SET(nc,data) ((nc)->dispatchdata = (void*)(data))
#1439     size_t len, const void *data)
#1446     size_t *len, void *data)
netcdf.h#699     size_t len, const void *data);
#703     size_t *len, void *data);
#710nc_free_string(size_t len, char **data);
oc.c#926    OCdatadata;
#931    OCDEREF(OCdata*,data,datanode);
#934    ocerr = ocdata_ithfield(state,data,index,&field);
#1054    OCdatadata;
#1059    OCDEREF(OCdata*,data,datanode);
#1062    ocerr = ocdata_container(state,data,&container);
#1087    OCdatadata;
#1092    OCDEREF(OCdata*,data,datanode);
#1095    ocerr = ocdata_root(state,data,&root);
#1123    OCdatadata;
#1128    OCDEREF(OCdata*,data,datanode);
#1131    ocerr = ocdata_ithelement(state,data,indices,&element);
#1157    OCdatadata;
#1162    OCDEREF(OCdata*,data,datanode);
#1165    ocerr = ocdata_ithrecord(state,data,index,&record);
#1193    OCdatadata;
#1197    OCDEREF(OCdata*,data,datanode);
#1199    return OCTHROW(ocdata_position(state,data,indices));
#1224    OCdatadata;
#1228    OCDEREF(OCdata*,data,datanode);
#1230    return OCTHROW(ocdata_recordcount(state,data,countp));
#1249    OCdatadata;
#1251    OCDEREF(OCdata*,data,datanode);
#1253    OCASSERT(data->pattern != NULL);
#1255    else *nodep = (OCobject)data->pattern;
#1277    OCdatadata;
#1279    OCDEREF(OCdata*,data,datanode);
#1281    OCASSERT(data->pattern != NULL);
#1283    else *typep = data->pattern->octype;
#1303    OCdatadata;
#1305    OCDEREF(OCdata*,data,datanode);
#1307    return (fisset(data->datamode,OCDT_ARRAY)
#1308     || fisset(data->datamode,OCDT_SEQUENCE)) ? 1 : 0;
#1327    OCdatadata;
#1329    OCDEREF(OCdata*,data,datanode);
#1331    return (fisset(data->datamode,OCDT_ELEMENT)
#1332     || fisset(data->datamode,OCDT_RECORD)) ? 1 : 0;
#1373    OCdatadata;
#1378    OCDEREF(OCdata*,data,datanode);
#1387    pattern = data->pattern;
#1459    OCdatadata;
#1466    OCDEREF(OCdata*,data,datanode);
#1473    pattern = data->pattern;
#1485        ocerr = ocdata_read(state,data,startpoint,N,memory,memsize);
#1528    OCdatadata;
#1535    data = dds->data;
#1536    if(data == NULL) return OCTHROW(OC_EINVAL);
#1537    return OCTHROW(oc_data_read(link,data,start,edges,memsize,memory));
#1611    OCdatadata;
#1618    data = dds->data;
#1619    if(data == NULL) return OCTHROW(OC_EINVAL);
#1620    return OCTHROW(oc_data_readn(link,data,start,N,memsize,memory));
#1867    if(xdrsizep) *xdrsizep = root->root->tree->data.datasize;
#1968    OCdatadata;
#1974    OCDEREF(OCdata*,data,datanode);
#1977    ocdumpdatapath(state,data,buffer);
#1987    OCdatadata;
#1992    OCDEREF(OCdata*,data,ddsroot);
#1995    ocdumpdatatree(state,data,buffer,0);
#2004    OCdatadata;
#2006    OCDEREF(OCdata*,data,datanode);
#2008    return data->datamode;
oc.h#342extern OCerror oc_data_container(OClinkOCdatanode dataOCdatanodecontainerp);
#348extern OCerror oc_data_root(OClinkOCdatanode dataOCdatanoderootp);
#393extern OCerror oc_data_ithelement(OClinkOCdatanode data, size_t* indicesOCdatanodeelementp);
#396extern OCerror oc_data_ithrecord(OClinkOCdatanode data, size_t indexOCdatanoderecordp);
#399extern OCerror oc_data_free(OClinkOCdatanode data);
#433extern OCerror oc_data_position(OClinkOCdatanode data, size_t* indices);
#436extern OCerror oc_data_ddsnode(OClinkOCdatanode dataOCddsnode*);
#439extern OCerror oc_data_octype(OClinkOCdatanode dataOCtype*);
occompile.c#45    OCdatadata;
#51    OCASSERT(xroot->tree->data.data == NULL);
#55    xxdrs = xtree->data.xdrs;
#58    ocstat = occompile1(state,xroot,xxdrs,&data);
#60 xtree->data.data = data;
#65    ocdumpdatatree(state,data,buffer,0);
#78    OCdatadata = NULL;
#83    data = newocdata(xnode);
#84    MEMFAIL(data);
#87    data->xdroffset = xxdr_getpos(xxdrs);
#93 ocstat = occompilefields(state,data,xxdrs,istoplevel(xnode));
#99     ocstat = occompilefields(state,data,xxdrs,istoplevel(xnode));
#103         fset(data->datamode,OCDT_ARRAY);
#114     data->instances = (OCdata**)malloc(nelements*sizeof(OCdata*));
#115     MEMGOTO(data->instances,ocstat,fail);
#116     data->ninstances = 0;
#123 data->instances[i] = instance;
#124 data->ninstances++;
#126 instance->container = data;
#141 fset(data->datamode,OCDT_SEQUENCE);
#155 record->container = data;
#169 data->ninstances = nelements;
#170 data->instances = (OCdata**)oclistdup(records);
#171 MEMGOTO(data,ocstat,fail);
#177 fset(data->datamode,OCDT_ATOMIC);
#178 ocstat = occompileatomic(state,data,xxdrs);
#189 *datap = data;
#190 data = NULL;
#193    if(data != NULL)
#194 ocdata_free(state,data);
#208    if(data != NULL)
#209 ocdata_free(state,data);
#238occompilefields(OCstatestateOCdatadataXXDRxxdrs, int istoplevel)
#243    OCnodexnode = data->pattern;
#245    assert(data != NULL);
#249    data->instances = (OCdata**)malloc(nelements*sizeof(OCdata*));
#250    MEMFAIL(data->instances);
#259 data->instances[i] = fieldinstance;
#260 data->ninstances++;
#262 fieldinstance->container = data;
#270            OCdatafieldinstance = data->instances[i];
#271     fieldnode->data = fieldinstance;
#279    if(data->instances != NULL) {
#280 for(i=0;i<data->ninstances;i++)
#281     ocdata_free(state,data->instances[i]);
#282 data->ninstances = 0;
#288occompileatomic(OCstatestateOCdatadataXXDRxxdrs)
#294    OCnodexnode = data->pattern;
#315    data->xdroffset = xxdr_getpos(xxdrs);
#316    data->ninstances = xxdrcount;
#317    data->xdrsize = ocxdrsize(xnode->etype,scalar);
#327 xxdr_skip(xxdrs,data->ninstances*data->xdrsize);
#335 xdrsize = data->ninstances*data->xdrsize;
#344 data->nstrings = xxdrcount;
#345 data->strings = (off_t*)malloc(sizeof(off_t)*data->nstrings);
#347        for(i=0;i<data->nstrings;i++) {
#350     data->strings[i] = xxdr_getpos(xxdrs);
#369    if(data->strings != NULL)
#370 free(data->strings);
#371    data->strings = NULL;
#372    data->ninstances = 0;
#377ocdata_free(OCstatestateOCdatadata)
#379    if(data == NULL)
#382    if(data->instances != NULL) {
#384        for(i=0;i<data->ninstances;i++)
#385     ocdata_free(state,data->instances[i]);
#386 free(data->instances);
#388    if(data->strings != NULL)
#389 free(data->strings);
#390    free(data);
#396    OCdatadata = (OCdata*)calloc(1,sizeof(OCdata));
#397    MEMCHECK(data,NULL);
#398    data->header.magic = OCMAGIC;
#399    data->header.occlass = OC_Data;
#400    data->pattern = pattern;
#401    return data;
#453    char* data;
#455    data = (char*)malloc((size_t)avail);
#456    MEMCHECK(data,0);
#457    if(!xxdr_opaque(xdrs,data,avail)) {free(data); return 0;}
#459    if(ocstrncmp(data,tag,sizeof(tag))==0) {
#461        if((p=strchr(data,'}')) != NULL) *(++p)='\0';
#462        oclog(OCLOGERR,"Server error: %s",data);
#464        fprintf(stderr,"Server error: %s",data);
ocdata.c#15octrace(char* procOCstatestateOCdatadata)
#18    ocdumpdatapath(state,data,buffer);
#24#define octrace(proc,state,data)
#31    OCdatadata;
#35    if(root->tree->data.data == NULL)
#38    data = root->tree->data.data;
#39    if(datap) *datap = data;
#41    octrace("attach",state,data);
#47ocdata_container(OCstatestateOCdatadataOCdata** containerp)
#54    pattern = data->pattern;
#59    container = data->container;
#71ocdata_root(OCstatestateOCdatadataOCdata** rootp)
#78    pattern = data->pattern;
#79    root = pattern->tree->data.data;
#114ocdata_ithelement(OCstatestateOCdatadata, size_t* indicesOCdata** elementp)
#122    OCASSERT(data != NULL);
#124    pattern = data->pattern;
#138    if(index >= data->ninstances)
#141    element = data->instances[index];
#152ocdata_ithrecord(OCstatestateOCdatadata,
#162    OCASSERT(data != NULL);
#164    pattern = data->pattern;
#168       || !fisset(data->datamode,OCDT_SEQUENCE))
#172    if(index >= data->ninstances)
#175    record = data->instances[index];
#185ocdata_position(OCstatestateOCdatadata, size_t* indices)
#190    OCASSERT(data != NULL);
#193    pattern = data->pattern;
#194    if(fisset(data->datamode,OCDT_RECORD))
#195 indices[0] = data->index;
#196    else if(fisset(data->datamode,OCDT_ELEMENT)) {
#198 ocarrayindices(data->index,
#208ocdata_recordcount(OCstatestateOCdatadata, size_t* countp)
#211    OCASSERT(data != NULL);
#214    if(data->pattern->octype != OC_Sequence
#215       || !fisset(data->datamode,OCDT_SEQUENCE))
#218    *countp = data->ninstances;
#235ocdata_read(OCstatestateOCdatadata, size_t start, size_t count,
#246    octrace("read", statedata);
#249    assert(data != NULL);
#253    pattern = data->pattern;
#261    totalsize = elemsize*data->ninstances;
#267    xdrs = pattern->root->tree->data.xdrs;
#271        stat = ocread(data,xdrs,(char*)memory,memsize,0,1);
#274        if(start >= data->ninstances
#275           || (start+count) > data->ninstances)
#278        stat = ocread(data,xdrs,(char*)memory,memsize,start,count);
#290ocread(OCdatadataXXDRxdrs, char* memory, size_t memsize, size_t start, size_t count)
#298    OCASSERT(data != NULL);
#302    OCASSERT((start+count) <= data->ninstances);
#304    pattern = data->pattern;
#309    xdrtotal = count*data->xdrsize; /* amount (in xdr sizes) to read */
#310    xdrstart = start*data->xdrsize; /* offset from the start of the data */
#322 xxdr_setpos(xdrs,data->xdroffset+xdrstart);
#333 xxdr_setpos(xdrs,data->xdroffset+xdrstart);
#344 xxdr_setpos(xdrs,data->xdroffset+xdrstart);
#361        xxdr_setpos(xdrs,data->xdroffset+xdrstart);
#385     xxdr_setpos(xdrs,data->xdroffset+xdrstart);
#390     xxdr_setpos(xdrs,data->xdroffset+xdrstart);
#399 if(count > data->nstrings)
#403     off_t offset = data->strings[start+i];
ocdata.h#34extern OCerror ocdata_container(OCstate*, OCdatadataOCdata** containerp);
#35extern OCerror ocdata_root(OCstate*, OCdatadataOCdata** rootp);
#37extern OCerror ocdata_ithelement(OCstate*, OCdatadata, size_t* indicesOCdata** elementp);
#38extern OCerror ocdata_ithrecord(OCstate*, OCdatadata, size_t indexOCdata** recordp);
#40extern OCerror ocdata_position(OCstate*, OCdatadata, size_t* indices);
ocdump.c#483    if(root->tree->data.file != NULL) {
#484        if(!ocreadfile(root->tree->data.file,
#485                       root->tree->data.bod,
#496        mem = root->tree->data.memory;
#497        mem += root->tree->data.bod;
#498        len = root->tree->data.datasize;
#499        len -= root->tree->data.bod;
#505ocdumpdata(OCstatestateOCdatadataOCbytesbuffer, int frominstance)
#508    OCnodepattern = data->pattern;
#509    snprintf(tmp,sizeof(tmp),"%lx:",(unsigned long)data);
#515    snprintf(tmp,sizeof(tmp)," xdroffset=%ld",(unsigned long)data->xdroffset);
#517    if(data->pattern->octype == OC_Atomic) {
#518        snprintf(tmp,sizeof(tmp)," xdrsize=%ld",(unsigned long)data->xdrsize);
#522        snprintf(tmp,sizeof(tmp)," ninstances=%d",(int)data->ninstances);
#525        snprintf(tmp,sizeof(tmp)," nstrings=%d",(int)data->nstrings);
#529    snprintf(tmp,sizeof(tmp),"%lx",(unsigned long)data->container);
#532    ocbytescat(buffer,ocdtmodestring(data->datamode,0));
#546ocdumpdatatree(OCstatestateOCdatadataOCbytesbuffer, int depth)
#561    pattern = data->pattern;
#574    snprintf(tmp,sizeof(tmp),"%08lu",(unsigned long)data->xdroffset);
#580    if(fisset(data->datamode,OCDT_FIELD)
#581       || fisset(data->datamode,OCDT_ELEMENT)
#582       || fisset(data->datamode,OCDT_RECORD)) {
#583        snprintf(tmp,sizeof(tmp),"%04lu ",(unsigned long)data->index);
#590    ocbytescat(buffer,ocdtmodestring(data->datamode,1));
#595    if(fisset(data->datamode,OCDT_ARRAY)
#596       || fisset(data->datamode,OCDT_SEQUENCE)) {
#597        snprintf(tmp,sizeof(tmp),"%04lu",(unsigned long)data->ninstances);
#599        snprintf(tmp,sizeof(tmp),"%04lu",(unsigned long)data->xdrsize);
#625    if(!fisset(data->datamode,OCDT_ATOMIC)) {
#626        for(i=0;i<data->ninstances;i++)
#627     ocdumpdatatree(state,data->instances[i],buffer,depth+1);
#632ocdumpdatapath(OCstatestateOCdatadataOCbytesbuffer)
#641    path[0] = data;
ochttp.c#177WriteFileCallback(void* ptr, size_t size, size_t nmemb, void* data)
#182 fetchdata = (struct Fetchdata*) data;
#198WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
#201 OCbytesbuf = (OCbytes*) data;
ocinternal.c#333            tree->data.xdrs = xxdr_filecreate(tree->data.file,tree->data.bod);
#337 (unsigned long)tree->data.datasize,(unsigned long)tree->data.bod);
#340            tree->data.xdrs
#341xxdr_memcreate(tree->data.memory,tree->data.datasize,tree->data.bod);
#343        MEMCHECK(tree->data.xdrs,OC_ENOMEM);
#347 if(dataError(tree->data.xdrs,state)) {
#396    tree->data.filename = name; /* remember our tmp file name */
#398    tree->data.file = fopen(tree->data.filename,"w+");
#399    if(tree->data.file == NULL) return OC_EOPEN;
#401    if(ocdebug == 0) unlink(tree->data.filename);
#466 bod = tree->data.bod;
#467 ddslen = tree->data.datasize;
#469    tree->data.bod = bod;
#470    tree->data.ddslen = ddslen;
#479    tree->data.memory = ocbytesextract(state->packet);
#482    if(tree->data.bod % 8 != 0) {
#483        unsigned long count = tree->data.datasize - tree->data.bod;
#484        memcpy(tree->xdrmemory,tree->xdrmemory+tree->data.bod,count);
#485        tree->data.datasize = count;
#486 tree->data.bod = 0;
#487 tree->data.ddslen = 0;
#502    rewind(tree->data.file);
#508        count = fread(chunk,1,sizeof(chunk),tree->data.file);
#514 bod = tree->data.bod;
#515 ddslen = tree->data.datasize;
#521    tree->data.bod = bod;
#522    tree->data.ddslen = ddslen;
#531    if(fseek(tree->data.file,(long)tree->data.bod,SEEK_SET) < 0
ocinternal.h#247        OCdatadata;
#248    } data;
ocnode.c#161    if(tree->data.data != NULL)
#162 ocdata_free(state,tree->data.data);
#180    if(tree->data.xdrs != NULL) {
#181        xxdr_free(tree->data.xdrs);
#183    ocfree(tree->data.filename); /* may be null */
#184    if(tree->data.file != NULL) fclose(tree->data.file);
#185    ocfree(tree->data.memory);
ocnode.h#60    OCdatadata; /* Defined only if this node is a top-level atomic variable*/
ocread.c#142        tree->data.datasize = ocbyteslength(state->packet);
#152            stat = readfiletofile(readurl, ".dods", tree->data.file, &tree->data.datasize);
#163            stat = ocfetchurl_file(state->curlreadurltree->data.file,
#164                                   &tree->data.datasize, &lastmod);
ocutil.c#438    xdrs = tree->data.xdrs;
rewrite-scalar.c#20    int ncidvariddata[] = {42};
#24    if (nc_put_var_int(ncidvariddata)) ERR;
semantics.c#427 if(att->data != NULL && listlength(att->data) > 0)
#428     processeconstrefsR(att->data);
#432 if(var->data != NULL && listlength(var->data) > 0)
#433     processeconstrefsR(var->data);
#439processeconstrefsR(Datalistdata)
#443    for(i=0,con=data->data;i<data->alloc;i++,con++) {
#730 if(asym->data->length == 0) {
#735     asym->data = builddatalist(1);
#736     emptystringconst(asym->lineno,&asym->data->data[asym->data->length]);
#751     if(asym->data == NULL) {
#753         asym->data = getfiller(asym->typ.basetype);
#755     asym->att.var->var.special._Fillvalue = asym->data;
#761 if(asym->data->length == 0) {
#765     asym->data = builddatalist(1);
#766     emptystringconst(asym->lineno,&asym->data->data[asym->data->length]);
#901    ASSERT(asym->data != NULL);
#902    datalist = asym->data;
#955    Datalistdatalist = sym->data;
#1082computeunlimitedsizes(Dimsetdimset, int dimindexDatalistdata, int ischar)
#1098        length = data->length;
#1112 for(i=0;i<data->length;i++) {
#1113     NCConstantcon = data->data+i;
#1124     for(i=0;i<data->length;i++) {
#1125 NCConstantcon = &data->data[i];
#1134     semwarn(datalistline(data),"Expected character constant, found {...}");
#1137     semwarn(datalistline(data),"Illegal character constant: %d",con->nctype);
#1141        length = data->length;
#1174 if(var->data == NULL) continue; /* no data list to walk */
#1179     computeunlimitedsizes(dimset,first,var->data,ischar);
#1182     for(j=0;j<var->data->length;j++) {
#1183         NCConstantcon = var->data->data+j;
tst_atts2.c#38      struct s1 data[DIM_LEN];
#48  data[i].i1 = 32768;
#49  data[i].i2 = 32767;
#73      data)) ERR;
#120      long long data = 0, data_in[NUM_ATT];
#129     (void *)&data);
#165      struct s1 data[DIM_LEN], data_in[DIM_LEN];
#170  data[i].i1 = 5;
#171  data[i].i2 = 10;
#187      data)) ERR;
#201  if (data[i].i1 != data_in[i].i1 || data[i].i2 != data_in[i].i2ERR;
#218      int data_in[DIM_LEN_10], data[DIM_LEN_10] = {0, 1, 2, 3, 0, 1, 2, 3, 0, 1};
#233      data)) ERR;
#248  if (data[i] != data_in[i]) ERR;
tst_big_rvar.c#49    signed char data[DIM2][DIM3];
#67     data[i][j] = (i + j) % 16;
#71    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#73    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#81    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#85     if (data[i][j] != (signed char)((i + j) % 16))
#88        start[0], ij, (i + j) % 16, data[i][j]);
#95    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#99     if (data[i][j] != (signed char)((i + j) % 16))
#102        start[0], ij, (i + j) % 16, data[i][j]);
tst_big_var2.c#53    signed char data[DIM1][DIM2];
#71     data[i][j] = 42;
#75    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#78     data[i][j] = 19;
#81    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#89    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#93     if (data[i][j] != 42 )
#96        start[0], ij, 42, data[i][j]);
#103    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#107     if (data[i][j] != 19 )
#110      start[0], ij, 19, data[i][j]);
tst_big_var6.c#51    short data[DIM3];
#70 data[j] = FIRST_VAL;
#71    if (nc_put_vara_short(ncidvaridstartcount, &data[0])) ERR;
#78 data[j] = SECOND_VAL;
#79    if (nc_put_vara_short(ncidvaridstartcount, &data[0])) ERR;
#85    if (nc_get_vara_short(ncidvaridstartcount, &data[0])) ERR;
#87 if (data[j] != FIRST_VAL ) {
#89    start[0], start[1], start[2], jFIRST_VALdata[j]);
tst_camrun.c#678   unsigned data;/*       data/stack */
#687      &text, &lib, &data);
#688      *mem_used = (data * page_size) / MEGABYTE;
tst_comp2.c#49   struct vecmat_t data[DIM_LEN] = {
#115   if(nc_put_var(ncidvariddata)) ERR;
#157       if (val_in.dow != data[k].dowERR;
#159    if (val_in.mon[i] != data[k].mon[i]) ERR;
#162    if (val_in.vec[i] != data[k].vec[i]) ERR;
#166        if (val_in.mat[i][j] != data[k].mat[i][j]) ERR;
tst_compounds.c#44      struct s1 datadata_in;
#47      data.i1 = 5;
#48      data.i2 = 10;
#60      if (nc_put_var(ncidvarid, &data)) ERR;
#96      if (data.i1 != data_in.i1 || data.i2 != data_in.i2ERR;
#118      struct s1 data[DIM_LEN], data_in[DIM_LEN];
#125      memcpy((void *)data, (void *)dummy, sizeof(struct s1) * DIM_LEN);
#131  data[i].i1 = 5;
#132  data[i].i2 = 10;
#146      if (nc_put_var(ncidvariddata)) ERR;
#183  if (data[i].i1 != data_in[i].i1 || data[i].i2 != data_in[i].i2ERR;
#192 memcpy(datas,data,sizeof(datas));
#195 memset(data,0,sizeof(data));
#196 if (nc_get_var(ncidvariddata)) ERR;
#198 memset(data,0,sizeof(data));
#199 if (nc_get_var(ncidvariddata)) ERR;
#201   if(data[i*STRIDE_S].i1 != datas[i].i1 || data[i*STRIDE_S].i2 != datas[i].i2ERR;
#204 memset(data,0,sizeof(data));
#205        if (nc_get_vars(ncidvaridstartedgesstridedata)) ERR;
#207   if(data[i].i1 != datas[i].i1 || data[i].i2 != datas[i].i2ERR;
#256      struct s1 data[DIM_LEN], data_in[DIM_LEN];
#263      memcpy((void *)data, (void *)dummy, sizeof(struct s1) * DIM_LEN);
#269  data[i].i1 = 5;
#270  data[i].i2 = 10;
#280      if (nc_put_att(ncidNC_GLOBALSERVICE_RECORDtypeid, 3, data)) ERR;
#294  if (data[i].i1 != data_in[i].i1 || data[i].i2 != data_in[i].i2ERR;;
#512      struct s1 data[DIM_LEN];
#537  data[i].i1 = 5;
#538  data[i].i2 = 10;
#541  hr_data_out[i].svc_rec = data[i];
tst_compounds3.c#62      struct s1_packed *data;
#65      if (!(data = calloc(sizeof(struct s1_packed), DIM_LEN))) ERR;
#71  data[i].i = 100;
#72  data[i].j = 1000000000000LL;
#86      if (nc_put_var(ncidvariddata)) ERR;
#111  if (data[i].i != data_in[i].i || data[i].j != data_in[i].jERR;
#114      free(data);
tst_coords.c#707      int data[D0_LEN] = {42, -42};
#713      if (nc_put_var_int(ncidvariddata)) ERR;
#715      if (nc_put_var_int(ncidvarid2data)) ERR;
tst_create_files.c#60   long long data[DIM_LEN] = {42LL, -42LL};
#95      if (nc_put_var_longlong(luna_idvariddata)) ERR;
#179  if (data_in[i] != data[i]) ERR;
#193      nc_vlen_t data[DIM_LEN];
#204  data[i].p = phoney;
#205  data[i].len = i+1;
#212      if (nc_put_att(ncidNC_GLOBALATT_NAME2typeidDIM_LENdata)) ERR;
#221  free(data[i].p);
tst_create_files.c#44       float *data;
#49       if (!(data = (float *)malloc(D1 * D2 * sizeof(float)))) ERR;
#51   data[i] = (float)rand();
#83   if (nc_put_vara_float(ncidvaridstartcount, (const float *) data))
#88       free(data);
#105       float data[DIMLEN], data_in[DIMLEN];
#109   data[i] = ((float)rand() / (float)(RAND_MAX));
#117       if (nc_put_var_float(ncidvariddata)) ERR;
#133   if (data_in[i] != data[i]) ERR;
#154       void *data[MAX_TYPES];
#165       data[0] = fdata;
#166       data[1] = idata;
#167       data[2] = sdata;
#185      if (nc_put_var(ncidvariddata[t])) ERR;
#234       int data[DIM_LEN];
#239   data[i] = i;
#248       if (nc_put_var(ncidvariddata)) ERR;
#266       void *data[MAX_TYPES];
#277       data[0] = fdata;
#278       data[1] = idata;
#279       data[2] = sdata;
#297      if (nc_put_var(ncidvariddata[t])) ERR;
tst_dims.c#620      unsigned short data[2] = {42, 24}, data_in[2];
#647      if (nc_put_vara(ncidhp_varidstartcountdata)) ERR;
#656      if (data_in[0] != data[0]) ERR;
tst_dims3.c#92      float data = 42.5;
#104      if (nc_put_var_float(ncidvarid, &data)) ERR_RET;
tst_diskless3.c#51   char data[MAX_RECS], data_in;
#64   for (data[0] = 'a', r = 1; r < MAX_RECSr++)
#65      data[r] = data[r - 1] + 1;
#76      sprintf(att_name, "a_%d", data[r]);
#79  if((status=nc_put_vara_text(ncidvarid[v], startcount, &data[r]))) ERRSTAT(status);
#81  if((status=nc_put_att_text(ncidvarid[v], att_name, 1, &data[r]))) ERRSTAT(status);
#94  if (data_in != data[r]) ERR;
#107   char data = 'h', data_in;
#115   if((status=nc_put_att_text(ncidNC_GLOBALATT_NAME, 1, &data))) ERRSTAT(status);
#121   if((status=nc_put_vara_text(ncidvaridstartcount, &data))) ERRSTAT(status);
#131   if (data_in != dataERRSTAT(status);
#133   if (data_in != dataERRSTAT(status);
tst_diskless4.c#45    unsigned int data[DATASIZE];
#164 for(j=0;j<DATASIZE;j++) data[j] = iv*((i*CHUNKSIZE)+j);
#165 if((status=nc_put_vara(ncid,varids[iv],start,count,(void*)data)))
#175 if((status=nc_get_vara(ncid,varids[iv],start,count,(void*)data)))
#179         if(data[j] != expected) {
#181 ivi,j,data[j],expected);
tst_empty_vlen_unlim.c#40    nc_vlen_t data[ROW_COUNT];
#106    data[0].p = dat0;
#107    data[0].len = VLEN0;
#109    data[1].p = dat1;
#110    data[1].len = VLEN1;
#112    data[2].p = dat2;
#113    data[2].len = VLEN2;
#132    nc_vlen_t data[ROW_COUNT];
#198    data[0].p = dat0;
#199    data[0].len = VLEN0;
#201    data[1].p = dat1;
#202    data[1].len = VLEN1;
#204    data[2].p = dat2;
#205    data[2].len = VLEN2;
tst_enums.c#111      unsigned char data[BRADY_DIM_LEN] = {0, 4, 8};
#140      if (nc_put_att(ncidNC_GLOBALATT_NAMEtypeidBRADY_DIM_LENdata)) ERR;
tst_fileinfo.c#76 int data = 17;
#88 if(nc_put_att_int(root,NC_GLOBAL,INT_ATT_NAME,NC_INT,1,&data)!=0) ERR;
#92 if(nc_put_att_int(root,varid,INT_ATT_NAME,NC_INT,1,&data)!=0) ERR;
#96 if(nc_put_att_int(grpid,NC_GLOBAL,INT_ATT_NAME,NC_INT,1,&data)!=0) ERR;
#147 if(nc_get_att_int(root,NC_GLOBAL,SUPERBLOCKATT,&data)!=0) ERR;
#160 stat = nc_put_att_int(root,NC_GLOBAL,NCPROPS,NC_INT,1,&data);
#174 if(nc_get_att_int(root,NC_GLOBAL,ISNETCDF4ATT,&data)!=0) ERR;
#187 stat = nc_put_att_int(root,NC_GLOBAL,ISNETCDF4ATT,NC_INT,1,&data);
tst_files2.c#66      unsigned data;/*       data/stack */
#69      &text, &lib, &data);
#70      *mem_used = data;
tst_files3.c#28int dump_file2(const float *data, int docompression, int usedefdim)
#47  if (nc_put_vara_float(ncidvarstartcountdata)) ERR_RET;
#53int dump_file(const float *data, int docompression, int usedefdim)
#69   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#75int dump_file3(const float *data, int docompression, int usedefdim)
#91   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#97int dump_hdf_file(const float *data, int docompression)
#145       xfer_plistiddata) < 0) ERR_RET;
#179      unsigned data;/*       data/stack */
#182      &text, &lib, &data);
#183      *mem_used = data;
#192   float data[X_LEN * Y_LEN * Z_LEN];
#199      data[i] = i;
#208  if (dump_file3(data, 1, 0)) ERR_RET;
#217  if (dump_hdf_file(data, 1)) ERR_RET;
#226  if (dump_file2(data, 1, 0)) ERR_RET;
tst_files4.c#52       double data[SLICE_LEN * PARTICLE_LEN * AXIS_LEN];
#63   data[i] = 42.42;
#83       startcountdata)) ERR;
tst_fill_attr_vanish.c#44  double data[1] = {3.14159};
#76  if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_fillbug.c#27   double data[1] = {3.14159};
#50   if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_grps.c#969      unsigned char data[BASE_SIZE] = {42, 43}, data_in[BASE_SIZE];
#977      if (nc_put_att(g1idNC_GLOBALDATE_MOVIExtype, 1, &data)) ERR;
#983      if (data[0] != data_in[0] || data[1] != data_in[1]) ERR;
#991      if (data[0] != data_in[0] || data[1] != data_in[1]) ERR;
#1002      if (data[0] != data_in[0] || data[1] != data_in[1]) ERR;
#1098      struct s1 data;
#1102      data.i1 = 5;
#1103      data.i2 = 10;
#1121      if (nc_put_var(ncidvarid, &data)) ERR;
tst_h_atts3.c#60  hvl_t data[NUM_VL];
#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++)
#75        ((struct s1 *)cvc_out[i].data[j].p)[k].x = 42.42;
#76        ((struct s1 *)cvc_out[i].data[j].p)[k].y = 2.0;
#114      if (H5Tinsert(s3_typeidVL_NAMEoffsetof(struct s3data),
#190     free(cvc_out[i].data[j].p);
tst_h_compounds.c#35   } data[DIM1_LEN];
#53      data[i].i1 = 99;
#54      data[i].i2 = -99;
#85                   H5P_DEFAULTdata) < 0) ERR;
#138                   H5P_DEFAULTdata) < 0) ERR;
#146                   H5P_DEFAULTdata) < 0) ERR;
tst_h_dimscales4.c#62      float data = 42;
#97      if (H5Pset_fill_value(create_propidH5T_NATIVE_FLOAT, &data) < 0) ERR;
#114      if (H5Pset_fill_value(create_propidH5T_NATIVE_FLOAT, &data) < 0) ERR;
tst_h_enums.c#48      short data[DIM1_LEN];
#70  data[i] = i*2;
#91      if (H5Awrite(attidtypeiddata) < 0) ERR;
#130  if (data_in[i] != data[i]) ERR;
tst_h_files.c#30      unsigned char data[DIM_LEN][OPAQUE_SIZE];
#44     data[j][k] = 42;
#64      if (H5Awrite(attidtypeiddata) < 0) ERR;
#178      int *data;
#184      if (!(data = malloc(SC * sizeof(int))))
#187  data[i] = rand();
#216       H5P_DEFAULTdata) < 0) ERR;
#220      free(data);
tst_h_files2.c#28      unsigned char data[DIM_LEN][OPAQUE_SIZE];
#34     data[j][k] = 42;
#52      if (H5Awrite(attidtypeiddata) < 0) ERR;
tst_h_files3.c#39      unsigned data;/*       data/stack */
#42      &text, &lib, &data);
#43      *mem_used = data;
tst_h_ints.c#32      int data[NUM_STR] = {42};
#54    H5P_DEFAULT, &data) < 0) ERR;
tst_h_opaques.c#21   char data[DIM1_LEN][SIZE];
#28  data[i][j] = 0;
#49   if (H5Awrite(attidtypeiddata) < 0) ERR;
tst_h_par.c#70      int data[SC1], data_in[SC1];
#81  data[i] = rand();
#132  xferiddata) < 0) ERR;
tst_h_rd_cmp.c#24   } data[DIM1_LEN];
#50        data) < 0) ERR;
#54      if (data[i].c1 != 126 || data[i].d != -9999999) ERR;
tst_h_strings.c#30      const char *data = "The art of war is of vital "
#50      if (H5Awrite(attidtypeid, &data) < 0) ERR;
#82      if (strcmp(datadata_in)) ERR;
#102      char *data[DIM1_LEN] = {"Ohhh!", "Ahhh!", "Wub-wub-wub!"};
#123      if (H5Awrite(attidtypeiddata) < 0) ERR;
#154  if (strcmp(data[i], data_in[i])) ERR;
#176      char **data;
#184      data = malloc(sizeof(char *) * 2);
#185      data[0] = malloc(strlen(S1) + 1);
#186      strcpy(data[0], S1);
#187      data[1] = malloc(strlen(S2) + 1);
#188      strcpy(data[1], S2);
#207      if (H5Awrite(attidtypeiddata) < 0) ERR;
#239  if (strcmp(data[i], data_in[i])) ERR;
#245      free(data[0]);
#246      free(data[1]);
#247      free(data);
#259      char **data;
#267      data = malloc(sizeof(char *) * 2);
#268      data[0] = malloc(strlen(S1) + 1);
#269      strcpy(data[0], "");
#270      data[1] = malloc(strlen(S2) + 1);
#271      strcpy(data[1], "");
#290      if (H5Awrite(attidtypeiddata) < 0) ERR;
#322  if (strcmp(data[i], data_in[i])) ERR;
#328      free(data[0]);
#329      free(data[1]);
#330      free(data);
tst_h_strings1.c#26      char *data = "Not for the first time, an argument had broken "
#64    H5P_DEFAULT, &data) < 0) ERR;
#161      char *data[NUM_STR] = {
#203    H5P_DEFAULT, &data) < 0) ERR;
tst_h_strings2.c#34      char *data = "A man who carries a cat by the tail learns "
#103    H5P_DEFAULT, &data) < 0) ERR;
#131      char *data = "A man who carries a cat by the tail learns "
#191    H5P_DEFAULT, &data) < 0)
tst_h_vars.c#325      int data[DIM1_LEN], data_in[DIM1_LEN];
#333  data[i] = i;
#350    data) < 0) ERR;
#352    data) < 0) ERR;
#354    data) < 0) ERR;
#377  if (data[i] != data_in[i]) ERR;
#387  if (data[i] != data_in[i]) ERR;
#397  if (data[i] != data_in[i]) ERR;
tst_h_vars3.c#30      char *data[NA];
#47  data[i] = amend[i];
#65    data) < 0) ERR;
tst_h_vl.c#24      hvl_t data[DIM1_LEN], data_in[DIM1_LEN];
#36  data[i].p = phoney;
#37  data[i].len = i+1;
#56      if (H5Awrite(attidtypeiddata) < 0) ERR;
#73  if (data[i].len != i+1) ERR;
#75     if (((int *)(data[i].p))[j] != -99) ERR;
#80  free(data[i].p);
tst_h_wrt_cmp.c#27   } data[DIM1_LEN];
#34      memcpy((void *)(&data[i]), (void *)dummy, sizeof(struct s1));
#39      data[i].c1 = 126;
#40      data[i].d = -9999999;
#68 data) < 0) ERR;
tst_interops.c#314      char data[ATT_LEN][MAX_LEN + 1] = {"Larry_", "Curley", "Moe111"};
#333      if (H5Awrite(attidtypeiddata) < 0) ERR;
#367  if (strcmp(data[i], cur)) ERR;
#387  if (strcmp(data[i], data_in2[i])) ERR;
tst_interops6.c#29      char *data = "The art of war is of vital "
#57      if (H5Awrite(attidtypeid, &data) < 0) ERR;
#89      if (strcmp(datadata_in)) ERR;
#107      char *data = "Thou art no dissatisfied, I suppose, because "
#136      if (H5Tset_size(typeid, strlen(data) + 1) < 0) ERR;
#147    data) < 0) ERR;
tst_knmi.c#51   short *data;
#62   if (!(data = malloc(sizeof(short) * XLEN * YLEN))) ERR;
#65   if (nc_get_var_short(ncidvariddata)) ERR;
#70   free(data);
tst_large2.c#37      float *data;
#47      if (!(data = calloc(LAT_LEN * LON_LEN, sizeof(float)))) ERR;
#68   data[j + LON_LEN * i] = (start[0] + i + j) % 19;
#71     if (nc_put_vara_float(ncidvaridstartcountdata)) ERR;
#80     if (nc_get_vara_float(ncidvaridstartcountdata)) ERR;
#84   if (data[j + LON_LEN * i] != (start[0] + i + j) % 19)
#87     start[0], ij, (start[0] + i + j), data[j + LON_LEN * i]);
#95      free(data);
tst_mem.c#40      unsigned data;/*       data/stack */
#43      &text, &lib, &data);
#44      *mem_used = data;
#54   float data;
#71      data = 25.5 + l_index[0];
#72      if (nc_put_var1_float(ncidsfc_tempidl_index, (const float*) &data)) ERR;
tst_nc4perf.c#39   float *data;
#49   if (!(data = malloc(sizeof(float) * DIMSIZE2 * DIMSIZE1 / mpi_size)))
#53  data[j * DIMSIZE1 / mpi_size + i] = (float)mpi_rank * (j + 1);
#97  if (nc_put_vara_float(ncidvarid1[i], startcountdata)) ERR;
#110   free(data);
tst_nofill2.c#91      double data;
#99  if (nc_get_var1(ncid, 0, idx, &data)) ERR;
#100  if (!dataERR;
tst_nofill3.c#102      int data[TIME_LEN];
#107      if (nc_get_var(ncidvariddata)) ERR;
#108      if (data[0] != 1) ERR; /* value overwritten by zero due to NOFILL bug */
tst_opaques.c#28   unsigned char data[DIM_LEN][BASE_SIZE], data_in[DIM_LEN][BASE_SIZE];
#35  data[i][j] = 0;
#56      if (nc_put_var(ncidvarid, &data[0])) ERR;
#67  if (data_in[0][j] != data[0][j]) ERR;
#91      if (nc_put_var(ncidvariddata)) ERR;
#104      if (data_in[i][j] != data[i][j]) ERR;
#116      if (nc_put_att(ncidNC_GLOBALATT_NAMExtypeDIM_LENdata)) ERR;
#147      if (nc_put_att(ncidNC_GLOBALATT_NAMExtypeDIM_LENdata)) ERR;
#165      if (data_in[i][j] != data[i][j]) ERR;
tst_parallel.c#43    int data[DIMSIZE * DIMSIZE], ires;
#88       data[i] = mpi_rank;
tst_parallel2.c#42    int data[DIMSIZE * DIMSIZE], data_in[DIMSIZE * DIMSIZE];
#97       data[i] = mpi_rank;
#145       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
tst_parallel3.c#192   int *data;
#235   if (!(data = malloc(sizeof(int)*count[1]*count[0]))) ERR;
#236   tempdata = data;
#246   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#247   free(data);
#403   int *data;
#452   data      = malloc(sizeof(int)*count[1]*count[0]);
#453   tempdata  = data;
#461   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#462   free(data);
#580   int *data;
#656   data      = malloc(sizeof(int)*count[1]*count[0]);
#657   tempdata  = data;
#666   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#667   free(data);
tst_parallel4.c#46    int data[DIMSIZE * DIMSIZE], data_in[DIMSIZE * DIMSIZE];
#101       data[i] = mpi_rank;
#149       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
tst_simplerw_coll_r.c#55    int data[DIMSIZE * DIMSIZE], data_in[DIMSIZE * DIMSIZE];
#110       data[i] = mpi_rank;
#157       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
tst_small.c#145   char data[NUM_VALS][STR_LEN + 1], data_in[NUM_VALS][STR_LEN];
#152   strcpy(data[0], "2005-04-11_12:00:00");
#153   strcpy(data[1], "2005-04-11_13:00:00");
#172      if ((stat=nc_put_vara_text(ncidvaridstartcountdata[start[0]]))!=NC_NOERRERR2;
#183      if (strncmp(data[i], data_in[i], STR_LEN)) ERR;
#193   char data[NUM_VALS][STR_LEN + 1], data_in[NUM_VALS][STR_LEN];
#200   strcpy(data[0], "2005-04-11_12:00:00");
#201   strcpy(data[1], "2005-04-11_13:00:00");
#217      if (nc_put_vara_text(ncidvaridstartcountdata[start[0]])) ERR;
#228      if (strncmp(data[i], data_in[i], STR_LEN)) ERR;
#238   char data = 'h', data_in;
#254   if (nc_put_vara_text(ncidvaridstartcount, &data)) ERR;
#264   if (data_in != dataERR;
#277   char data[MAX_RECS], data_in;
#282   for (data[0] = 'a', r = 1; r < MAX_RECSr++)
#283      data[r] = data[r - 1] + 1;
#316  if (nc_put_vara_text(ncidvaridstartcount, &data[r])) ERR;
#325  if (data_in != data[r]) ERR;
#341   char data[MAX_RECS], data_in;
#353   for (data[0] = 'a', r = 1; r < MAX_RECSr++)
#354      data[r] = data[r - 1] + 1;
#368      if (nc_put_vara_text(ncidvaridstartcount, &data[r])) ERR;
#369      sprintf(att_name, "a_%d", data[r]);
#371      if (nc_put_att_text(ncidvaridatt_name, 1, &data[r])) ERR;
#380      if (data_in != data[r]) ERR;
#382      if (data_in != data[r]) ERR;
#397   char data[MAX_RECS], data_in;
#410   for (data[0] = 'a', r = 1; r < MAX_RECSr++)
#411      data[r] = data[r - 1] + 1;
#431      sprintf(att_name, "a_%d", data[r]);
#434  if (nc_put_vara_text(ncidvarid[v], startcount, &data[r])) ERR;
#436  if (nc_put_att_text(ncidvarid[v], att_name, 1, &data[r])) ERR;
#449  if (data_in != data[r]) ERR;
#461   char data = 'h', data_in;
#469   if (nc_put_att_text(ncidNC_GLOBALATT_NAME, 1, &data)) ERR;
#478   if (nc_put_vara_text(ncidvaridstartcount, &data)) ERR;
#488   if (data_in != dataERR;
#490   if (data_in != dataERR;
tst_strings.c#34      char *data[ATT_LEN_1] = {"R"};
#37      if (nc_put_att(ncidNC_GLOBALMOUNTAIN_RANGENC_STRINGATT_LEN_1data)) ERR;
#52        if (strcmp(data_in[i], data[i])) ERR;
#65      char *data[ATT_LEN] = {"Let but your honour know",
#76      if (nc_put_att(ncidNC_GLOBALATT_NAMENC_STRINGATT_LENdata)) ERR;
#91        if (strcmp(data_in[i], data[i])) ERR;
#100      char *data[] = {"Perhaps a very little thought will now enable you to account for ",
#122      if (nc_put_var_string(ncidvarid, (const char **)data)) ERR;
#129 if (strcmp(data_in[i], data[i])) ERR;
#141      char *data[SOME_PRES] = {"Washington", "Adams", "Jefferson", "Madison",
#149      if (nc_put_att_string(ncidNC_GLOBALATT2_NAMESOME_PRES, (const char **)data)) ERR;
#156  if (strcmp(data_in[i], data[i])) ERR;
#172      char *data[SOME_PRES] = {"Washington", "Adams", "Jefferson", "Madison",
#185      if (nc_put_vara_string(ncidvaridstartcount, (const char **)data)) ERR;
#193  if (i < SOME_PRES && (data_in[i] == NULL || strcmp(data_in[i], data[i]))) ERR;
#212      char *data[SOME_PRES] = {"Washington", "Adams", "Jefferson", "Madison",
#227      status = nc_put_vars_string(ncidvaridstartcountstride, (const char **)data);
#237  if (i < SOME_PRES && strcmp(data_in[i], data[i])) ERR;
#260      char *data[DHR_LEN] = {
#448      if (nc_put_var(ncidvariddata)) ERR;
#470  if (strcmp(data_in[i], data[i])) ERR;
tst_strings2.c#29      char *data[ATT_LEN] = {"An appeaser is one who feeds a crocodile — "
#34      if (nc_put_att(ncidNC_GLOBALATT_NAMENC_STRINGATT_LENdata)) ERR;
#49        if (strcmp(data_in[i], data[i])) ERR;
tst_varms.c#34   int data[DIM1_LEN][DIM2_LEN], data_in[DIM1_LEN][DIM2_LEN];
#107     data[i][j] = k++;
#115      if (nc_put_var_int(ncidvarid, (int *)data)) ERR;
#128     if (data_in[i][j] != data[i][j]) ERR;
#141     if (data_in_t[j][i] != data[i][j]) ERR;
#163      float data[D0][D1][D2], data_in[D0][D1][D2];
#168        data[i][j][k] = i + j + k;
#177      if (nc_put_var_float(ncidvarid, (float *)data)) ERR;
#188        if (data_in[i][j][k] != data[i][j][k]) ERR;
#197        if (data_in[i][j][k] != data[i][j][k]) ERR;
#222      float data[4][6], data_in[6][4];
#229     data[i][j] = k;
#244     (float *)data)) ERR;
tst_vars.c#946      double data[DIM6_LEN];
#954      for (i = 1, data[0] = TEN_K_M2i < DIM6_LENi++)
#955  data[i] = data[i - 1] + INCREMENT;
#1139      int data = TARGET_VALUEdata_in[D1_TARGET][D2_LEN], fill_value_in;
#1155      if (nc_put_var1_int(ncidvaridindex, &data)) ERR;
tst_vars2.c#90         signed char data = 99, data_in;
#105         if (nc_put_vara_schar(ncidvaridstartcount, &data)) ERR;
#116         if (data_in != dataERR;
#145         if (data_in != dataERR;
#592      int data[DIM4_LEN], data_in[DIM4_LEN];
#597         data[i] = i;
#606      if (nc_put_var_int(ncidvariddata)) ERR;
#640  if (data[i] != data_in[i]) ERR;
#661      int data[DIM5_LEN], data_in[DIM5_LEN];
#670         data[i] = i;
#679      if (nc_put_var_int(ncidvariddata)) ERR;
#697         if (data[i] != data_in[i])
#724         if (data[i] != data_in[i])
#742      int data[DIM6_LEN], data_in[DIM6_LEN];
#748         data[i] = i;
#756      if (nc_put_var_int(ncidvariddata)) ERR;
#772         if (data_in[i] != data[i])
#793         if (data[i] != data_in[i])
#809      unsigned long long data = 9223372036854775817ulldata_in;
#814      if (nc_put_var_ulonglong(ncidvarid, &data)) ERR;
#824      if (data_in != dataERR;
#836      if (data_in != dataERR;
tst_vars3.c#238      double data[1] = {3.14159};
#259      if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_vl.c#35      nc_vlen_t data[DIM_LEN], data_in[DIM_LEN];
#50  data[i].p = phony;
#51  data[i].len = i+1;
#63      if (nc_put_att(ncidNC_GLOBALATT_NAMEtypeidDIM_LENdata)) ERR;
#69     ((int *)(data[i].p))[j] = 0;
#101  if (nc_free_vlen(&data[i]) || nc_free_vlen(&data_in[i])) ERR;
#111      nc_vlen_t data[DIM_LEN], data_in[DIM_LEN];
#122  data[i].p = phony;
#123  data[i].len = i+1;
#130      if (nc_put_var(ncidvariddata)) ERR;
#143     if (*((int *)data_in[i].p) != *((int *)data[i].p))
#154  if (nc_free_vlen(&data[i]) || nc_free_vlen(&data_in[i])) ERR;
#161      nc_vlen_t data[DIM_LEN], data_in[DIM_LEN];
#176  data[i].p = phony;
#177  data[i].len = i+1;
#185      if (nc_put_att(ncid1NC_GLOBALATT_NAMEtypeid1DIM_LENdata)) ERR;
#193     ((int *)(data[i].p))[j] = 0;
#225  if (nc_free_vlen(&data[i]) || nc_free_vlen(&data_in[i])) ERR;
tst_xplatform2.c#54   struct s1 data[NUM_S1];
#58   nc_vlen_t data[NUM_VL];
#147   if (strcmp(name_inS1_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s2data) ||
#156  if (data_out[i].data[j].x != data_in[i].data[j].x ||
#157      data_out[i].data[j].y != data_in[i].data[j].yERR;
#202   if (strcmp(name_inVL_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s3data) ||
#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++)
#214     if (((struct s1 *)data_in[i].data[j].p)[k].x != ((struct s1 *)data_out[i].data[j].p)[k].x ||
#215 ((struct s1 *)data_in[i].data[j].p)[k].y != ((struct s1 *)data_out[i].data[j].p)[k].yERR;
#266   if (strcmp(name_inVL_NAME) || offset_in != NC_COMPOUND_OFFSET(struct s3data) ||
#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++)
#278     if (((struct s1 *)data_in[i].data[j].p)[k].x != ((struct s1 *)data_out[i].data[j].p)[k].x ||
#279 ((struct s1 *)data_in[i].data[j].p)[k].y != ((struct s1 *)data_out[i].data[j].p)[k].yERR;
#324  comp_array_of_comp_out[i].data[j].x = 42.42;
#325  comp_array_of_comp_out[i].data[j].y = 2.0;
#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++)
#338     ((struct s1 *)comp_array_of_vlen_of_comp_out[i].data[j].p)[k].x = 42.42;
#339     ((struct s1 *)comp_array_of_vlen_of_comp_out[i].data[j].p)[k].y = 2.0;
#417    NC_COMPOUND_OFFSET(struct s2data),
#479    NC_COMPOUND_OFFSET(struct s3data),
#532    NC_COMPOUND_OFFSET(struct s3data),
#559  free(comp_array_of_vlen_of_comp_out[i].data[j].p);
util.c#117 reclaimconstlist(vsym->var.data);
#122       reclaimattptrs(asym->att.data,asym->att.count);
#124     efree(asym->att.data);
#561 if(list->data != NULL) { /* avoid multiple free attempts*/
#563     for(i=0,con=list->data;i<list->length;i++,con++)
#565     list->data = NULL;
xxdr.c#274        (void)fflush((FILE *)xdrs->data);
#289        if(fseek((FILE *)xdrs->data, (long)(xdrs->pos + xdrs->base), 0) != 0) {
#298        count = fread(addr, (size_t)len, (size_t)1, (FILE*)xdrs->data);
#354        xdrs->data = (void*)file;
#394        memcpy(addr,(char*)xdrs->data+xdrs->base+xdrs->pos, (size_t)len);
#445        xdrs->data = (void*)(mem + base);
#467   unsigned int* data = (unsigned int*)&f;
#469   status = xxdr_uint(xdr,data);
#480   char data[2*XDRUNIT];
#482   status = xxdr_opaque(xdr,data,(off_t)2*XDRUNIT);
#484 xxdrntohdouble(data,dp);
xxdr.h#118  char* data;


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