atttests.c#647    static struct cdfatt att =  /* attribute */
#665    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#669    add_att(&testNC_GLOBAL, &att); /* keep in-memory netcdf consistent */
#678    if (ncattput(cdfidtt_idatt.nameatt.typeatt.lenatt.val) == -1) {
#682    add_att(&testtt_id, &att); /* keep in-memory netcdf consistent */
#692    if (ncattput(cdfidtu_idatt.nameatt.typeatt.lenatt.val) == -1) {
#696    add_att(&testtu_id, &att); /* keep in-memory netcdf consistent */
#723    if (ncattcopy(cdfidNC_GLOBALatt.namecdfid2NC_GLOBAL) == -1) {
#725       pnameatt.name);
#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));
#739    if (ncattget(cdfid2NC_GLOBALatt.nametmp.val) == -1) {
#743    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#750    if (ncattcopy(cdfidtt_idatt.namecdfid2tu2_id) == -1) {
#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));
#765    if (ncattget(cdfid2tu2_idatt.nametmp.val) == -1) {
#769    if (val_cmp(tmp.typetmp.lentmp.valatt.val) != 0) {
#849    if (ncattcopy(cdfidtu_idatt.namecdfidtu_id) == -1) {
#861    if (ncattcopy(cdfidtest.nvarsatt.namecdfidtu_id) != -1) {
#866    if (ncattcopy(cdfidtt_idatt.namecdfid, 2) != -1) {
#876    if (ncattcopy(cdfidtt_idatt.namecdfid2tu_id) != -1) {
#885    if (ncattcopy(cdfidtt_idatt.namecdfid2tu_id) != -1) {
#921    static struct cdfatt att =  /* attribute */
#936    att.name = (char *) emalloc(MAX_NC_NAME);
#939 if (ncattname(cdfidNC_GLOBALiaatt.name) == -1) {
#951 if (strcmp(att.nametest.atts[ib].name) != 0) {
#953   pnameatt.nametest.atts[ib].name);
#962     if (ncattname(cdfidiviaatt.name) == -1) {
#974     if (strcmp(att.nametest.atts[ib].name) != 0) {
#976       pnametest.vars[iv].nameatt.nametest.atts[ib].name);
#983    (void) strcpy(att.name,"attx");
#984    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val)
#989    add_att(&testNC_GLOBAL, &att); /* keep in-memory netcdf consistent */
#996    if (strcmp(att.nametmp.name) != 0) {
#998       pnametmp.nameatt.name);
#1009 if (ncattname(cdfidNC_GLOBALiaatt.name) == -1) {
#1021 if (strcmp(att.nametest.atts[ib].name) != 0) {
#1023   pnameatt.nametest.atts[ib].name);
#1032     if (ncattname(cdfidiviaatt.name) == -1) {
#1044     if (strcmp(att.nametest.atts[ib].name) != 0) {
#1046       pnametest.vars[iv].nameatt.nametest.atts[ib].name);
#1053    if (ncattname(cdfidtest.nvars, 0, att.name) != -1) {
#1058    if (ncattname(cdfidNC_GLOBAL, -1, att.name) != -1) {
#1062    if (ncattname(cdfidNC_GLOBALtest.ngattsatt.name) != -1) {
#1072    if (ncattname(cdfidNC_GLOBAL, 0, att.name) != -1) {
#1077    free (att.name);
cdf.c#1094     NCattributeatt = (NCattribute*)nclistget(node->attributes,j);
#1095     nullfree(att->name);
#1096     for(k=0;k<nclistlength(att->values);k++)
#1097 nullfree((char*)nclistget(att->values,k));
#1098     nclistfree(att->values);
#1099     nullfree(att);
cdftests.c#790    static struct cdfatt att = /* attribute */
#806    if (ncattput(ncidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#821    if (ncattinq(ncidNC_GLOBALatt.name, &att.type, &att.len) != -1) {
dapattr.c#48     NCattributeatt = NULL;
#60     ncstat = buildattribute(ocname,octypetonc(ocetype),nvalues,values,&att);
#64     nclistpush(node->attributes,(void*)att);
#66 att->invisible = 1;
#125    NCattributeatt = NULL;
#127    att = (NCattribute*)calloc(1,sizeof(NCattribute));
#128    MEMCHECK(att,NC_ENOMEM);
#129    att->name = nulldup(name);
#130    att->etype = ptype;
#132    att->values = nclistnew();
#134 nclistpush(att->values,(void*)nulldup(values[i]));
#136    if(attp) *attp = att;
#138      free(att);
#331     NCattributeatt = NULL;
#344     &att);
#346            nclistpush(dds->attributes,(void*)att);
#358         NCattributeatt = NULL;
#377         &att);
#379 att->invisible = 1;
#380             nclistpush(dds->attributes,(void*)att);
dapdump.c#43 NCattributeatt = &hdr->gatts[i];
#51 att->name = nulldup(attname);
#52 stat = nc_inq_att(hdr->ncid,NC_GLOBAL,att->name,&nctype,&nvalues);
#54 att->etype = nctypetodap(nctype);
#55  typesize = nctypesizeof(att->etype);
#57 i,att->name,nctypetostring(octypetonc(att->etype)),
#63     stat = nc_get_att(hdr->ncid,NC_GLOBAL,att->name,values);
#71     stat = nc_get_att(hdr->ncid,NC_GLOBAL,att->name,values);
#75 dumpdata1(octypetonc(att->etype),k,values);
#121     NCattributeatt = &var->atts[j];
#129     att->name = nulldup(attname);
#130     stat = nc_inq_att(hdr->ncid,var->varid,att->name,&nctype,&nvalues);
#132     att->etype = nctypetodap(nctype);
#133     typesize = nctypesizeof(att->etype);
#136     stat = nc_get_att(hdr->ncid,var->varid,att->name,values);
#139 j,att->name,nctypetostring(octypetonc(att->etype)),(unsigned long)nvalues);
#142 dumpdata1(octypetonc(att->etype),k,values);
dapparse.c#182    OCnodeatt;
#183    att = newocnode((char*)name,OC_Attribute,state);
#184    att->etype = octypefor(etype);
#185    att->att.values = (OClist*)values;
#186    return att;
#195    attset->att.isglobal = isglobalname(name);
#196    attset->att.isdods = isdodsname(name);
genbin.c#440    varid = (asym->att.var == NULL?NC_GLOBAL : asym->att.var->ncid);
genc.c#1128 (asym->att.var == NULL?"NC_GLOBAL"
#1129               :varncid(asym->att.var)),
#1143 (asym->att.var == NULL?"NC_GLOBAL"
#1144               :varncid(asym->att.var)),
#1165 (asym->att.var == NULL?"NC_GLOBAL"
#1166               :varncid(asym->att.var)),
#1184 (asym->att.var == NULL?"NC_GLOBAL"
#1185               :varncid(asym->att.var)),
#1203 (asym->att.var == NULL?"NC_GLOBAL"
#1204               :varncid(asym->att.var)),
genf77.c#874 (asym->att.var == NULL?"NF_GLOBAL"
#875       :f77varncid(asym->att.var)),
#888 (asym->att.var == NULL?"NF_GLOBAL"
#889       :f77varncid(asym->att.var)),
genj.c#567 if(asym->att.var == NULL) {
#573 jescapifyname(asym->att.var->name),
#582 if(asym->att.var == NULL) {
#590 jescapifyname(asym->att.var->name),
nc4attr.c#35   NC_ATT_INFO_T *att = NULL;
#75   if ((retval = nc4_find_grp_att(grpvaridnorm_namemy_attnum, &att))) {
#85      mem_type = att->nc_typeid;
#91   if (data && att->len &&
#92       ((att->nc_typeid == NC_CHAR && mem_type != NC_CHAR) ||
#93 (att->nc_typeid != NC_CHAR && mem_type == NC_CHAR)))
#98      *lenp = att->len;
#100      *xtype = att->nc_typeid;
#102      *attnum = att->attnum;
#106   if (!att->len)
#116   if (data && att->len && mem_type != att->nc_typeid &&
#119  (att->nc_typeid == NC_UBYTE || att->nc_typeid == NC_BYTE)))
#121      if (!(bufr = malloc((size_t)(att->len * type_size))))
#124      if ((retval = nc4_convert_type(att->databufratt->nc_typeid,
#125      mem_type, (size_t)att->len, &range_error,
#132   (att->nc_typeid == NC_UBYTE || att->nc_typeid == NC_BYTE) &&
#139      bufr = att->data;
#148      if (att->vldata)
#155  if ((retval = nc4_find_type(h5att->nc_typeid, &type)))
#162  for (i = 0; i < att->leni++)
#164     vldest[i].len = att->vldata[i].len;
#167     memcpy(vldest[i].patt->vldata[i].pvldest[i].len * base_typelen);
#170      else if (att->stdata)
#172  for (i = 0; i < att->leni++)
#175            if(att->stdata[i])
#177                if (!(((char **)data)[i] = strdup(att->stdata[i])))
#181                ((char **)data)[i] = att->stdata[i];
#187  if (is_long && att->nc_typeid == NC_INT)
#192     for (i = 0; i < att->leni++)
#196     memcpy(databufr, (size_t)(att->len * type_size));
#217   NC_ATT_INFO_T *att, **attlist = NULL;
#261      attlist = &grp->att;
#267           attlist = &var->att;
#274   for (att = *attlistattatt = att->l.next)
#275     if (!strcmp(att->namenorm_name))
#278   if (!att)
#295         len * nc4typelen(file_type) > (size_t)att->len * nc4typelen(att->nc_typeid))
#328      if ((res = nc4_att_list_add(attlist, &att)))
#330      if (!(att->name = strdup(norm_name)))
#335   att->dirty = NC_TRUE;
#336   att->nc_typeid = file_type;
#339   if (att->stdata)
#341      for (i = 0; i < att->leni++)
#342         if(att->stdata[i])
#343     free(att->stdata[i]);
#344      free(att->stdata);
#345      att->stdata = NULL;
#347   if (att->vldata)
#349      for (i = 0; i < att->leni++)
#350  nc_free_vlen(&att->vldata[i]);
#351      free(att->vldata);
#352      att->vldata = NULL;
#355   att->len = len;
#356   if (att->l.prev)
#357      att->attnum = ((NC_ATT_INFO_T *)att->l.prev)->attnum + 1;
#359      att->attnum = 0;
#365   if (!strcmp(att->name_FillValue) && varid != NC_GLOBAL)
#371      if (att->nc_typeid != var->type_info->nc_typeid)
#373      if (att->len != 1)
#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))) {
#491        if (!new_att && att->data) {
#492          free(att->data);
#493          att->data = NULL;
#496        for (i = 0; i < att->leni++)
#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,
#528   att->dirty = NC_TRUE;
#529   att->created = NC_FALSE;
#597   NC_ATT_INFO_T *att;
#613   if ((retval = nc4_find_nc_att(ncidvaridNULLattnum, &att)))
#618      strcpy(nameatt->name);
#633   NC_ATT_INFO_T *att, *list;
#665      list = grp->att;
#672     list = var->att;
#678   for (att = listattatt = att->l.next)
#679      if (!strncmp(att->namenorm_newnameNC_MAX_NAME))
#685   for (att = listattatt = att->l.next)
#686      if (!strncmp(att->namenorm_nameNC_MAX_NAME))
#688   if (!att)
#693   if (!(h5->flags & NC_INDEF) && strlen(norm_newname) > strlen(att->name) &&
#698   if (att->created)
#702         if (H5Adelete(grp->hdf_grpidatt->name) < 0)
#709         if (H5Adelete(datasetidatt->name) < 0)
#712      att->created = NC_FALSE;
#716   free(att->name);
#717   if (!(att->name = malloc((strlen(norm_newname) + 1) * sizeof(char))))
#719   strcpy(att->namenorm_newname);
#720   att->dirty = NC_TRUE;
#740   NC_ATT_INFO_T *att, *natt;
#775      attlist = &grp->att;
#784     attlist = &var->att;
#795   for (att = *attlistattatt = att->l.next)
#796      if (!strcmp(att->namename))
#800   if (!att)
#804   if (att->created)
#808      if(H5Adelete(locidatt->name) < 0)
#813   for (natt = att->l.nextnattnatt = natt->l.next)
#817   if ((retval = nc4_att_list_del(attlistatt)))
nc4file.c#1003read_hdf5_att(NC_GRP_INFO_T *grphid_t attidNC_ATT_INFO_T *att)
#1015   assert(att->name);
#1017        __func__att->attnumatt->name, (int)att->nc_typeidatt->len));
#1022   if ((att->native_hdf_typeid = H5Tget_native_type(file_typeidH5T_DIR_DEFAULT)) < 0)
#1024   if ((att_class = H5Tget_class(att->native_hdf_typeid)) < 0)
#1026   if (att_class == H5T_STRING && !H5Tis_variable_str(att->native_hdf_typeid))
#1029      if (!(fixed_size = H5Tget_size(att->native_hdf_typeid)))
#1032   if ((retval = get_netcdf_type(grp->nc4_infoatt->native_hdf_typeid, &(att->nc_typeid))))
#1051   else if (att->nc_typeid == NC_STRING)
#1053   else if (att->nc_typeid == NC_CHAR)
#1065         att->nc_typeid = NC_STRING;
#1097   att->len = dims[0];
#1103      if ((retval = nc4_get_typelen_mem(grp->nc4_infoatt->nc_typeid, 0,
#1108  if (!(att->vldata = malloc((unsigned int)(att->len * sizeof(hvl_t)))))
#1110  if (H5Aread(attidatt->native_hdf_typeidatt->vldata) < 0)
#1113      else if (att->nc_typeid == NC_STRING)
#1115  if (!(att->stdata = calloc(att->len, sizeof(char *))))
#1134     if (!(contig_buf = malloc(att->len * fixed_size * sizeof(char))))
#1138     if (H5Aread(attidatt->native_hdf_typeidcontig_buf) < 0) {
#1147     for (i = 0; i < att->leni++)
#1149          if (!(att->stdata[i] = malloc(fixed_size))) {
#1153           strncpy(att->stdata[i], curfixed_size);
#1163     if (H5Aread(attidatt->native_hdf_typeidatt->stdata) < 0)
#1169  if (!(att->data = malloc((unsigned int)(att->len * type_size))))
#1171  if (H5Aread(attidatt->native_hdf_typeidatt->data) < 0)
#1515   NC_ATT_INFO_T *att;
#1787  if ((retval = nc4_att_list_add(&var->att, &att)))
#1791  att->attnum = var->natts++;
#1792  if (!(att->name = strdup(att_name)))
#1797  if ((retval = read_hdf5_att(grpattidatt)))
#1801                if ((retval = nc4_att_list_del(&var->attatt)))
#1809  att->created = NC_TRUE;
#1848   NC_ATT_INFO_T *att;
#1884         if ((retval = nc4_att_list_add(&grp->att, &att)))
#1889  if (!(att->name = malloc((max_len + 1) * sizeof(char))))
#1891         strncpy(att->nameobj_namemax_len);
#1892         att->name[max_len] = 0;
#1893         att->attnum = grp->natts++;
#1894         retval = read_hdf5_att(grpattidatt);
#1896               if((retval = nc4_att_list_del(&grp->attatt)))
#1901             att->created = NC_TRUE;
#1902      if ((retval = nc4_find_type(grp->nc4_infoatt->nc_typeid, &type)))
#2511   NC_ATT_INFO_T *att;
#2550      if ((retval = nc4_att_list_add(&h5->root_grp->att, &att)))
#2552      att->attnum = grp->natts++;
#2553      att->created = NC_TRUE;
#2556      if (!(att->name = malloc(NC_MAX_HDF4_NAME * sizeof(char))))
#2558      if (SDattrinfo(h5->sdidaatt->name, &att_data_type, &att_count))
#2561       &att->nc_typeidNULL)))
#2563      att->len = att_count;
#2566      if ((retval = nc4_get_typelen_mem(h5att->nc_typeid, 0, &att_type_size)))
#2568      if (!(att->data = malloc(att_type_size * att->len)))
#2572      if (SDreadattr(h5->sdidaatt->data))
#2733         if ((retval = nc4_att_list_add(&var->att, &att))) {
#2737  att->attnum = var->natts++;
#2738  att->created = NC_TRUE;
#2741  if (!(att->name = malloc(NC_MAX_HDF4_NAME * sizeof(char)))) {
#2745  if (SDattrinfo(var->sdsidaatt->name, &att_data_type, &att_count)) {
#2750  &att->nc_typeidNULL))) {
#2755  att->len = att_count;
#2758  if ((retval = nc4_get_typelen_mem(h5att->nc_typeid, 0, &att_type_size))) {
#2762  if (!(att->data = malloc(att_type_size * att->len))) {
#2768  if (SDreadattr(var->sdsidaatt->data)) {
#3207   NC_ATT_INFO_T *att;
#3235      for (att = grp->attattatt = att->l.next)
nc4hdf.c#47  NC_ATT_INFO_T *att = NULL;
#53  for(att = *attlistattatt = att->l.next) {
#54    att->dirty = NC_TRUE;
#1289put_att_grpa(NC_GRP_INFO_T *grp, int varidNC_ATT_INFO_T *att)
#1299  assert(att->name);
#1301       __func__varidatt->attnumatt->name,
#1302       att->nc_typeidatt->len));
#1319  if ((attr_exists = H5Aexists(locidatt->name)) < 0)
#1323      if (H5Adelete(locidatt->name) < 0)
#1329  dims[0] = att->len;
#1330  if ((retval = nc4_get_hdf_typeid(grp->nc4_infoatt->nc_typeid,
#1339  else if (att->data)
#1340    data = att->data;
#1341  else if (att->stdata)
#1342    data = att->stdata;
#1344    data = att->vldata;
#1351  if (att->nc_typeid == NC_CHAR)
#1378      if (!att->len)
#1395  if ((attid = H5Acreate(locidatt->namefile_typeidspaceid,
#1420  NC_ATT_INFO_T *att;
#1423  for (att = attlistattatt = att->l.next)
#1425      if (att->dirty)
#1427          LOG((4, "%s: writing att %s to varid %d", __func__att->namevarid));
#1428          if ((retval = put_att_grpa(grpvaridatt)))
#1430          att->dirty = NC_FALSE;
#1431          att->created = NC_TRUE;
#1758  if ((retval = write_attlist(var->attvar->varidgrp)))
#2167      flag_atts_dirty(&var->att);
#2189                flag_atts_dirty(&var->att);
#2344      if ((retval = write_attlist(var->attvar->varidgrp)))
#2562  if ((retval = write_attlist(grp->attNC_GLOBALgrp)))
nc4internal.c#530  NC_ATT_INFO_T **att)
#541      attlist = grp->att;
#548     attlist = var->att;
#559       for (*att = attlist; *att; *att = (*att)->l.next) {
#560           if (name && (*att)->name && !strcmp((*att)->namename))
#562           if (!name && (*att)->attnum == attnum)
#574     NC_ATT_INFO_T **att)
#592      attlist = grp->att;
#599     attlist = var->att;
#608   for (*att = attlist; *att; *att = (*att)->l.next)
#609      if ((name && !strcmp((*att)->namename)) ||
#610   (!name && (*att)->attnum == attnum))
#717nc4_att_list_add(NC_ATT_INFO_T **listNC_ATT_INFO_T **att)
#728   if (att)
#729      *att = new_att;
#1009   NC_ATT_INFO_T *a, *att;
#1019   att = var->att;
#1020   while (att)
#1022      a = att->l.next;
#1023      if ((ret = nc4_att_list_del(&var->attatt)))
#1025      att = a;
#1130   NC_ATT_INFO_T *a, *att;
#1151   att = grp->att;
#1152   while (att)
#1154      LOG((4, "%s: deleting att %s", __func__att->name));
#1155      a = att->l.next;
#1156      if ((retval = nc4_att_list_del(&grp->attatt)))
#1158      att = a;
#1220nc4_att_list_del(NC_ATT_INFO_T **listNC_ATT_INFO_T *att)
#1225   obj_list_del((NC_LIST_NODE_T **)list, (NC_LIST_NODE_T *)att);
#1229   if (att->data)
#1230      free(att->data);
#1233   if (att->name)
#1234      free(att->name);
#1237   if (att->native_hdf_typeid && H5Tclose(att->native_hdf_typeid) < 0)
#1246   if (att->stdata)
#1248      for (i = 0; i < att->leni++)
#1249         if(att->stdata[i])
#1250     free(att->stdata[i]);
#1251      free(att->stdata);
#1255   if (att->vldata)
#1257      for (i = 0; i < att->leni++)
#1258  nc_free_vlen(&att->vldata[i]);
#1259      free(att->vldata);
#1262   free(att);
#1454   NC_ATT_INFO_T *att;
#1471   for(att = grp->attattatt = att->l.next)
#1473    tabsatt->attnumatt->nameatt->nc_typeidatt->len));
#1494      for(att = var->attattatt = att->l.next)
#1496       tabsatt->attnumatt->nameatt->nc_typeidatt->len));
nc4internal.h#167   NC_ATT_INFO_T *att;
#278   NC_ATT_INFO_T *att;
#373     NC_ATT_INFO_T **att);
#377      NC_ATT_INFO_T **att);
#392int nc4_att_list_add(NC_ATT_INFO_T **listNC_ATT_INFO_T **att);
#399int nc4_att_list_del(NC_ATT_INFO_T **listNC_ATT_INFO_T *att);
nc4var.c#645   NC_ATT_INFO_T *att;
#666         for (att = grp->attattatt = att->l.next)
#694      for (att = var->attattatt = att->l.next)
ncd2dispatch.c#801 NCattributeatt = (NCattribute*)nclistget(var->attributes,j);
#802 ncstat = buildattribute(dapcomm,att,var->etype,varid);
#827        NCattributeatt = (NCattribute*)nclistget(root->attributes,i);
#828     ncstat = buildattribute(dapcomm,att,NC_NAT,NC_GLOBAL);
#897buildattribute(NCDAPCOMMONdapcommNCattributeattnc_type vartype, int varid)
#901    unsigned int nvalues = nclistlength(att->values);
#909    if(att->etype == NC_STRING || att->etype == NC_URL) {
#913     char* s = (char*)nclistget(att->values,i);
#922     char* s = (char*)nclistget(att->values,i);
#928     ncstat = nc_put_att_text(dapcomm->nc3id,varid,att->name,1,newstring);
#930     ncstat = nc_put_att_text(dapcomm->nc3id,varid,att->name,strlen(newstring),newstring);
#944        if(varid != NC_GLOBAL && strcmp(att->name,"_FillValue")==0)
#947     atype = nctypeconvert(dapcomm,att->etype);
#955    ncstat = dapcvtattrval(atype,mem,att->values);
#960    ncstat = nc_put_att(dapcomm->nc3id,varid,att->name,atype,nvalues,mem);
ncdump.c#763    ncatt_t att; /* attribute */
#765    NC_CHECKnc_inq_attname(ncidvaridiaatt.name) );
#769        && strcmp(att.name,NCPROPS)==0)
#772    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#773    att.tinfo = get_typeinfo(att.type);
#778    if (is_user_defined_type(att.type) || att.type == NC_STRING)
#780    if (is_user_defined_type(att.type))
#786 get_type_name(ncidatt.typeatt_type_name);
#790 print_type_name(ncidatt.type);
#798    print_name(att.name);
#801    if (att.len == 0) { /* show 0-length attributes as empty strings */
#802 att.type = NC_CHAR;
#805    if (! is_user_defined_type(att.type) ) {
#806 att.valgp = (void *) emalloc((att.len + 1) * att.tinfo->size );
#807 NC_CHECKnc_get_att(ncidvaridatt.nameatt.valgp ) );
#808 if(att.type == NC_CHAR) /* null-terminate retrieved text att value */
#809     ((char *)att.valgp)[att.len] = '\0';
#811        pr_att_valgs(kindatt.typeatt.lenatt.valgp);
#818     print_att_times(ncidvarid, &att);
#819     if(is_bounds_att(&att)) {
#820 insert_bounds_info(ncidvarid, &att);
#825 if(att.type == NC_STRING) {
#826     nc_free_string(att.lenatt.valgp);
#829 free(att.valgp);
#840       NC_CHECKnc_inq_user_type(ncidatt.type,  type_name, &type_size,
#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);
#873    for (i = 0; i < att.leni++) {
#875        printf("%s%s", souti < att.len-1 ? ", " : "");
#883    for (i = 0; i < att.leni++) {
#914        NC_CHECKnc_inq_enum_ident(ncidatt.typevalue,
#918        printf("%s", i < att.len-1 ? ", " : "");
#923    pr_any_att_vals(&attdata);
#1139    ncatt_t att; /* attribute */
#1143    NC_CHECKnc_inq_attname(ncidvaridiaatt.name) );
#1147        && strcmp(att.name,NCPROPS)==0
#1153    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#1157    switch (att.type) {
#1159 attvals = (char *) emalloc(att.len + 1);
#1160 attvalslen = att.len;
#1161 attvals[att.len] = '\0';
#1162 NC_CHECKnc_get_att_text(ncidvaridatt.nameattvals ) );
#1168 attvals = (char *) emalloc(att.len + 1);
#1169 attvals[att.len] = '\0';
#1170 NC_CHECKnc_get_att_text(ncidvaridatt.nameattvals ) );
#1183 att.vals = (double *) emalloc((att.len + 1) * sizeof(double));
#1184 NC_CHECKnc_get_att_double(ncidvaridatt.nameatt.vals ) );
#1185 attvalslen = PRIM_LEN * att.len; /* max chars for each value and blank separator */
#1187 pr_att_valsx(att.typeatt.lenatt.valsattvalsattvalslen);
#1188 free(att.vals);
#1193    if(att.type == NC_CHAR
#1195                          || att.type == NC_CHAR
#1201 att.name);
#1203 pr_attx_string(att.nameattvalslenattvals);
#1206 get_type_name(ncidatt.typeatt_type_name);
#1210 att.name,
#1417    ncatt_t att; /* attribute */
#1424    nc_status = nc_inq_att(ncid,varid,_FillValue,&att.type,&att.len);
#1427       att.type == vp->type && att.len == 1) {
ncgen.h#212        Attrinfo  att;
ncgeny.c#3418        asym->att.var = vsym;
#3424        asym->att.var = NULL; /* NULL => NC_GLOBAL*/
nctime0.c#277    const ncatt_t *att /* attribute structure */
#280    nc_type type = att->type; /* local copy */
#295    assert (att->len > 0); /* should already be eliminated by caller */
#317 const char *valp = (const char *)att->valgp;  /* attrib value pointer */
#326 var.type = att->type; /* insert attrib type into fake var */
#328 for (iel = 0; iel < att->leniel++) {
#330     valp += att->tinfo->size; /* increment value pointer, by type */
#331     if (iel < att->len - 1) /* add comma, except for final value */
#336            wrap = (att->len > 2); /* specify line wrap variations:     */
nctime0.h#14extern void print_att_times(int ncid, int varid, const ncatt_t *att);
oc.c#240            *nattrp = oclistlength(node->att.values);
#379            *nattrp = oclistlength(node->att.values);
#786    if(nvaluesp) *nvaluesp = oclistlength(attr->att.values);
#821    nvalues = oclistlength(attr->att.values);
#824    if(valuep) *valuep = nulldup((char*)oclistget(attr->att.values,index));
ocdump.c#144 for(n=0;n<oclistlength(node->att.values);n++) {
#145     char* value = (char*)oclistget(node->att.values,n);
#168     OCattributeatt = (OCattribute*)oclistget(node->attributes,i);
#169     fprintf(stdout,"%s[%s=",dent2(depth+2),att->name);
#170     if(att->nvalues == 0)
#172     if(att->nvalues == 1) {
#173 dumpattvalue(att->etype,att->values,0);
#177 for(j=0;j<att->nvalues;j++) {
#179     dumpattvalue(att->etype,att->values,j);
ocnode.c#133    OCattributeatt = (OCattribute*)ocmalloc(sizeof(OCattribute)); /* ocmalloc zeros*/
#134    MEMCHECK(att,(OCattribute*)NULL);
#135    att->name = nulldup(name);
#136    att->etype = ptype;
#137    att->nvalues = oclistlength(values);
#138    att->values = NULL;
#139    if(att->nvalues > 0) {
#141        att->values = (char**)ocmalloc(sizeof(char*)*att->nvalues);
#142        for(i=0;i<att->nvalues;i++)
#143     att->values[i] = nulldup((char*)oclistget(values,(size_t)i));
#145    return att;
#197        while(oclistlength(node->att.values) > 0) {
#198     char* value = (char*)oclistpop(node->att.values);
#218        if(node->att.values != NULLoclistfree(node->att.values);
#273 if(das->name == NULL || das->att.isglobal) {
#277 if(das->att.isdods) {
#365     OCattributeatt = makeattribute(attnode->name,
#367 attnode->att.values);
#368            oclistpush(dds->attributes,(void*)att);
#388     OCattributeatt;
#401     att = makeattribute(newname,attnode->etype,attnode->att.values);
#403            oclistpush(dds->attributes,(void*)att);
#413    OCattributeatt = NULL;
#422        att = makeattribute(das->fullname,das->etype,das->att.values);
#423        oclistpush(root->attributes,(void*)att);
#572 if(node->att.isglobal) {
#575 Attributeatt = makeattribute(attnode->name,
#577 attnode->att.values);
#578 oclistpush(globals,(void*)att);
#587        if(das->att.isglobal) continue;
#616     Attributeatt = makeattribute(attnode->name,
#618 attnode->att.values);
#619            oclistpush(dds->attributes,(void*)att);
ocnode.h#55    OCattinfo       att;       /* octype == OC_Attribute */
ocutil.c#96 OCattributeatt = (OCattribute*)oclistget(attset,i);
#97 if(att->name != NULL) free(att->name);
#98 if(att->etype == OC_String || att->etype == OC_URL) {
#99     for(j=0;j<att->nvalues;j++) {
#100 char* s = ((char**)att->values)[j];
#104     free(att->values);
semantics.c#426 Symbolatt = (Symbol*)listget(attdefs,i);
#427 if(att->data != NULL && listlength(att->data) > 0)
#428     processeconstrefsR(att->data);
#749     asym->typ.basetype = asym->att.var->typ.basetype; /* its basetype is same as its var*/
#755     asym->att.var->var.special._Fillvalue = asym->data;
#776     if(asym->att.var == NULL)
#778     if(asym->att.var != vsym) continue;
tst_atts1.c#953      int ncidatt = 1;
#958      if (nc_put_att(ncidNC_GLOBALATT_1NC_INT, 1, &att)) ERR;
#959      if (nc_put_att(ncidNC_GLOBALATT_2NC_INT, 1, &att)) ERR;
#960      if (nc_put_att(ncidNC_GLOBALATT_3NC_INT, 1, &att)) ERR;
tst_atts3.c#749      int ncidatt = 1;
#758      if (nc_put_att(ncidNC_GLOBALATT_1NC_INT, 1, &att)) ERR;
#759      if (nc_put_att(ncidNC_GLOBALATT_2NC_INT, 1, &att)) ERR;
#760      if (nc_put_att(ncidNC_GLOBALATT_3NC_INT, 1, &att)) ERR;
tst_small.c#93   char att[MAX_LEN + 1], att_in[MAX_LEN + 1], source[MAX_LEN + 1] = "0123456";
#106  strncpy(attsourcet);
#110  if (nc_put_att_text(ncidNC_GLOBALATT_NAMEt + 1, att)) ERR;
#121  if (strncmp(att_inattt)) ERR;
util.c#121 if(asym->att.basetype == primsymbols[NC_STRING])
#122       reclaimattptrs(asym->att.data,asym->att.count);
#124     efree(asym->att.data);
util.c#783    double att[MAX_NELS];
#798     att[k] = hash(ATT_TYPE(i,j), -1, &k);
#799     allInRange = allInRange && inRange(att[k], ATT_TYPE(i,j));
#802     ATT_TYPE(i,j), ATT_LEN(i,j), att);


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