add.c#38    test->dims[test->ndims].name = (char *) emalloc(strlen(idim->name) + 1);
#39    (void) strcpy(test->dims[test->ndims].nameidim->name);
#59    test->vars[test->nvars].name = (char *) emalloc(strlen(ivar->name) + 1);
#60    (void) strcpy(test->vars[test->nvars].nameivar->name);
#88     strcmp(test->atts[ia].nameiatt->name) == 0) {
#97    test->atts[test->natts].name = (char *) emalloc(strlen(iatt->name) + 1);
#98    (void) strcpy(test->atts[test->natts].nameiatt->name);
#133     strcmp(test->atts[ia].nameiatt->name) == 0) {
#134     free(test->atts[ia].name);
#137 test->atts[ib-1].name =  test->atts[ib].name;
#152    test->vars[varid].nameiatt->name);
#202    varp->nametypes);
attr.c#30 free_NC_string(attrp->name);
#91 attrp->name = strp;
#116 char *name = (char *)utf8proc_NFC((const unsigned char *)uname);
#117 if(name == NULL)
#119 assert(name != NULL && *name != 0);
#121 strp = new_NC_string(strlen(name), name);
#122 free(name);
#140 NC_attr *attrp = new_NC_attr(rattrp->name->cp,
#341 char *name;
#351 name = (char *)utf8proc_NFC((const unsigned char *)uname);
#352 if(name == NULL)
#354 slen = strlen(name);
#358 if(strlen((*attrpp)->name->cp) == slen &&
#359 strncmp((*attrpp)->name->cpnameslen) == 0)
#361         free(name);
#365 free(name);
#376 const char *name, /* attribute name */
#394 tmp = NC_findattr(ncapname);
#407NC3_inq_attname(int ncid, int varid, int attnum, char *name)
#428 (void) strncpy(nameattrp->name->cpattrp->name->nchars);
#429 name[attrp->name->nchars] = 0;
#436NC3_inq_attid(int ncid, int varid, const char *name, int *attnump)
#454 attrpp = NC_findattr(ncapname);
#467 const char *name, /* input, attribute name */
#474 status = NC_lookupattr(ncidvaridname, &attrp);
#488NC3_rename_att( int ncid, int varid, const char *name, const char *unewname)
#516 tmp = NC_findattr(ncapname);
#528 old = attrp->name;
#538 attrp->name = newStr;
#585 char *name = (char *)utf8proc_NFC((const unsigned char *)uname);
#586 if(name == NULL)
#590 slen = strlen(name);
#595 if( slen == (*attrpp)->name->nchars &&
#596 strncmp(name, (*attrpp)->name->cpslen) == 0)
#602 free(name);
#1382 const char *name,
#1426    attrpp = NC_findattr(ncapname);
#1468    status = NC_check_name(name);
#1471    attrp = new_NC_attr(nametypenelems);
#1501 const char *name,
#1509    status = NC_lookupattr(ncidvaridname, &attrp);
atttests.c#98 if (ncattput(cdfidNC_GLOBALatts[ia].nameatts[ia].type,
#117 if (ncattinq(cdfidNC_GLOBALatts[ia].name,
#129 if (ncattget(cdfidNC_GLOBALatts[ia].nametmp.val) == -1) {
#145    ww.nameww.typeww.ndimsww.dims)) == -1) {
#152       atts[ia].nameatts[ia].typeatts[ia].lenatts[ia].val)
#161 if (ncattinq(cdfidww_idatts[ia].name,
#173 if (ncattget(cdfidww_idatts[ia].nametmp.val) == -1) {
#189    tmp.name = (char *) emalloc(MAX_NC_NAME);
#191 if (ncattput(cdfidww_idatts[ia-1].nameatts[ia].type,
#197 (void) strcpy (tmp.nameatts[ia-1].name);
#205 if (ncattinq(cdfidww_idatts[ia-1].name,
#217 if (ncattget(cdfidww_idatts[ia-1].nametmp.val) == -1) {
#245    if (ncattput(cdfidww_idatts[0].nameatts[0].type,
#251 if (ncattput(cdfidww_idatts[0].nameatts[0].type,
#270 if (ncattput(cdfidww_idatts[ia+1].nameatts[ia].type,
#277 (void) strcpy (tmp.nameatts[ia+1].name);
#285 if (ncattinq(cdfidww_idatts[ia+1].name, &tmp.type, &tmp.len)
#298 if (ncattget(cdfidww_idatts[ia+1].nametmp.val) == -1) {
#310    if (ncattput(cdfidtest.nvarsatts[0].nameatts[0].typeatts[0].len,
#320    if (ncattput(cdfidww_idatts[0].nameatts[0].typeatts[0].len,
#325    free(tmp.name);
#365 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#392    if ((vv_id = ncvardef(cdfidvv.namevv.typevv.ndimsvv.dims))
#405    if (ncattinq(cdfidtest.nvarstest.atts[0].name, &type, &len) != -1) {
#411 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#436    if (ncattinq(cdfidNC_GLOBALtest.atts[0].name, &type, &len) != -1) {
#491    uu.nameuu.typeuu.ndimsuu.dims)) == -1) {
#499   vmax.namevmax.typevmax.lenvmax.val)
#508 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#524 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#533   cdfidtest.vars[test.atts[ia].var].name,
#534   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#551 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#569 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#578   cdfidtest.vars[test.atts[ia].var].name,
#579   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#590    if (ncattget(cdfidtest.nvarsvmax.namevmax.val) != -1) {
#604    if (ncattget(cdfiduu_idvmax.namevmax.val) != -1) {
#665    if (ncattput(cdfidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#673    if ((tt_id=ncvardef(cdfidtt.namett.typett.ndimstt.dims)) == -1) {
#678    if (ncattput(cdfidtt_idatt.nameatt.typeatt.lenatt.val) == -1) {
#687    if ((tu_id=ncvardef(cdfidtu.nametu.typetu.ndimstu.dims)) == -1) {
#692    if (ncattput(cdfidtu_idatt.nameatt.typeatt.lenatt.val) == -1) {
#712 if ((tu.dims[id] =ncdimdef(cdfid2test.dims[id].name,
#718    if ((tu2_id=ncvardef(cdfid2tu.nametu.typetu.ndimstu.dims)) == -1) {
#723    if (ncattcopy(cdfidNC_GLOBALatt.namecdfid2NC_GLOBAL) == -1) {
#725       pnameatt.name);
#729    if (ncattinq(cdfid2NC_GLOBALatt.name, &tmp.type, &tmp.len) == -1) {
#739    if (ncattget(cdfid2NC_GLOBALatt.nametmp.val) == -1) {
#750    if (ncattcopy(cdfidtt_idatt.namecdfid2tu2_id) == -1) {
#755    if (ncattinq(cdfid2tu2_idatt.name, &tmp.type, &tmp.len) == -1) {
#765    if (ncattget(cdfid2tu2_idatt.nametmp.val) == -1) {
#785    if (ncattput(cdfidNC_GLOBALatt2.nameatt2.typeatt2.lenatt2.val)
#792    if (ncattcopy(cdfidNC_GLOBALatt2.namecdfid2tu2_id) == -1) {
#798    if (ncattinq(cdfid2tu2_idatt2.name, &tmp.type, &tmp.len) == -1) {
#808    if (ncattget(cdfid2tu2_idatt2.nametmp.val) == -1) {
#821    if (ncattcopy(cdfidNC_GLOBALatt2.namecdfidtu_id) == -1) {
#827    if (ncattinq(cdfidtu_idatt2.name, &tmp.type, &tmp.len) == -1) {
#837    if (ncattget(cdfidtu_idatt2.nametmp.val) == -1) {
#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) {
#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)
#991    tmp.name = (char *) emalloc(MAX_NC_NAME);
#992    if (ncattname(cdfidNC_GLOBALtest.ngatts-1, tmp.name) == -1) {
#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) {
#1076    free (tmp.name);
#1077    free (att.name);
#1125    if (ncattput(cdfidNC_GLOBALatty.nameatty.typeatty.len,
#1132    if (ncattput(cdfidNC_GLOBALattz.nameattz.typeattz.len,
#1140    if (ncattrename(cdfidNC_GLOBALatty.namenewname) == -1) {
#1144    (void) strcpy(test.atts[ynum].namenewname); /* keep test consistent */
#1165    if (ncattinq(cdfidNC_GLOBALatty.name, &tmp.type, &tmp.len) != -1) {
#1170    if (ncattrename(cdfidNC_GLOBALattz.namenewname) != -1) {
#1175    if (ncattrename(cdfidNC_GLOBALattz.namelongername) == -1) {
#1180    if (ncattrename(cdfidtest.nvarsnewnameatty.name) != -1) {
#1218    if (ncattrename(cdfidNC_GLOBALnewnameatty.name) != -1) {
#1274    if (ncattput(cdfidNC_GLOBALyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1282    if ((yav_id=ncvardef(cdfidyav.nameyav.typeyav.ndimsyav.dims))
#1288    if (ncattput(cdfidyav_idyaa.nameyaa.typeyaa.lenyaa.val) == -1) {
#1300    vtmp.name = (char *) emalloc(MAX_NC_NAME);
#1301    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndimsvtmp.dims,
#1308    if (ncattdel(cdfidNC_GLOBALyaa.name) == -1) {
#1322    if (ncattinq(cdfidNC_GLOBALyaa.name, &atmp.type, &atmp.len) != -1) {
#1328    if (ncattdel(cdfidyav_idyaa.name) == -1) {
#1333    if (ncvarinq(cdfidyav_idvtmp.name, &vtmp.type, &vtmp.ndims,
#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) {
#1365    if (ncattdel(cdfidtest.nvarsyaa.name) != -1) {
#1374    if (ncattdel(cdfidNC_GLOBALyaa.name) != -1) {
#1383    if (ncattdel(cdfidyav_idyaa.name) != -1) {
#1388    free(vtmp.name);
bm_file.c#189file_size(char* name)
#192   stat(name, &stbuf);
#204   char name[NC_MAX_NAME + 1];
#209   if ((ret = nc_inq_attname(ncid1varidaname)))
#211   if ((ret = nc_inq_att(ncid1varidname, &typeid, &len)))
#213   if ((ret = nc_inq_att(ncid2varidname, &typeid2, &len2)))
#230      if ((ret = nc_get_att(ncid1varidnamed)))
#232      if ((ret = nc_get_att(ncid2varidnamed2)))
#258   char name[NC_MAX_NAME + 1], name2[NC_MAX_NAME + 1];
#321      if ((ret = nc_inq_dim(ncid1dname, &len)))
#325      if (len != len2 || strcmp(namename2))
#338      if ((ret = nc_inq_var(ncid1vname, &xtype, &ndimsdimids, &natts)))
#344      if (strcmp(namename2) || xtype != xtype2 || ndims != ndims2 || natts != natts2)
#471   char name[NC_MAX_NAME + 1];
#542  if ((ret = nc_inq_dim(ncid_indname, &len)))
#546     if ((ret = nc_def_dim(ncid_outnamelenNULL)))
#551     if ((ret = nc_def_dim(ncid_outname,
#561  if (nc_inq_attname(ncid_inNC_GLOBALaname)) ERR;
#562  if (nc_copy_att(ncid_inNC_GLOBALnamencid_outNC_GLOBAL)) ERR;
#568  char name[NC_MAX_NAME + 1];
#577  if ((ret = nc_inq_var(ncid_invname, &xtype, &ndimsdimids, &natts)))
#581  if (nc_def_var(ncid_outnamextypendimsdimids, &varid_out)) ERR;
#638      char name[NC_MAX_NAME + 1];
#654      if ((ret = nc_inq_var(ncid_invname, &xtype, &ndimsdimids, &natts)))
cdf.c#1095     nullfree(att->name);
cdftests.c#270    if ((ii_dim = ncdimdef(ncidii.nameii.size)) == -1) {
#279    if ((aa_id = ncvardef(ncidaa.nameaa.type,
#288    if (ncattput(ncidaa_units.varaa_units.name,
#360    if ((jj_dim = ncdimdef(ncidjj.namejj.size)) == -1 ||
#361 (kk_dim = ncdimdef(ncidkk.namekk.size)) == -1) {
#372    if ((bb_id = ncvardef(ncidbb.namebb.type,
#380    if (ncattput(ncidbb_idbb_range.namebb_range.typebb_range.len,
#547 if ((dimids[id] = ncdimdef(nciddims[id].namedims[id].size))
#556    if ((rec_dim = ncdimdef(ncidrec.namerec.size)) == -1) {
#568 if ((cc_id = ncvardef(ncidcc[iv].namecc[iv].type,
#576 if (ncattput(ncidcc_idcc_units.namecc_units.type,
#671    if ((ll_dim = ncdimdef(ncid0ll.namell.size)) == -1) {
#680    if ((dd_id=ncvardef(ncid0dd.namedd.typedd.ndimsdd.dims)) == -1) {
#687    if (ncattput(ncid0dd_iddd_fill_val.namedd_fill_val.type,
#806    if (ncattput(ncidNC_GLOBALatt.nameatt.typeatt.lenatt.val) == -1) {
#821    if (ncattinq(ncidNC_GLOBALatt.name, &att.type, &att.len) != -1) {
constraints.c#184        seg->name = nulldup(node->ocname);
#252        if(strcmp(node->ocname,lastseg->name) != 0)
#264        nclog(NCLOGERR,"No match for projection name: %s",lastseg->name);
#286        nclog(NCLOGERR,"No match for projection name: %s",lastseg->name);
#316 lastseg->name);
#361 if(strcmp(seg->name,node->ocname) != 0) {
#711        segment->name = nulldup(n->ocname);
dapalign.c#196padname(char* name)
#199    if(name == NULLname = "null";
#200    int len = strlen(name);
#205    strncpy(s,name,len);
dapattr.c#120buildattribute(char* namenc_type ptype,
#129    att->name = nulldup(name);
#426isglobalname(char* name)
#428    int len = strlen(name);
#432    p = name + (len - glen);
dapdump.c#51 att->name = nulldup(attname);
#52 stat = nc_inq_att(hdr->ncid,NC_GLOBAL,att->name,&nctype,&nvalues);
#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);
#87                   hdr->dims[i].name,
#91 i,hdr->dims[i].name,(unsigned long)hdr->dims[i].size);
#101                   var->name,
#110 var->name,
#129     att->name = nulldup(attname);
#130     stat = nc_inq_att(hdr->ncid,var->varid,att->name,&nctype,&nvalues);
#136     stat = nc_get_att(hdr->ncid,var->varid,att->name,values);
#139 j,att->name,nctypetostring(octypetonc(att->etype)),(unsigned long)nvalues);
dapdump.h#12    char name[NC_MAX_NAME+1];
#18    char name[NC_MAX_NAME+1];
daplex.c#363dapdecode(DAPlexstatelexstate, char* name)
#367    decoded = ocuridecode(name);
#369    decoded = ocuridecodeonly(name,decodelist);
dapparse.c#13static int isglobalname(const char* name);
#14static int isdodsname(const char* name);
#15static OCnodenewocnode(char* nameOCtype octypeDAPparsestatestate);
#43dap_datasetbody(DAPparsestatestateObject nameObject decls)
#45    OCnoderoot = newocnode((char*)name,OC_Dataset,state);
#54        dap_parse_error(state,"Duplicate dataset field names: %s",name,dupname);
#138dap_arraydecl(DAPparsestatestateObject nameObject size)
#146    if(name != NULL)
#147 dim = newocnode((char*)name,OC_Dimension,state);
#180dap_attribute(DAPparsestatestateObject nameObject valuesObject etype)
#183    att = newocnode((char*)name,OC_Attribute,state);
#190dap_attrset(DAPparsestatestateObject nameObject attributes)
#193    attset = newocnode((char*)name,OC_Attributeset,state);
#195    attset->att.isglobal = isglobalname(name);
#196    attset->att.isdods = isdodsname(name);
#203isglobalname(const char* name)
#205    int len = strlen(name);
#209    p = name + (len - glen);
#216isdodsname(const char* name)
#218    size_t len = strlen(name);
#221    if(ocstrncmp(name,"DODS",glen) != 0)
#247 if(dim->name == NULL) {
#249     dim->name = dimnameanon(node->name,i);
#258    char name[64];
#259    sprintf(name,"%s_%d",basename,index);
#260    return strdup(name);
#264dap_makebase(DAPparsestatestateObject nameObject etypeObject dimensions)
#267    node = newocnode((char*)name,OC_Atomic,state);
#274dap_makestructure(DAPparsestatestateObject nameObject dimensionsObject fields)
#280        dap_parse_error(state,"Duplicate structure field names in same structure: %s",(char*)name);
#284    node = newocnode(name,OC_Structure,state);
#292dap_makesequence(DAPparsestatestateObject nameObject members)
#298        dap_parse_error(state,"Duplicate sequence member names in same sequence: %s",(char*)name);
#301    node = newocnode(name,OC_Sequence,state);
#308dap_makegrid(DAPparsestatestateObject nameObject arraydeclObject mapdecls)
#315        dap_parse_error(state,"Duplicate grid map names in same grid: %s",(char*)name);
#319    node = newocnode(name,OC_Grid,state);
#383newocnode(char* nameOCtype octypeDAPparsestatestate)
#385    OCnodenode = ocnode_new(name,octype,state->root);
#413     if(strcmp(io->name,jo->name)==0) {
dapparselex.h#58extern Object dap_datasetbody(DAPparsestate*,Object declsObject name);
#61extern Object dap_arraydecl(DAPparsestate*,Object nameObject size);
#66extern Object dap_attribute(DAPparsestate*,Object nameObject valueObject etype);
#67extern Object dap_attrset(DAPparsestate*,Object nameObject attributes);
#70extern Object dap_makebase(DAPparsestate*,Object nameObject etypeObject dimensions);
#71extern Object dap_makestructure(DAPparsestate*,Object nameObject dimensionsObject fields);
#72extern Object dap_makesequence(DAPparsestate*,Object nameObject members);
#73extern Object dap_makegrid(DAPparsestate*,Object nameObject arraydeclObject mapdecls);
daputil.c#22static char* repairname(const char* name, const char* badchars);
#71cdflegalname(char* name)
#73    return repairname(name,"/");
#375    char* name;
#385        oc_dds_name(conn,node,&name);
#386 return nulldup(name);
#397 char* name;
#399        oc_dds_name(conn,node,&name);
#401 ncbytescat(pathname,name);
#402 nullfree(name);
#430 char* name;
#433                name = node->ncbasename;
#434 assert(name != NULL);
#436                ncbytescat(pathname,name);
#478 char* name = (char*)nclistget(names,i);
#479 len += strlen(name);
#784dap_badname(char* name)
#787    if(name == NULL) return 0;
#789        if(strchr(name,*p) != NULL)
#797dap_repairname(char* name)
#800    return repairname(name,baddapchars);
#810repairname(const char* name, const char* badchars)
#817    if(name == NULL) return NULL;
#818    newname = (char*)malloc(1+(3*strlen(name))); /* max needed */
#820    for(p=name,q=newname;(c=*p);p++) {
daputil.h#83extern int dap_badname(char* name);
#84extern char* dap_repairname(char* name);
datt.c#107nc_rename_att(int ncid, int varid, const char *name, const char *newname)
#113   return ncp->dispatch->rename_att(ncidvaridnamenewname);
#158nc_del_att(int ncid, int varid, const char *name)
#164   stat = ncp->dispatch->del_att(ncidvaridname);
dattget.c#44nc_get_att(int ncid, int varid, const char *name, void *value)
#54   if ((stat = nc_inq_atttype(ncidvaridname, &xtype)))
#58   return ncp->dispatch->get_att(ncidvaridnamevaluextype);
#137nc_get_att_text(int ncid, int varid, const char *name, char *value)
#143   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_CHAR);
#147nc_get_att_schar(int ncid, int varid, const char *name, signed char *value)
#153   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_BYTE);
#157nc_get_att_uchar(int ncid, int varid, const char *name, unsigned char *value)
#163   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UBYTE);
#167nc_get_att_short(int ncid, int varid, const char *name, short *value)
#173   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_SHORT);
#177nc_get_att_int(int ncid, int varid, const char *name, int *value)
#183   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_INT);
#187nc_get_att_long(int ncid, int varid, const char *name, long *value)
#193   return ncp->dispatch->get_att(ncidvaridname, (void *)valuelongtype);
#197nc_get_att_float(int ncid, int varid, const char *name, float *value)
#203   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_FLOAT);
#207nc_get_att_double(int ncid, int varid, const char *name, double *value)
#213   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_DOUBLE);
#217nc_get_att_ubyte(int ncid, int varid, const char *name, unsigned char *value)
#223   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UBYTE);
#227nc_get_att_ushort(int ncid, int varid, const char *name, unsigned short *value)
#233   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_USHORT);
#237nc_get_att_uint(int ncid, int varid, const char *name, unsigned int *value)
#243   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UINT);
#247nc_get_att_longlong(int ncid, int varid, const char *name, long long *value)
#253   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_INT64);
#257nc_get_att_ulonglong(int ncid, int varid, const char *name, unsigned long long *value)
#263   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UINT64);
#341nc_get_att_string(int ncid, int varid, const char *name, char **value)
#347    return ncp->dispatch->get_att(ncid,varid,name,(void*)valueNC_STRING);
dattinq.c#72nc_inq_att(int ncid, int varid, const char *namenc_type *xtypep,
#78   return ncp->dispatch->inq_att(ncidvaridnamextypeplenp);
#101nc_inq_attid(int ncid, int varid, const char *name, int *idp)
#106   return ncp->dispatch->inq_attid(ncidvaridnameidp);
#129nc_inq_attname(int ncid, int varid, int attnum, char *name)
#134   return ncp->dispatch->inq_attname(ncidvaridattnumname);
#174nc_inq_atttype(int ncid, int varid, const char *namenc_type *xtypep)
#179   return ncp->dispatch->inq_att(ncidvaridnamextypepNULL);
#200nc_inq_attlen(int ncid, int varid, const char *name, size_t *lenp)
#205   return ncp->dispatch->inq_att(ncidvaridnameNULLlenp);
dattput.c#50nc_put_att_string(int ncid, int varid, const char *name,
#56    return ncp->dispatch->put_att(ncidvaridnameNC_STRING,
#138int nc_put_att_text(int ncid, int varid, const char *name,
#144   return ncp->dispatch->put_att(ncidvaridnameNC_CHARlen,
#229nc_put_att(int ncid, int varid, const char *namenc_type xtype,
#235   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#240nc_put_att_schar(int ncid, int varid, const char *name,
#246   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#251nc_put_att_uchar(int ncid, int varid, const char *name,
#257   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#262nc_put_att_short(int ncid, int varid, const char *name,
#268   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#273nc_put_att_int(int ncid, int varid, const char *name,
#279   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#284nc_put_att_long(int ncid, int varid, const char *name,
#290   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#295nc_put_att_float(int ncid, int varid, const char *name,
#301   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#306nc_put_att_double(int ncid, int varid, const char *name,
#312   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#317nc_put_att_ubyte(int ncid, int varid, const char *name,
#323   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#328nc_put_att_ushort(int ncid, int varid, const char *name,
#334   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#339nc_put_att_uint(int ncid, int varid, const char *name,
#345   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#350nc_put_att_longlong(int ncid, int varid, const char *name,
#357   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#362nc_put_att_ulonglong(int ncid, int varid, const char *name,
#369   return ncp->dispatch->put_att(ncidvaridnamextypelen,
dceconstraints.c#363        clone->name = nulldup(orig->name);
#379        clone->name = nulldup(orig->name);
#473        nullfree(target->name);
#516        nullfree(target->name);
#636 char* name = (segment->name?segment->name:"<unknown>");
#637 name = nulldup(name);
#638 ncbytescat(buf,name);
#639 nullfree(name);
#657        ncbytescat(buf,fcn->name);
#963 if(strcmp(s1->name,s2->name) != 0) return 0;
#1073 char* name = (segment->name?segment->name:"<unknown>");
#1075 ncbytescat(buf,name);
#1100        ncbytescat(buf,fcn->name);
dceconstraints.h#33    char* name;
#43    char* name;
dceparse.c#92segment(DCEparsestatestateObject nameObject slices0)
#97    segment->name = strdup((char*)name);
#218indexer(DCEparsestatestateObject nameObject indices)
#223    seg->name = strdup((char*)name);
#237    fcn->name = nulldup((char*)fcnname);
dceparselex.h#68extern Object segment(DCEparsestatestateObject nameObject slices0);
#74extern Object arrayelement(DCEparsestatestateObject nameObject index);
#80extern Object indexer(DCEparsestatestateObject nameObject indices);
dcompound.c#63nc_def_compound(int ncid, size_t size, const char *name,
#69   return ncp->dispatch->def_compound(ncid,size,name,typeidp);
#99nc_insert_compound(int ncidnc_type xtype, const char *name,
#105   return ncp->dispatch->insert_compound(ncidxtypename,
#141nc_insert_array_compound(int ncidnc_type xtype, const char *name,
#148   return ncp->dispatch->insert_array_compound(ncid,xtype,name,offset,field_typeid,ndims,dim_sizes);
#175nc_inq_compound(int ncidnc_type xtype, char *name,
#179   int stat = nc_inq_user_type(ncid,xtype,name,sizep,NULL,nfieldsp,&class);
#203nc_inq_compound_name(int ncidnc_type xtype, char *name)
#205   return nc_inq_compound(ncid,xtype,name,NULL,NULL);
#288       char *name, size_t *offsetp,
#296     nameoffsetpfield_typeidp,
#322   char *name)
#328     nameNULLNULLNULL,
#475nc_inq_compound_fieldindex(int ncidnc_type xtype, const char *name,
#481   return ncp->dispatch->inq_compound_fieldindex(ncid,xtype,name,fieldidp);
dcopy.c#255   char name[NC_MAX_NAME + 1];
#273   if ((retval = nc_inq_var(ncid_invarid_inname, &xtype,
#313   if ((retval = nc_def_var(ncid_outnamextype,
#481NC_copy_att(int ncid_in, int varid_in, const char *name,
#490 ncid_invarid_inname));
#493   if ((res = nc_inq_att(ncid_invarid_inname, &xtype, &len)))
#508      res = nc_get_att(ncid_invarid_innamedata);
#510  res = nc_put_att(ncid_outvarid_outnamextype,
#522      res = nc_get_att_string(ncid_invarid_innamestr_data);
#524  res = nc_put_att_string(ncid_outvarid_outnamelen,
#554     if ((res = nc_get_att(ncid_invarid_innamevldata)))
#556     if ((res = nc_put_att(ncid_outvarid_outnamextype_out,
#568     res = nc_get_att(ncid_invarid_innamedata);
#570        res = nc_put_att(ncid_outvarid_outnamextype_outlendata);
#591nc_copy_att(int ncid_in, int varid_in, const char *name,
#611      retval = nc_inq_attid(ncid_outvarid_outname, &target_attid);
#615  return NC_copy_att(ncid_invarid_innamencid_outvarid_out);
#626     return NC_copy_att(ncid_invarid_innamencid_outvarid_out);
#634        if ((retval = NC_copy_att(ncid_invarid_innamencid_outvarid_out)))
#651      return NC_copy_att(ncid_invarid_innamencid_outvarid_out);
ddim.c#124nc_def_dim(int ncid, const char *name, size_t len, int *idp)
#130    return ncp->dispatch->def_dim(ncidnamelenidp);
#154nc_inq_dimid(int ncid, const char *name, int *idp)
#160    return ncp->dispatch->inq_dimid(ncid,name,idp);
#218nc_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
#224    return ncp->dispatch->inq_dim(ncid,dimid,name,lenp);
#280nc_rename_dim(int ncid, int dimid, const char *name)
#286    return ncp->dispatch->rename_dim(ncid,dimid,name);
#401nc_inq_dimname(int ncid, int dimid, char *name)
#406    if(name == NULL) return NC_NOERR;
#408    return ncp->dispatch->inq_dim(ncid,dimid,name,NULL);
denum.c#43nc_def_enum(int ncidnc_type base_typeid, const char *namenc_type *typeidp)
#48    return ncp->dispatch->def_enum(ncid,base_typeid,name,typeidp);
#71nc_insert_enum(int ncidnc_type xtype, const char *name,
#77    return ncp->dispatch->insert_enum(ncidxtypename,
#107nc_inq_enum(int ncidnc_type xtype, char *namenc_type *base_nc_typep,
#111    int stat = nc_inq_user_type(ncidxtypenamebase_sizep,
#140nc_inq_enum_member(int ncidnc_type xtype, int idx, char *name,
#146    return ncp->dispatch->inq_enum_member(ncidxtypeidxnamevalue);
dfile.c#1578nc_inq_type(int ncidnc_type xtype, char *name, size_t *size)
#1591            if(namestrncpy(name,NC_atomictypename(xtype),NC_MAX_NAME);
#1597      return ncp->dispatch->inq_type(ncid,xtype,name,size);
dgroup.c#56int nc_inq_ncid(int ncid, const char *name, int *grp_ncid)
#61    return ncp->dispatch->inq_ncid(ncid,name,grp_ncid);
#88int nc_inq_grpname(int ncid, char *name)
#93    return ncp->dispatch->inq_grpname(ncid,name);
#268int nc_def_grp(int parent_ncid, const char *name, int *new_ncid)
#273    return ncp->dispatch->def_grp(parent_ncid,name,new_ncid);
#284int nc_rename_grp(int grpid, const char *name)
#289    return ncp->dispatch->rename_grp(grpid,name);
dim.c#25 free_NC_string(dimp->name);
#31new_x_NC_dim(NC_string *name)
#39 dimp->name = name;
#56 char *name = (char *)utf8proc_NFC((const unsigned char *)uname);
#57 if(name == NULL)
#59 strp = new_NC_string(strlen(name), name);
#60 free(name);
#80 return new_NC_dim(dimp->name->cpdimp->size);
#130   char *name;
#142      name = (char *)utf8proc_NFC((const unsigned char *)uname);
#143      if(name == NULL)
#145      dimid = (int)NC_hashmapGetDim(ncapname);
#146      free(name);
#293 NC_hashmapAddDim(ncap, (long)ncap->nelemsnewelemp->name->cp);
#318NC3_def_dim(int ncid, const char *name, size_t size, int *dimidp)
#334 status = NC_check_name(name);
#362 dimid = NC_finddim(&ncp->dimsname, &dimp);
#366 dimp = new_NC_dim(namesize);
#383NC3_inq_dimid(int ncid, const char *name, int *dimid_ptr)
#395 dimid = NC_finddim(&ncp->dimsnameNULL);
#406NC3_inq_dim(int ncid, int dimid, char *name, size_t *sizep)
#422 if(name != NULL)
#424 (void)strncpy(namedimp->name->cp,
#425 dimp->name->nchars);
#426 name[dimp->name->nchars] = 0;
#468 NC_string *old = dimp->name;
#482 dimp->name = newStr;
#496 status = set_NC_string(dimp->namenewname);
#501 NC_hashmapAddDim(&ncp->dimsdimiddimp->name->cp);
dimtests.c#53    if (ncdimdef(cdfidmm.namemm.size) != -1) {
#63    if ((dimid = ncdimdef(cdfidmm.namemm.size)) == -1) {
#76    if (ncdimdef(cdfidmm.namemm.size) != -1) {
#81    if (ncdimdef(cdfidnn.name, (long) -10) != -1) {
#91 if (ncdimdef(cdfidrec.namerec.size) == -1) {
#154    if ((nn_dim = ncdimdef(cdfidnn.namenn.size)) == -1) {
#160    if (ncdimid(cdfidnn.name) != nn_dim) {
#169    if (ncdimid(cdfidnn.name) != nn_dim) {
#188    if (ncdimid(cdfidnn.name) != -1) {
#225    dim.name = (char *) emalloc(MAX_NC_NAME);
#227 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#233 if (strcmp(dim.nametest.dims[dimid].name) != 0) {
#235 pnamedim.nametest.dims[dimid].namedimid);
#250 if (ncdiminq(cdfiddimiddim.name, &dim.size) == -1) {
#256 if (strcmp(dim.nametest.dims[dimid].name) != 0) {
#258 pnamedim.nametest.dims[dimid].namedimid);
#268    if (ncdiminq(cdfid, -1, dim.name, &dim.size) != -1 ||
#269 ncdiminq(cdfidtest.ndimsdim.name, &dim.size) != -1) {
#284 if (ncdiminq (cdfid, 0, dim.name, &dim.size) != -1) {
#289    free(dim.name);
#333    if ((pp_dim = ncdimdef(cdfidpp.namepp.size)) == -1) {
#338    if (ncdimdef(cdfidqq.nameqq.size) == -1) {
#349    dim.name = (char *) emalloc(MAX_NC_NAME);
#350    if (ncdiminq(cdfidpp_dimdim.name, &dim.size) == -1) {
#354    if (strcmp(dim.name,pp.name) == 0) {
#358    if (strcmp(dim.name,newname) != 0) {
#360       pnamedim.namenewname);
#363    test.dims[pp_dim].name = (char *) erealloc((void *)test.dims[pp_dim].name,
#365    (void) strcpy(test.dims[pp_dim].namenewname); /* keep test consistent */
#367    if (ncdimrename(cdfidpp_dimqq.name) != -1) {
#372    if (ncdimrename(cdfid, -1, dim.name) != -1 ||
#373 ncdimrename(cdfidtest.ndimsdim.name) != -1) {
#388    test.dims[pp_dim].name = (char *) erealloc((void *)test.dims[pp_dim].name,
#390    (void) strcpy(test.dims[pp_dim].name, "p"); /* keep test consistent */
#398    if (ncdimrename(cdfidpp_dimpp.name) == -1) {
#402    test.dims[pp_dim].name = (char *) erealloc((void *)test.dims[pp_dim].name,
#403       strlen(pp.name)+1);
#404    (void) strcpy(test.dims[pp_dim].namepp.name); /* keep test consistent */
#410    if (ncdimrename (cdfid, 0, dim.name) != -1) {
#414    free (dim.name);
dinternal.c#18NCDISPATCH_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#29      ncidvaridnamextypep,
#40NCDISPATCH_get_att(int ncid, int varid, const char* name, void* valuenc_type t)
#45   return ncp->dispatch->get_att(ncid,varid,name,value,t);
dopaque.c#33nc_def_opaque(int ncid, size_t size, const char *namenc_type *xtypep)
#38    return ncp->dispatch->def_opaque(ncid,size,name,xtypep);
#61nc_inq_opaque(int ncidnc_type xtype, char *name, size_t *sizep)
#64    int stat = nc_inq_user_type(ncid,xtype,name,sizep,NULL,NULL,&class);
driver.c#110      free(test.dims[i].name);
#114      free(test.vars[i].name);
#119      free(test.atts[i].name);
dstring.c#169NC_check_name(const char *name)
#173 const char *cp = name;
#176 assert(name != NULL);
#178 if(*name == 0 /* empty names disallowed */
#183 utf8_stat = utf8proc_check((const unsigned char *)name);
#213     if(cp - name > NC_MAX_NAME)
dtype.c#92nc_inq_typeid(int ncid, const char *namenc_type *typeidp)
#97    return ncp->dispatch->inq_typeid(ncid,name,typeidp);
#135nc_inq_user_type(int ncidnc_type xtype, char *name, size_t *size,
#141    return ncp->dispatch->inq_user_type(ncidxtypenamesize,
dump.c#166    fdebug("group %s {\n",(g==NULL?"null":g->name));
#179 sym->name,
#213 fprintf(stderr,"%s",(con->value.enumv==NULL?"?":con->value.enumv->name));
dumplib.c#1534 tp->name = strdup(prim_type_name(tp->tid));
#1595   tinfo->name = strdup(type_name);
#1735 NC_CHECKnc_inq_dimname(nciddimids[dimid], dims[dimid].name) );
#1741 if (strcmp(dims[dimid].namevarname) == 0 && varndims == 1) {
#1768get_type_name(int ncidnc_type type, char *name)
#1772 NC_CHECK(nc_inq_user_type(ncidtypenameNULLNULLNULLNULL));
#1774 strncpy(nameprim_type_name(type), NC_MAX_NAME + 1);
#1777    strncpy(nameprim_type_name(type), NC_MAX_NAME + 1);
#1794    char name[NC_MAX_NAME+1];
#1803    ename = escaped_name(nctypes[typeid]->name);
#1808 name[NC_MAX_NAME] = '\0';
#1809 strncpy(name,nctypes[typeid]->name,NC_MAX_NAME);
#1820     if(strncmp(namecurnameNC_MAX_NAME) == 0) {
dumplib.h#71extern void get_type_name(int ncidnc_type type, char *name);
dv2i.c#28# define A_DECL(nametypendimsrhs) \
#29 const type *const name = ((const type *)(rhs))
#31# define A_FREE(name)
#72# define A_DECL(nametypendimsrhs) \
#73  type *const name = (type*) nvmalloc((ndims) * sizeof(type))
#79# define A_FREE(name) \
#80 FREE_ONSTACK(name)
#531    const char* name,
#542 status =  nc_def_dim(ncidname, (size_t)length, &dimid);
#553ncdimid(int ncid, const char* name)
#556 const int status =  nc_inq_dimid(ncidname, &dimid);
#570    char* name,
#575 const int status = nc_inq_dim(nciddimidname, &ll);
#595    const char* name
#598 const int status = nc_rename_dim(nciddimidname);
#611    const char* name,
#618 const int status = nc_def_var(ncidnamedatatypendimsdim, &varid);
#631    const char* name
#635 const int status = nc_inq_varid(ncidname, &varid);
#649    char* name,
#657 const int status = nc_inq_var(ncidvaridnamedatatype,
#974    const char* name
#977 const int status = nc_rename_var(ncidvaridname);
#991    const char* name,
#997 const int status = nc_put_att(ncidvaridnamedatatypelenvalue);
#1011    const char* name,
#1017 const int status = nc_inq_att(ncidvaridnamedatatype, &ll);
#1022     ncidvaridname);
#1038    const char* name,
#1042 const int status = nc_get_att(ncidvaridnamevalue);
#1056    const char* name,
#1061 const int status = nc_copy_att(ncid_invarid_innamencid_outvarid_out);
#1064 nc_advise("ncattcopy", status, "%s", name);
#1076    char* name
#1079 const int status = nc_inq_attname(ncidvaridattnumname);
#1093    const char* name,
#1097 const int status = nc_rename_att(ncidvaridnamenewname);
#1111    const char* name
#1114  const int status = nc_del_att(ncidvaridname);
dvar.c#207nc_def_var(int ncid, const char *namenc_type xtype,
#216   return ncp->dispatch->def_var(ncidnamextypendims,
#281nc_rename_var(int ncid, int varid, const char *name)
#287   return ncp->dispatch->rename_var(ncidvaridname);
dvarinq.c#52nc_inq_varid(int ncid, const char *name, int *varidp)
#57   return ncp->dispatch->inq_varid(ncidnamevaridp);
#116nc_inq_var(int ncid, int varid, char *namenc_type *xtypep,
#123   return ncp->dispatch->inq_var_all(ncidvaridnamextypepndimsp,
#147nc_inq_varname(int ncid, int varid, char *name)
#149   return nc_inq_var(ncidvaridnameNULLNULL,
#643NC_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#654      ncidvaridnamextypep,
dvlen.c#90nc_def_vlen(int ncid, const char *namenc_type base_typeidnc_type *xtypep)
#95    return ncp->dispatch->def_vlen(ncid,name,base_typeid,xtypep);
#118nc_inq_vlen(int ncidnc_type xtype, char *name, size_t *datum_sizepnc_type *base_nc_typep)
#121    int stat = nc_inq_user_type(ncid,xtype,name,datum_sizep,base_nc_typep,NULL,&class);
escapes.c#26deescapify(char* name)
#28    const char *cp = name;
#30    size_t len = strlen(name);
#33    if(strchr(name, '\\') == NULL)
#37    cp = name;
#55    strncpy(namenewnamelen+1); /* watch out for trailing null*/
#270    char* name;
#286    name = bbContents(newname);
#287    if(bbGet(newname,0) == '_') name++;
#288    return pooldup(name);
#468jcodify (const char *name)
#470    return ccodify(name);
#538    char* name;
#541    name = bbDup(buf);
#543    return name;
genbin.c#74 stat = nc_def_grp(gsym->container->ncid,gsym->name,&gsym->ncid);
#95       dsym->name,
#112   vsym->name,
#119   vsym->name,
#272      tsym->name,
#282    tsym->name,
#297 econst->name,
#307    tsym->name,
#315        tsym->name,
#325 efield->name,
#339 efield->name,
#451        stat = nc_put_att_schar(grpid,varid,asym->name,typid,len,data);
#465        stat = nc_put_att_text(grpid,varid,asym->name,slen,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);
#492                stat = nc_put_att_string(grpid,varid,asym->name,
#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);
#527        stat = nc_put_att(grpid,varid,asym->name,typid,
#534     stat = nc_get_att(grpid,varid,asym->name,&out);
genc.c#283 gsym->namegroupncid(gsym));
#316                          escapifyname(dsym->name),
#349 escapifyname(vsym->name),
#690    const char* name;
#693 name = ncctype(tsym->typ.typecode);
#695        name = cname(tsym);
#696    return name;
#793 tsym->name,
#808 tsym->name,
#826     escapifyname(econst->name));
#835 escapifyname(tsym->name),
#846 escapifyname(tsym->name),
#886     escapifyname(efield->name),
#896     escapifyname(efield->name),
#1130 escapifyname(asym->name),
#1145 escapifyname(asym->name),
#1167 escapifyname(asym->name),
#1186 escapifyname(asym->name),
#1205 escapifyname(asym->name),
#1225    char* name;
#1227    assert (sym->fqn != NULL && sym->name != NULL);
#1230 name = codify(sym->name);
#1232 name = codify(sym->fqn);
#1233    return name;
generate.c#521                 basetype->name);
genf77.c#238                  codify(dsym->name), f77name(dsym), f77dimncid(dsym));
#269 codify(vsym->name),
#429    const char* name;
#432 name = nftype(tsym->typ.typecode);
#434        name = f77name(tsym);
#435    return name;
#442    char* name;
#444    name = codify(sym->fqn);
#445    return name;
#591 slen += (strlen(sym->name)+strlen(separator));
#601        strcat(result,sym->name); /* append "<prefix[i]/>"*/
#859    bbprintf0(stmt,"* define %s\n",asym->name);
#876 codify(asym->name),
#890 codify(asym->name),
genj.c#119                    indented(1),jname(dsym),jescapifyname(dsym->name));
#122                    indented(1),jname(dsym),jescapifyname(dsym->name), jname(dsym));
#152                            jescapifyname(vsym->name),
#275    char* name;
#278    name = codify(sym->fqn); /* convert to usable form*/
#279    return name;
#455 indented(1),jescapifyname(vsym->name));
#509 indented(1),jescapifyname(vsym->name));
#525    codeprintf("%s/* attribute: %s */\n",indented(1),asym->name);
#569                indented(1),jescapifyname(asym->name));
#573 jescapifyname(asym->att.var->name),
#574                jescapifyname(asym->name));
#585                jescapifyname(asym->name),
#590 jescapifyname(asym->att.var->name),
#591                jescapifyname(asym->name),
genlib.c#118        fqnname = fqnescape(sym->name);
#127 sym->fqn = strdup(sym->name);
#153    fqnname = fqnescape(sym->name);
#185    fqnname = fqnescape(sym->name);
#210 slen += (strlen(sym->name)+strlen(separator));
#220        strcat(result,sym->name); /* append "<prefix[i]/>"*/
genlib.c#50 stat = nc_def_dim(nciddims[idim].namedims[idim].size, &dimid);
#57   vars[ivar].name,
#70     stat = nc_put_att_schar(ncidvaridatts[iatt].name,
#75     stat = nc_put_att_text(ncidvaridatts[iatt].name,
#80     stat = nc_put_att_short(ncidvaridatts[iatt].name,
#85     stat = nc_put_att_int(ncidvaridatts[iatt].name,
#90     stat = nc_put_att_float(ncidvaridatts[iatt].name,
#95     stat = nc_put_att_double(ncidvaridatts[iatt].name,
#352 dims[idim].namedims[idim].lnamedims[idim].lname);
#374 vars[ivar].name,
#382 vars[ivar].name,
#403 atts[iatt].name,
#426 atts[iatt].name,
#754                    dims[idim].namedims[idim].lname);
#757                    dims[idim].name, (unsigned long) dims[idim].size,
#777 vars[ivar].name,
#785 vars[ivar].name,
#805 atts[iatt].name,
#827 atts[iatt].name,
#1524 sprintf(stmnt, "* store %s", v->name);
#1909    const char *name)
#1991    cp = name;
#2003    cp = name;
#2007    newlen = strlen(name) + count + 1; /* bytes left to be filled */
#2040deescapify (char *name)
#2042    const char *cp = name;
#2044    size_t len = strlen(name);
#2047    if(strchr(name, '\\') == NULL)
#2051    cp = name;
#2069    strncpy(namenewnamelen);
genlib.h#66extern char* codify(const char *name);
#98extern  Symbollookupingroup(nc_class objectclass, char* nameSymbolgrp);
genlib.h#50extern char* decodify (const char *name);
#51extern void deescapify (char *name);
getvara.c#1254    ASSERT((strcmp(cdfvar->ncfullname,var->name->cp)==0));
load.c#84    sprintf(stmnt, "   {\t\t\t/* store %s */", vars[varnum].name);
#209     vars[varnum].name);
#434 sprintf(stmnt, "* store %s", v->name);
main.c#115    char* name;
#130 char* name;
#301     for(langs=legallanguages;langs->name != NULL;langs++) {
#302              if(strcmp(lang_name,langs->name)==0) {
#307     if(langs->name == NULL) {
#357            for(kvalue=legalkinds;kvalue->name;kvalue++) {
#358              if(strcmp(kind_name,kvalue->name) == 0) {
#363            if(kvalue->name == NULL) {
nc.h#56NC_check_name(const char *name);
nc3dispatch.c#33static int NC3_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#189NC3_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#196    int stat = NC3_inq_var(ncid,varid,name,xtypep,ndimsp,dimidsp,nattsp);
#234NC3_def_grp(int parent_ncid, const char *name, int *new_ncid)
#240NC3_rename_grp(int grpid, const char *name)
#246NC3_inq_ncid(int ncid, const char *name, int *grp_ncid)
#261NC3_inq_grpname(int ncid, char *name)
#263    if (name)
#264        strcpy(name, "/");
#357NC3_inq_typeid(int ncid, const char *namenc_type *typeidp)
#361        if (!strcmp(nameNC_atomictypename(i))) {
#376NC3_inq_user_type(int ncidnc_type typeid, char *name, size_t *size,
#383NC3_def_compound(int ncid, size_t size, const char *namenc_type *typeidp)
#389NC3_insert_compound(int ncidnc_type typeid, const char *name, size_t offset,
#396NC3_insert_array_compound(int ncidnc_type typeid, const char *name,
#405NC3_inq_compound_field(int ncidnc_type typeid, int fieldid, char *name,
#413NC3_inq_compound_fieldindex(int ncidnc_type typeid, const char *name, int *fieldidp)
#419NC3_def_opaque(int ncid, size_t datum_size, const char *namenc_typextypep)
#425NC3_def_vlen(int ncid, const char *namenc_type base_typeidnc_typextypep)
#431NC3_def_enum(int ncidnc_type base_typeid, const char *name,
nc3dispatch.h#109NC3_def_dim(int ncid, const char *name, size_t len, int *idp);
#112NC3_inq_dimid(int ncid, const char *name, int *idp);
#115NC3_inq_dim(int ncid, int dimid, char *name, size_t *lenp);
#121NC3_rename_dim(int ncid, int dimid, const char *name);
#127NC3_inq_att(int ncid, int varid, const char *name,
#131NC3_inq_attid(int ncid, int varid, const char *name, int *idp);
#134NC3_inq_attname(int ncid, int varid, int attnum, char *name);
#137NC3_rename_att(int ncid, int varid, const char *name, const char *newname);
#146NC3_get_att(int ncid, int varid, const char *name, void *valuenc_type);
#149NC3_put_att(int ncid, int varid, const char *namenc_type datatype,
#156NC3_def_var(int ncid, const char *name,
#160NC3_inq_var(int ncid, int varid, char *name,
#164NC3_inq_varid(int ncid, const char *name, int *varidp);
#167NC3_rename_var(int ncid, int varid, const char *name);
nc3internal.c#210fprintf(stderr, "    VAR %d %s: %ld\n", ii, (*vpp)->name->cp, (long)index);
#280fprintf(stderr, "    REC %d %s: %ld\n", ii, (*vpp)->name->cp, (long)index);
#1616NC3_inq_type(int ncidnc_type typeid, char *name, size_t *size)
#1646   if (name)
#1647      strcpy(nameNC_atomictypename(typeid));
nc3internal.h#82 NC_string *name;
#101new_x_NC_dim(NC_string *name);
#128 NC_string *name;
#154NC_findattr(const NC_attrarray *ncap, const char *name);
#181 NC_string *name;
#229NC_findvar(const NC_vararray *ncap, const char *nameNC_var **varpp);
#244extern void NC_hashmapAddDim(const NC_dimarray*, long data, const char *name);
#247extern long NC_hashmapRemoveDim(const NC_dimarray*, const char *name);
#250extern long NC_hashmapGetDim(const NC_dimarray*, const char *name);
#253extern void NC_hashmapAddVar(const NC_vararray*, long data, const char *name);
#256extern long NC_hashmapRemoveVar(const NC_vararray*, const char *name);
#259extern long NC_hashmapGetVar(const NC_vararray*, const char *name);
nc4attr.c#29nc4_get_att(int ncidNC *nc, int varid, const char *name,
#52 __func__ncidvaridnamemy_attnummem_type));
#60   if ((retval = nc4_normalize_name(namenorm_name)))
#66     if(strcmp(name,*sp)==0) {
#210nc4_put_att(int ncidNC *nc, int varid, const char *name,
#225   if (!name)
#231 namefile_typemem_typelen));
#247   if ((retval = nc4_check_name(namenorm_name)))
#253     if(strcmp(name,*sp)==0) {
#275     if (!strcmp(att->namenorm_name))
#330      if (!(att->name = strdup(norm_name)))
#365   if (!strcmp(att->name_FillValue) && varid != NC_GLOBAL)
#415      LOG((4, "Copying fill value into metadata for variable %s", var->name));
#548NC4_inq_att(int ncid, int varid, const char *namenc_type *xtypep, size_t *lenp)
#553   LOG((2, "nc_inq_att: ncid 0x%x varid %d name %s", ncidvaridname));
#564   return nc4_get_att(ncidncvaridnamextypepNC_NATlenpNULL, 0, NULL);
#569NC4_inq_attid(int ncid, int varid, const char *name, int *attnump)
#575   LOG((2, "nc_inq_attid: ncid 0x%x varid %d name %s", ncidvaridname));
#586   stat = nc4_get_att(ncidncvaridnameNULLNC_NAT,
#594NC4_inq_attname(int ncid, int varid, int attnum, char *name)
#617   if (name)
#618      strcpy(nameatt->name);
#626NC4_rename_att(int ncid, int varid, const char *name,
#638   if (!name || !newname)
#642 ncidvaridnamenewname));
#679      if (!strncmp(att->namenorm_newnameNC_MAX_NAME))
#683   if ((retval = nc4_normalize_name(namenorm_name)))
#686      if (!strncmp(att->namenorm_nameNC_MAX_NAME))
#693   if (!(h5->flags & NC_INDEF) && strlen(norm_newname) > strlen(att->name) &&
#702         if (H5Adelete(grp->hdf_grpidatt->name) < 0)
#709         if (H5Adelete(datasetidatt->name) < 0)
#716   free(att->name);
#717   if (!(att->name = malloc((strlen(norm_newname) + 1) * sizeof(char))))
#719   strcpy(att->namenorm_newname);
#735NC4_del_att(int ncid, int varid, const char *name)
#746   if (!name)
#750 ncidvaridname));
#796      if (!strcmp(att->namename))
#808      if(H5Adelete(locidatt->name) < 0)
#827nc4_put_att_tc(int ncid, int varid, const char *namenc_type file_type,
#834   if (!name || strlen(name) > NC_MAX_NAME)
#838 "mem_type %d len %d", ncidvaridnamefile_typemem_typelen));
#856 if(strcmp(name,*reserved)==0)
#864 if(strcmp(name,*reserved)==0)
#870   return nc4_put_att(ncidncvaridnamefile_typemem_typelen,
#875nc4_get_att_special(NC_HDF5_FILE_INFO_Th5, const char* name,
#883    if(strcmp(name,NCPROPS)==0) {
#899    } else if(strcmp(name,ISNETCDF4ATT)==0
#900              || strcmp(name,SUPERBLOCKATT)==0) {
#904 if(strcmp(name,SUPERBLOCKATT)==0)
#929nc4_get_att_tc(int ncid, int varid, const char *namenc_type mem_type,
#936 ncidvaridnamemem_type));
#946   return nc4_get_att(ncidncvaridnameNULLmem_type,
#951NC4_put_att(int ncid, int varid, const char *namenc_type xtype,
#954   return nc4_put_att_tc(ncidvaridnamextypememtype, 0, nelemsvalue);
#958NC4_get_att(int ncid, int varid, const char *name, void *valuenc_type memtype)
#960   return nc4_get_att_tc(ncidvaridnamememtype, 0, value);
nc4dim.c#58NC4_def_dim(int ncid, const char *name, size_t len, int *idp)
#68   LOG((2, "%s: ncid 0x%x name %s len %d", __func__ncidname,
#101   if ((retval = nc4_check_name(namenorm_name)))
#114      if (nn_hash == dim->hash && !strncmp(dim->namenorm_nameNC_MAX_NAME))
#123   if (!(dim->name = strdup(norm_name)))
#140NC4_inq_dimid(int ncid, const char *name, int *idp)
#151   LOG((2, "%s: ncid 0x%x name %s", __func__ncidname));
#161   if ((retval = nc4_normalize_name(namenorm_name)))
#169  if (dim->hash == shash && !strncmp(dim->namenorm_nameNC_MAX_NAME))
#183NC4_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
#206   if (name && dim->name)
#207      strcpy(namedim->name);
#239NC4_rename_dim(int ncid, int dimid, const char *name)
#248   if (!name)
#252 dimidname));
#266   if ((retval = nc4_check_name(namenorm_name)))
#273      if (!strncmp(dim->namenorm_nameNC_MAX_NAME))
#294      if (H5Gunlink(grp->hdf_grpiddim->name) < 0)
#300   if(dim->name)
#301      free(dim->name);
#302   if (!(dim->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
#304   strcpy(dim->namenorm_name);
#309   if (dim->coord_var && strcmp(dim->namedim->coord_var->name))
#323      if ((retval = nc4_find_var(grpdim->name, &var)))
nc4dispatch.h#80NC4_def_dim(int ncid, const char *name, size_t len, int *idp);
#83NC4_inq_dimid(int ncid, const char *name, int *idp);
#86NC4_inq_dim(int ncid, int dimid, char *name, size_t *lenp);
#92NC4_rename_dim(int ncid, int dimid, const char *name);
#98NC4_inq_att(int ncid, int varid, const char *name,
#102NC4_inq_attid(int ncid, int varid, const char *name, int *idp);
#105NC4_inq_attname(int ncid, int varid, int attnum, char *name);
#108NC4_rename_att(int ncid, int varid, const char *name, const char *newname);
#117NC4_get_att(int ncid, int varid, const char *name, void *valuenc_type);
#120NC4_put_att(int ncid, int varid, const char *namenc_type datatype,
#127NC4_def_var(int ncid, const char *name,
#131NC4_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#139NC4_inq_varid(int ncid, const char *name, int *varidp);
#142NC4_rename_var(int ncid, int varid, const char *name);
nc4file.c#618   if (!(new_dim->name = strdup(obj_name)))
#712   LOG((4, "dimscale %s is multidimensional and has coords", var->name));
#972      if (!((*type_info)->name = strdup(nc_type_name_g[t])))
#1015   assert(att->name);
#1017        __func__att->attnumatt->name, (int)att->nc_typeidatt->len));
#1210   LOG((4, "%s: type_name %s grp->name %s", __func__type_namegrp->name));
#1578      if (!(var->name = malloc(((strlen(obj_name) - strlen(NON_COORD_PREPEND))+ 1) * sizeof(char))))
#1581      strcpy(var->name, &obj_name[strlen(NON_COORD_PREPEND)]);
#1592      if (!(var->name = malloc((strlen(obj_name) + 1) * sizeof(char))))
#1595      strcpy(var->nameobj_name);
#1598   var->hash = hash_fast(var->name, strlen(var->name));
#1720         assert(0 == strcmp(var->namedim->name));
#1792  if (!(att->name = strdup(att_name)))
#1889  if (!(att->name = malloc((max_len + 1) * sizeof(char))))
#1891         strncpy(att->nameobj_namemax_len);
#1892         att->name[max_len] = 0;
#2005nc4_rec_read_metadata_cb(hid_t grpid, const char *name, const H5L_info_t *info,
#2016   if ((oinfo.oid = H5Oopen(grpidnameH5P_DEFAULT)) < 0)
#2023   strncpy(oinfo.onamenameNC_MAX_NAME);
#2107    assert(grp && grp->name);
#2108    LOG((3, "%s: grp->name %s", __func__grp->name));
#2120 grp->nameH5P_DEFAULT)) < 0)
#2497      if (!(type_info->name = strdup(nc_type_name_g[t])))
#2556      if (!(att->name = malloc(NC_MAX_HDF4_NAME * sizeof(char))))
#2558      if (SDattrinfo(h5->sdidaatt->name, &att_data_type, &att_count))
#2606      if (!(var->name = malloc(NC_MAX_HDF4_NAME + 1)))
#2610      if (SDgetinfo(var->sdsidvar->name, &rankNULL, &data_type, &num_atts))
#2613      var->hash = hash_fast(var->name, strlen(var->name));
#2618      if (SDgetinfo(var->sdsidvar->name, &rankdimsize, &data_type, &num_atts)) {
#2646      LOG((3, "reading HDF4 dataset %s, rank %d netCDF type %d", var->name,
#2698     if (!strcmp(dim->namedim_name))
#2705  dim_namevar->name));
#2712     if (!(dim->name = strdup(dim_name)))
#2741  if (!(att->name = malloc(NC_MAX_HDF4_NAME * sizeof(char)))) {
#2745  if (SDattrinfo(var->sdsidaatt->name, &att_data_type, &att_count)) {
nc4grp.c#19NC4_def_grp(int parent_ncid, const char *name, int *new_ncid)
#26   LOG((2, "%s: parent_ncid 0x%x name %s", __func__parent_ncidname));
#35   if ((retval = nc4_check_name(namenorm_name)))
#66NC4_rename_grp(int grpid, const char *name)
#73   LOG((2, "nc_rename_grp: grpid 0x%x name %s", grpidname));
#89   if ((retval = nc4_check_name(namenorm_name)))
#113         if (H5Gmove(grp->parent->hdf_grpidgrp->namename) < 0)
#117         if ((grp->hdf_grpid = H5Gopen2(grp->parent->hdf_grpidnameH5P_DEFAULT)) < 0)
#124   free(grp->name);
#125   if (!(grp->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
#127   strcpy(grp->namenorm_name);
#135NC4_inq_ncid(int ncid, const char *name, int *grp_ncid)
#142   LOG((2, "nc_inq_ncid: ncid 0x%x name %s", ncidname));
#153   if ((retval = nc4_normalize_name(namenorm_name)))
#158      if (!strcmp(norm_nameg->name)) /* found it! */
#215NC4_inq_grpname(int ncid, char *name)
#226   if (name)
#229  strcpy(name, "/");
#231  strcpy(namegrp->name);
#244   char *namegrp_name[NC_MAX_NAME + 1];
#253   if (!(name = malloc((g + 1) * (NC_MAX_NAME + 1) + 1)))
#257      free(name);
#260   assert(name && gid);
#263   strcpy(name, "/");
#275      strcat(namegrp_name);
#277  strcat(name, "/");
#282      *lenp = strlen(name);
#286      strcpy(full_namename);
#289   free(name);
nc4hdf.c#75  assert(grp && grp->name && dimid >= 0 && dimscaleid >= 0);
#76  LOG((3, "%s: grp->name %s", __func__grp->name));
#89               __func__var->dimids[d], var->name));
#115  assert(grp && grp->name && dimid >= 0 && dimscaleid >= 0);
#116  LOG((3, "%s: grp->name %s", __func__grp->name));
#129               __func__var->dimids[d], var->name));
#157    if ((var->hdf_datasetid = H5Dopen2(grp->hdf_grpidvar->name,
#255      LOG((4, "Found a fill value for var %s", var->name));
#502  LOG((4, "%s: var name %s ndims %d", __func__var->namevar->ndims));
#573  assert(grp && h5 && var && var->name);
#576       __func__var->namemem_nc_typeis_long));
#598    name_to_use = var->name;
#676      LOG((4, "converting data for var %s type=%d len=%d", var->name,
#899  assert(grp && h5 && var && var->name);
#902       __func__var->namemem_nc_typeis_long));
#923    name_to_use = var->name;
#1064          LOG((4, "converting data for var %s type=%d len=%d", var->name,
#1299  assert(att->name);
#1301       __func__varidatt->attnumatt->name,
#1319  if ((attr_exists = H5Aexists(locidatt->name)) < 0)
#1323      if (H5Adelete(locidatt->name) < 0)
#1395  if ((attid = H5Acreate(locidatt->namefile_typeidspaceid,
#1427          LOG((4, "%s: writing att %s to varid %d", __func__att->namevarid));
#1533  LOG((3, "%s:: name %s", __func__var->name));
#1727  name_to_use = var->hdf5_name ? var->hdf5_name : var->name;
#1741      if (H5DSset_scale(var->hdf_datasetidvar->name) < 0)
#1852      LOG((4, "creating compound type %s hdf_typeid 0x%x", type->name,
#1881          LOG((4, "inserting field %s offset %d hdf_typeid 0x%x", field->name,
#1883          if (H5Tinsert(type->hdf_typeidfield->namefield->offset,
#1925        if (H5Tenum_insert(type->hdf_typeidenum_m->nameenum_m->value) < 0)
#1935  if (H5Tcommit(grp->hdf_grpidtype->nametype->hdf_typeid) < 0)
#1938  LOG((4, "just committed type %s, HDF typeid: 0x%x", type->name,
#2020      if ((grp->hdf_grpid = H5Gcreate2(grp->parent->hdf_grpidgrp->name,
#2087                           __func__var->dimids[d], var->name));
#2116var_exists(hid_t grpid, char *namenc_bool_t *exists)
#2124  if ((link_exists = H5Lexists(grpidnameH5P_DEFAULT)) < 0)
#2131      if (H5Gget_objinfo(grpidname, 1, &statbuf) < 0)
#2151  LOG((4, "%s: writing var %s", __func__var->name));
#2179        if (!strcmp(d1->namevar->name))
#2183            if ((retval = var_exists(grp->hdf_grpidvar->name, &exists)))
#2207        if (!strcmp(d1->namevar->name))
#2211            if ((retval = var_exists(grp->hdf_grpidvar->name, &exists)))
#2300      if (H5Gunlink(grp->hdf_grpidvar->name) < 0)
#2369      LOG((4, "%s: creating dim %s", __func__dim->name));
#2408      LOG((4, "%s: about to H5Dcreate1 a dimscale dataset %s", __func__dim->name));
#2409      if ((dim->hdf_dimscaleid = H5Dcreate1(grp->hdf_grpiddim->nameH5T_IEEE_F32BE,
#2443        if (!strcmp(v1->namedim->name))
#2509              LOG((5, "%s: %s is out of order coord var", __func__var->name));
#2520              LOG((5, "%s: %s is multidimensional coord var", __func__var->name));
#2558  assert(grp && grp->name && grp->hdf_grpid);
#2559  LOG((3, "%s: grp->name %s, bad_coord_order %d", __func__grp->namebad_coord_order));
#2622  assert(grp && grp->name);
#2623  LOG((3, "%s: grp->name %s", __func__grp->name));
#3634  assert(grp && grp->name);
#3635  LOG((4, "%s: grp->name %s", __func__grp->name));
#3669                  LOG((5, "%s: var %s has dimscale info...", __func__var->name));
#3682                                   __func__ddim->name));
#3763                      LOG((3, "%s: creating phony dim for var %s", __func__var->name));
#3772                      if (!(dim->name = strdup(phony_dim_name))) {
#3927    char name[MAXNAME];
#3931    len = H5Iget_name(idnameMAXNAME);
#3933    name[len] = '\0';
#3942 len = H5Aget_name(idMAXNAMEname);
#3944 name[len] = '\0';
#3950 LOG((0,"Type = %s(%8u) name='%s'",typename,id,name));
#3953 fprintf(stderr,"Type = %s(%8u) name='%s'",typename,id,name);
#4090    char name[NC_HDF5_MAX_NAME];
#4098        len = H5Gget_objname_by_idx(gid,(hsize_t)i,name,(size_t)NC_HDF5_MAX_NAME);
#4104            grpid = H5Gopen(gid,name);
#4110     if(strcmp(name,"phony_dim")==0)
#4112            dsid = H5Dopen(gid,name);
#4118                    ssize_t len = H5Aget_name(aidNC_HDF5_MAX_NAMEname);
#4122                            if(strcmp(name,*p) ==     0) {
nc4info.c#67      char* name = p;
#78     if(strcmp(name,NCPVERSION) == 0) {
#82     } else if(strcmp(name,NCPNCLIBVERSION) == 0)
#84     else if(strcmp(name,NCPHDF5LIBVERSION) == 0)
nc4internal.c#86nc4_check_name(const char *name, char *norm_name)
#92   if (strlen(name) > NC_MAX_NAME)
#98   if ((retval = NC_check_name(name)))
#102   if (!(temp = (char *)utf8proc_NFC((const unsigned char *)name)))
#376nc4_find_var(NC_GRP_INFO_T *grp, const char *nameNC_VAR_INFO_T **var)
#378   assert(grp && var && name);
#382      if (0 == strcmp(name, (*var)->name))
#419nc4_rec_find_named_type(NC_GRP_INFO_T *start_grp, char *name)
#428      if (!strcmp(type->namename))
#434  if ((res = nc4_rec_find_named_type(gname)))
#503   LOG((3, "nc4_find_dim_len: grp->name %s dimid %d", grp->namedimid));
#529nc4_find_grp_att(NC_GRP_INFO_T *grp, int varid, const char *name, int attnum,
#535   assert(grp && grp->name);
#537 grp->namevaridnameattnum));
#560           if (name && (*att)->name && !strcmp((*att)->namename))
#562           if (!name && (*att)->attnum == attnum)
#573nc4_find_nc_att(int ncid, int varid, const char *name, int attnum,
#583 ncidvaridnameattnum));
#609      if ((name && !strcmp((*att)->namename)) ||
#610   (!name && (*att)->attnum == attnum))
#739  char *nameNC_GRP_INFO_T **grp)
#743   LOG((3, "%s: new_nc_grpid %d name %s ", __func__new_nc_grpidname));
#752   if (!(new_grp->name = strdup(name)))
#774nc4_check_dup_name(NC_GRP_INFO_T *grp, char *name)
#783      if (!strcmp(type->namename))
#788      if (!strcmp(g->namename))
#792   hash =  hash_fast(name, strlen(name));
#794      if (var->hash == hash && !strcmp(var->namename))
#802nc4_type_list_add(NC_GRP_INFO_T *grp, size_t size, const char *name,
#817   if (!(new_type->name = strdup(name)))
#832nc4_field_list_add(NC_FIELD_INFO_T **list, int fieldid, const char *name,
#839   if (!name)
#848   if (!(field->name = strdup(name)))
#864         free(field->name);
#881     const char *name, const void *value)
#886   assert(name && size > 0 && value);
#887   LOG((4, "%s: size %d name %s", __func__sizename));
#896   if (!(member->name = strdup(name))) {
#919   if (field->name)
#920      free(field->name);
#946      if (type->name)
#947         free(type->name);
#980                  free(enum_member->name);
#1035   if (var->name)
#1036     {free(var->name); var->name = NULL;}
#1105   if (dim->name)
#1106      free(dim->name);
#1136   LOG((3, "%s: grp->name %s", __func__grp->name));
#1154      LOG((4, "%s: deleting att %s", __func__att->name));
#1165      LOG((4, "%s: deleting var %s", __func__var->name));
#1180      LOG((4, "%s: deleting dim %s", __func__dim->name));
#1194      LOG((4, "%s: deleting type %s", __func__type->name));
#1202   LOG((4, "%s: closing group %s", __func__grp->name));
#1207   free(grp->name);
#1233   if (att->name)
#1234      free(att->name);
#1364      if (H5Gunlink(grp->hdf_grpiddim->name) < 0)
#1397nc4_normalize_name(const char *name, char *norm_name)
#1400   if (!(temp_name = (char *)utf8proc_NFC((const unsigned char *)name)))
#1469 tabsgrp->namegrp->nc_grpidgrp->nvarsgrp->natts));
#1473    tabsatt->attnumatt->nameatt->nc_typeidatt->len));
#1477    tabsdim->dimiddim->namedim->lendim->unlimited));
#1492    tabsvar->varidvar->namevar->type_info->nc_typeidvar->ndims, (int)var->dimscale,
#1496       tabsatt->attnumatt->nameatt->nc_typeidatt->len));
#1508    type->hdf_typeidtype->size, (int)type->committedtype->name,
#1515     LOG((4, "field %s offset %d nctype %d ndims %d", field->name,
nc4internal.h#119   char *name;
#134   char *name;
#150   char *name;
#201   char *name;
#210   char *name;
#217   char *name;
#270   char *name;
#365int nc4_find_var(NC_GRP_INFO_T *grp, const char *nameNC_VAR_INFO_T **var);
#370NC_TYPE_INFO_T *nc4_rec_find_named_type(NC_GRP_INFO_T *start_grp, char *name);
#372int nc4_find_nc_att(int ncid, int varid, const char *name, int attnum,
#376int nc4_find_grp_att(NC_GRP_INFO_T *grp, int varid, const char *name, int attnum,
#393int nc4_type_list_add(NC_GRP_INFO_T *grp, size_t size, const char *name,
#395int nc4_field_list_add(NC_FIELD_INFO_T **list, int fieldid, const char *name,
#401      NC *nc, char *nameNC_GRP_INFO_T **grp);
#404 const char *name, const void *value);
#411int NC_check_name(const char *name);
#412int nc4_check_name(const char *name, char *norm_name);
#413int nc4_normalize_name(const char *name, char *norm_name);
nc4type.c#85NC4_inq_typeid(int ncid, const char *namenc_type *typeidp)
#95      if (!strcmp(nameatomic_name[i]))
#113   if (name[0] != '/' && strstr(name, "/"))
#117   if (!(norm_name = (char*)malloc(strlen(name) + 1)))
#119   if ((retval = nc4_normalize_name(namenorm_name))) {
#126  if (!strcmp(norm_nametype->name))
#186add_user_type(int ncid, size_t size, const char *namenc_type base_typeid,
#196   if ((retval = nc4_check_name(namenorm_name)))
#262NC4_inq_type(int ncidnc_type typeid1, char *name, size_t *size)
#278      if (name)
#279 strcpy(nameatomic_name[typeid1]);
#293   if (name)
#294      strcpy(nametype->name);
#311NC4_def_compound(int ncid, size_t size, const char *namenc_type *typeidp)
#313   return add_user_type(ncidsizename, 0, NC_COMPOUNDtypeidp);
#318NC4_insert_compound(int ncidnc_type typeid1, const char *name, size_t offset,
#321   return nc_insert_array_compound(ncidtypeid1nameoffset,
#327NC4_insert_array_compound(int ncid, int typeid1, const char *name,
#338 nameoffsetfield_typeidndims));
#341   if ((retval = nc4_check_name(namenorm_name)))
#373NC4_inq_user_type(int ncidnc_type typeid1, char *name, size_t *size,
#411   if (name)
#412      strcpy(nametype->name);
#436NC4_inq_compound_field(int ncidnc_type typeid1, int fieldid, char *name,
#457  if (name)
#458     strcpy(namefield->name);
#493NC4_inq_compound_fieldindex(int ncidnc_type typeid1, const char *name, int *fieldidp)
#502 ncidtypeid1name));
#517   if ((retval = nc4_normalize_name(namenorm_name)))
#522      if (!strcmp(field->namenorm_name))
#538NC4_def_opaque(int ncid, size_t datum_size, const char *name,
#541   return add_user_type(nciddatum_sizename, 0, NC_OPAQUEtypeidp);
#547NC4_def_vlen(int ncid, const char *namenc_type base_typeid,
#550   return add_user_type(ncid, 0, namebase_typeidNC_VLENtypeidp);
#556NC4_def_enum(int ncidnc_type base_typeid, const char *name,
#559   return add_user_type(ncid, 0, namebase_typeidNC_ENUMtypeidp);
#623     strcpy(identifierenum_member->name);
#674      strcpy(identifierenum_member->name);
nc4var.c#57      if ((var->hdf_datasetid = H5Dopen2(grp->hdf_grpidvar->name,
#278     "chunksize %ld", __func__var->namedDEFAULT_CHUNK_SIZEnum_valuestype_sizevar->chunksizes[0]));
#286 "chunksize %ld", __func__var->namedDEFAULT_CHUNK_SIZEnum_valuestype_sizevar->chunksizes[d]));
#301       "chunksize %ld", __func__var->namedDEFAULT_CHUNK_SIZEnum_valuestype_sizevar->chunksizes[d]));
#346nc_def_var_nc4(int ncid, const char *namenc_type xtype,
#374   if ((retval = nc4_check_name(namenorm_name)))
#421   if (!(var->name = malloc((strlen(norm_name) + 1) * sizeof(char))))
#423   strcpy(var->namenorm_name);
#513      if (d == 0 && dim_grp == grp && dim->hash == var->hash && strcmp(dim->namenorm_name) == 0)
#530            if (H5Gunlink(grp->hdf_grpiddim->name) < 0)
#552 var->ndimsvar->name));
#571      if (dim->hash == var->hash && !strcmp(dim->namenorm_name) &&
#609NC4_def_var(int ncid, const char *namenc_type xtype, int ndims,
#616        __func__ncidnamextypendims));
#627   return nc_def_var_nc4(ncidnamextypendimsdimidspvaridp);
#634NC4_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#683   if (name)
#684      strcpy(namevar->name);
#958           var->name));
#1124NC4_inq_varid(int ncid, const char *name, int *varidp)
#1133   if (!name)
#1138   LOG((2, "%s: ncid 0x%x name %s", __func__ncidname));
#1145   if ((retval = nc4_normalize_name(namenorm_name)))
#1152      if (nn_hash == var->hash && !(strcmp(var->namenorm_name)))
#1166NC4_rename_var(int ncid, int varid, const char *name)
#1176        __func__ncidvaridname));
#1185   if (strlen(name) > NC_MAX_NAME)
#1194   if ((retval = NC_check_name(name)))
#1198   nn_hash = hash_fast(name, strlen(name));
#1202      if (nn_hash == var->hash && !strncmp(var->namenameNC_MAX_NAME))
#1213   if (!(h5->flags & NC_INDEF) && strlen(name) > strlen(var->name) &&
#1221      if (H5Gmove(grp->hdf_grpidvar->namename) < 0)
#1226   free(var->name);
#1227   if (!(var->name = malloc((strlen(name) + 1) * sizeof(char))))
#1229   strcpy(var->namename);
#1233   if (var->dimscale && strcmp(var->namevar->dim[0]->name))
#1255         if (strcmp(dim->namename) == 0 && dim_grp == grp)
#1342   assert(grp && h5 && var && var->name);
nc_hashmap.c#75      NC_hashmapAddDim(ncaptable[size].data-1, elem->name->cp);
#76      assert(NC_hashmapGetDim(ncapelem->name->cp) == 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)
#130  unsigned long key = hash_fast(name, strlen(name));
#149     strncmp(namencap->value[entry.data-1]->name->cp,
#150     ncap->value[entry.data-1]->name->nchars) == 0)
#175void NC_hashmapAddVar(const NC_vararrayncap, long data, const char *name)
#177  unsigned long key = hash_fast(name, strlen(name));
#196     strncmp(namencap->value[entry.data-1]->name->cp,
#197     ncap->value[entry.data-1]->name->nchars) == 0)
#222long NC_hashmapRemoveDim(const NC_dimarrayncap, const char *name)
#225  unsigned long key = hash_fast(name, strlen(name));
#237   strncmp(namencap->value[entry.data-1]->name->cp,
#238   ncap->value[entry.data-1]->name->nchars) == 0)
#259long NC_hashmapRemoveVar(const NC_vararrayncap, const char *name)
#262  unsigned long key = hash_fast(name, strlen(name));
#274   strncmp(namencap->value[entry.data-1]->name->cp,
#275   ncap->value[entry.data-1]->name->nchars) == 0)
#296long NC_hashmapGetDim(const NC_dimarrayncap, const char *name)
#301    unsigned long key = hash_fast(name, strlen(name));
#312   strncmp(namencap->value[entry.data-1]->name->cp,
#313   ncap->value[entry.data-1]->name->nchars) == 0)
#330long NC_hashmapGetVar(const NC_vararrayncap, const char *name)
#335    unsigned long key = hash_fast(name, strlen(name));
#346   strncmp(namencap->value[entry.data-1]->name->cp,
#347   ncap->value[entry.data-1]->name->nchars) == 0)
ncaux.c#29    char* name;
#41    char* name;
#55ncaux_begin_compound(int ncid, const char *name, int alignmode, void** tagp)
#72    cmpd->name = strdup(name);
#73    if(cmpd->name == NULL) {status = NC_ENOMEM; goto fail;}
#93    if(cmpd->name) free(cmpd->name);
#96 if(field->name) free(field->name);
#106ncaux_add_field(void* tag,  const char *namenc_type field_type,
#128    field->name = strdup(name);
#130    if(field->name == NULL) {status = NC_ENOMEM; goto done;}
#163    status = nc_def_compound(cmpd->ncidcmpd->sizecmpd->nameidp);
#169            status = nc_insert_compound(cmpd->ncid, *idpfield->name,
#172            status = nc_insert_array_compound(cmpd->ncid, *idpfield->name,
ncaux.h#14extern int ncaux_begin_compound(int ncid, const char *name, int alignmode,
#21extern int ncaux_add_field(void* tag,  const char *namenc_type field_type,
nccommon.h#222    char*   name;
nccomps.h#10    char name[NC_MAX_NAME];
#47    char *name;             /* relative name of type within its group */
#69    char name[NC_MAX_NAME];
#90    char name[NC_MAX_NAME];
nccopy.c#254    char name[NC_MAX_NAME];
#260    NC_CHECK(nc_inq_vlen(igrpitypename, &size, &ibasetype));
#273    NC_CHECK(nc_def_vlen(ogrpnameobasetype, &vlen_type));
#286    char name[NC_MAX_NAME];
#289    NC_CHECK(nc_inq_opaque(igrpitypename, &size));
#290    NC_CHECK(nc_def_opaque(ogrpsizename, &otype));
#306    char name[NC_MAX_NAME];
#309    NC_CHECK(nc_inq_enum(igrpitypename, &basetype, &basesize, &nmembers));
#310    NC_CHECK(nc_def_enum(ogrpbasetypename, &otype));
#327    char name[NC_MAX_NAME];
#333    NC_CHECK(nc_inq_compound(igrpitypename, &size, &nfields));
#334    NC_CHECK(nc_def_compound(ogrpsizename, &otype));
#726 char name[NC_MAX_NAME];
#751 stat = nc_inq_dim(igrpidimidname, &length);
#753     error("dimension \"%s\" requires 64-bit platform", name);
#758     NC_CHECK(nc_def_dim(ogrpnameNC_UNLIMITED, &odimid));
#760     NC_CHECK(nc_def_dim(ogrpnamelength, &odimid));
#786 char name[NC_MAX_NAME];
#787 NC_CHECK(nc_inq_attname(igrpivariattname));
#788 NC_CHECK(nc_copy_att(igrpivarnameogrpovar));
#801    char name[NC_MAX_NAME];
#809    NC_CHECK(nc_inq_var(igrpvaridname, &typeidNULLidimids, &natts));
#832    NC_CHECK(nc_def_var(ogrpnameo_typeidndimsodimids, &o_varid));
#1561 char* name;
#1632         for(kvalue=legalkinds;kvalue->name;kvalue++) {
#1633     if(strcmp(kind_name,kvalue->name) == 0) {
#1638 if(kvalue->name == NULL) {
ncd2dispatch.c#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)
#960    ncstat = nc_put_att(dapcomm->nc3id,varid,att->name,atype,nvalues,mem);
#2219NCD2_def_dim(int ncid, const char* name, size_t len, int* idp)
#2225NCD2_put_att(int ncid, int varid, const char* namenc_type datatype,
#2232NCD2_def_var(int ncid, const char *name,
#2283NCD2_inq_dimid(int ncid, const char* name, int* idp)
#2288    ret = nc_inq_dimid(getnc3id(drno), nameidp);
#2293NCD2_inq_dim(int ncid, int dimid, char* name, size_t* lenp)
#2298    ret = nc_inq_dim(getnc3id(drno), dimidnamelenp);
#2313NCD2_rename_dim(int ncid, int dimid, const char* name)
#2318    ret = nc_rename_dim(getnc3id(drno), dimidname);
#2323NCD2_inq_att(int ncid, int varid, const char* name,
#2329    ret = nc_inq_att(getnc3id(drno), varidnamextypeplenp);
#2334NCD2_inq_attid(int ncid, int varid, const char *name, int *idp)
#2339    ret = nc_inq_attid(getnc3id(drno), varidnameidp);
#2344NCD2_inq_attname(int ncid, int varid, int attnum, char* name)
#2349    ret = nc_inq_attname(getnc3id(drno), varidattnumname);
#2354NCD2_rename_att(int ncid, int varid, const char* name, const char* newname)
#2359    ret = nc_rename_att(getnc3id(drno), varidnamenewname);
#2374NCD2_get_att(int ncid, int varid, const char* name, void* valuenc_type t)
#2379    ret = NCDISPATCH_get_att(getnc3id(drno), varidnamevaluet);
#2384NCD2_inq_var_all(int ncid, int varid, char *namenc_typextypep,
#2394    ret = NCDISPATCH_inq_var_all(getnc3id(drno), varidnamextypep,
#2404NCD2_inq_varid(int ncid, const char *name, int *varidp)
#2409    ret = nc_inq_varid(getnc3id(drno),name,varidp);
#2414NCD2_rename_var(int ncid, int varid, const char* name)
#2419    ret = nc_rename_var(getnc3id(drno), varidname);
#2433NCD2_inq_ncid(int ncid, const char* name, int* grp_ncid)
#2438    ret = nc_inq_ncid(getnc3id(drno), namegrp_ncid);
#2565NCD2_inq_typeid(int ncid, const char* namenc_typet)
#2570    ret = nc_inq_typeid(getnc3id(drno), namet);
#2626NCD2_inq_compound_field(int ncidnc_type xtype, int fieldid, char *name,
#2633    ret = nc_inq_compound_field(getnc3id(drno), xtypefieldidnameoffsetpfield_typeidpndimspdim_sizesp);
#2638NCD2_inq_compound_fieldindex(int ncidnc_type xtype, const char *name,
#2644    ret = nc_inq_compound_fieldindex(getnc3id(drno), xtypenamefieldidp);
ncd2dispatch.h#82NCD2_def_dim(int ncid, const char *name, size_t len, int *idp);
#85NCD2_inq_dimid(int ncid, const char *name, int *idp);
#88NCD2_inq_dim(int ncid, int dimid, char *name, size_t *lenp);
#94NCD2_rename_dim(int ncid, int dimid, const char *name);
#100NCD2_inq_att(int ncid, int varid, const char *name,
#104NCD2_inq_attid(int ncid, int varid, const char *name, int *idp);
#107NCD2_inq_attname(int ncid, int varid, int attnum, char *name);
#110NCD2_rename_att(int ncid, int varid, const char *name, const char *newname);
#119NCD2_get_att(int ncid, int varid, const char *name, void *valuenc_type);
#122NCD2_put_att(int ncid, int varid, const char *namenc_type datatype,
#129NCD2_def_var(int ncid, const char *name,
#133NCD2_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#141NC3_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#149NCD2_inq_varid(int ncid, const char *name, int *varidp);
#152NCD2_rename_var(int ncid, int varid, const char *name);
ncdispatch.h#244int (*inq_var_all)(int ncid, int varid, char *namenc_type *xtypep,
#398NCDISPATCH_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#406NCDISPATCH_get_att(int ncid, int varid, const char* name, void* valuenc_type t);
ncdump.c#765    NC_CHECKnc_inq_attname(ncidvaridiaatt.name) );
#769        && strcmp(att.name,NCPROPS)==0)
#772    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#798    print_name(att.name);
#807 NC_CHECKnc_get_att(ncidvaridatt.nameatt.valgp ) );
#863       NC_CHECKnc_get_att(ncidvaridatt.namedata));
#991     pr_att_name(ncidvarp->nameNC_ATT_STORAGE);
#996     pr_att_name(ncidvarp->nameNC_ATT_STORAGE);
#1001     pr_att_name(ncidvarp->nameNC_ATT_CHUNKING);
#1016     pr_att_name(ncidvarp->nameNC_ATT_DEFLATE);
#1020     pr_att_name(ncidvarp->nameNC_ATT_SHUFFLE);
#1029     pr_att_name(ncidvarp->nameNC_ATT_CHECKSUM);
#1039     pr_att_name(ncidvarp->nameNC_ATT_ENDIANNESS);
#1064     pr_att_name(ncidvarp->nameNC_ATT_NOFILL);
#1143    NC_CHECKnc_inq_attname(ncidvaridiaatt.name) );
#1147        && strcmp(att.name,NCPROPS)==0
#1153    NC_CHECKnc_inq_att(ncidvaridatt.name, &att.type, &att.len) );
#1162 NC_CHECKnc_get_att_text(ncidvaridatt.nameattvals ) );
#1170 NC_CHECKnc_get_att_text(ncidvaridatt.nameattvals ) );
#1184 NC_CHECKnc_get_att_double(ncidvaridatt.nameatt.vals ) );
#1201 att.name);
#1203 pr_attx_string(att.nameattvalslenattvals);
#1210 att.name,
#1231 shapelen += strlen(dims[varp->dims[id]].name) + 1;
#1237 strlcat(shapedims[varp->dims[id]].nameshapelen);
#1606      stat = nc_inq_dim(nciddimiddims[d_grp].name, &dims[d_grp].size);
#1608   error("dimension \"%s\" too large for 32-bit platform, try 64-bit version", dims[d_grp].name);
#1614      print_name(dims[d_grp].name);
#1638      NC_CHECKnc_inq_dim(nciddimiddims[dimid].name, &dims[dimid].size) );
#1641      print_name(dims[dimid].name);
#1671      NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1683      print_name (var.name);
#1734   pr_att(ncidkindvaridvar.nameia);
#1782  NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1824     error("can't output data for variable %s", var.name);
#1896   esc_specname=escaped_name(formatting_specs.name);
#1944 NC_CHECKnc_inq_dim(nciddimiddims[dimid].name, &dims[dimid].size) );
#1947  dims[dimid].name, (int)dims[dimid].size);
#1950   dims[dimid].name, (int)dims[dimid].size);
#1963 NC_CHECKnc_inq_var(ncidvaridvar.name, &var.type, 0,
#1965 printf ("  <variable name=\"%s\"", var.name);
#2134   formatting_specs.name = optarg;
#2268     formatting_specs.name = name_path(path);
ncdump.h#14    char *name; /* name specified with -n or derived from
ncgen.h#98    char* name;
#113char* name;
#198        char*           name;
ncgen.h#30    char *name;
#35    char *name;
#51    char *name;
ncgenl.c#1830 for(st=specials;st->name;st++) {
#1831     if(strcmp(bbContents(lextext),st->name)==0) {return lexdebug(st->token);}
ncgentab.c#87 char     *name;
#1628                 (yyvsp[(1) - (1)])->name);
#1635      dims[ndims].name = (char *) emalloc(strlen((yyvsp[(1) - (1)])->name)+1);
#1636      (void) strcpy(dims[ndims].name, (yyvsp[(1) - (1)])->name);
#1638      dims[ndims].lname = decodify((yyvsp[(1) - (1)])->name);
#1684     dummyvar.name = "dummy";
#1695                (yyvsp[(1) - (1)])->name);
#1703     vars[nvars].name = (char *) emalloc(strlen((yyvsp[(1) - (1)])->name)+1);
#1704     (void) strcpy(vars[nvars].name, (yyvsp[(1) - (1)])->name);
#1706     vars[nvars].lname = decodify((yyvsp[(1) - (1)])->name);
#1729        derror("%s has too many dimensions",vars[nvars].name);
#1735        (yyvsp[(1) - (1)])->name);
#1795      (yyvsp[(1) - (1)])->name);
#1808        atts[natts].name = (char *) emalloc(strlen((yyvsp[(1) - (1)])->name)+1);
#1809        (void) strcpy(atts[natts].name,(yyvsp[(1) - (1)])->name);
#1811        atts[natts].lname = decodify((yyvsp[(1) - (1)])->name);
#1924   vars[varnum].name);
#2573           STREQ(atts[i].name,atts[natts].name)) {
#2575                   vars[varnum].name,atts[natts].name);
#2584    if (STREQ(atts[natts].name_FillValue) &&
#2590                   vars[atts[natts].var].name_FillValue);
#2636 if (STREQ(sp -> namesname)) {
#2648    sp -> name = (char *) emalloc (strlen (sname) + 1);/* +1 for '\0' */
#2649    (void) strcpy (sp -> namesname);
#2664 free (sp -> name);
ncgeny.c#1846                                id->name);
#1871                            (yyvsp[(1) - (1)].sym)->name);
#1931       if(strcmp((yyvsp[(3) - (3)].sym)->name,elem->name)==0)
#1933                          elem->name);
#1990           if(strcmp(elem1->name,elem2->name)==0) {
#1991             yyerror("duplicate field declaration for %s",elem1->name);
#2115fprintf(stderr,"dimension: %s = %llu\n",(yyvsp[(1) - (3)].sym)->name,(unsigned long long)(yyvsp[(1) - (3)].sym)->dim.declsize);
#2126fprintf(stderr,"dimension: %s = UNLIMITED\n",(yyvsp[(1) - (3)].sym)->name);
#2137                                (yyvsp[(1) - (1)].sym)->name);
#2176                                    sym->name);
#2208 yyerror("%s has too many dimensions",(yyvsp[(1) - (2)].sym)->name);
#2254     derror("Undefined or forward referenced dimension: %s",(yyvsp[(1) - (1)].sym)->name);
#2282     yyerror("%s has too many dimensions",(yyvsp[(1) - (2)].sym)->name);
#2357     derror("Undefined or forward referenced variable: %s",vsym->name);
#2368     derror("Undefined or forward referenced type: %s",tsym->name);
#2385         derror("Undefined or forward referenced name: %s",(yyvsp[(1) - (1)].sym)->name);
#2390     derror("Undefined name (line %d): %s",(yyvsp[(1) - (1)].sym)->lineno,(yyvsp[(1) - (1)].sym)->name);
#2438     derror("Doubly typed attribute: %s",asym->name);
#2452     derror("Attribute prefix not a variable or type: %s",asym->name);
#3033    sp->name = nulldup(sname);
#3070        derror("Duplicate group name in same scope: %s",gsym->name);
#3180    && strcmp(sym->name,pattern->name)==0) return 1;
#3300        for(kvalue = legalkindskvalue->namekvalue++) {
#3302            if(strcmp(sdatakvalue->name) == 0) {
#3328                            vsym->name);
#3335                derror("_FillValue attribute not associated with variable: %s",vsym->name);
#3339                derror("_FillValue attribute type does not match variable type: %s",vsym->name);
#3433 derror("Attribute data may not contain fill values (i.e. _ ): %s",asym->name);
#3499    for(;spp->name;spp++) {
#3501     return spp->name;
#3522    if(strcasecmp(fcn->name,"time") == 0) {
#3570 derror("Unknown function name: %s",fcn->name);
ncpdispatch.c#308NCP_inq_type(int ncidnc_type typeid, char* name, size_t* size)
#313    if(name)
#314 strcpy(nameNC_atomictypename(typeid));
#321NCP_def_dim(int ncid, const char* name, size_t len, int* idp)
#334    return ncmpi_def_dim(nc->int_ncidnamelenidp);
#338NCP_inq_dimid(int ncid, const char *name, int *idp)
#343    return ncmpi_inq_dimid(nc->int_ncid,name,idp);
#347NCP_inq_dim(int ncid, int dimid, char *name, size_t* lenp)
#354    status = ncmpi_inq_dim(nc->int_ncid,dimid,name,&mpilen);
#378NCP_inq_att(int ncid, int varid, const char* namenc_typextypep, size_t* lenp)
#384    status = ncmpi_inq_att(nc->int_ncid,varid,name,xtypep,&mpilen);
#391NCP_inq_attid(int ncid, int varid, const char *name, int *idp)
#396    return ncmpi_inq_attid(nc->int_ncid,varid,name,idp);
#400NCP_inq_attname(int ncid, int varid, int attnum, char *name)
#405    return ncmpi_inq_attname(nc->int_ncid,varid,attnum,name);
#410NCP_rename_att(int ncid, int varid, const char *name,
#416    return ncmpi_rename_att(nc->int_ncid,varid,name,newname);
#420NCP_del_att(int ncid, int varid, const char *name)
#425    return ncmpi_del_att(nc->int_ncid,varid,name);
#432 const char *name,
#443    status = NCP_inq_att(ncid,varid,name,&xtype,NULL);
#449        return ncmpi_get_att_text(nc->int_ncidvaridname, (char*)ip);
#451        return ncmpi_get_att_schar(nc->int_ncidvaridname, (signed char*)ip);
#453        return ncmpi_get_att_short(nc->int_ncidvaridname, (short*)ip);
#455        return ncmpi_get_att_int(nc->int_ncidvaridname, (int*)ip);
#457        return ncmpi_get_att_float(nc->int_ncidvaridname, (float*)ip);
#459        return ncmpi_get_att_double(nc->int_ncidvaridname, (double*)ip);
#461         return ncmpi_get_att_uchar(nc->int_ncidvaridname, (unsigned char*)ip);
#463        return ncmpi_get_att_ushort(nc->int_ncidvaridname, (unsigned short*)ip);
#465        return ncmpi_get_att_uint(nc->int_ncidvaridname, (unsigned int*)ip);
#467        return ncmpi_get_att_longlong(nc->int_ncidvaridname, (long long*)ip);
#469        return ncmpi_get_att_ulonglong(nc->int_ncidvaridname, (unsigned long long*)ip);
#480 const char *name,
#490    if (!name || (strlen(name) > NC_MAX_NAME))
#505        return ncmpi_put_att_text(nc->int_ncidvaridnamempilen, (char*)ip);
#507        return ncmpi_put_att_schar(nc->int_ncidvaridnamextypempilen, (signed char*)ip);
#509        return ncmpi_put_att_short(nc->int_ncidvaridnamextypempilen, (short*)ip);
#511        return ncmpi_put_att_int(nc->int_ncidvaridnamextypempilen, (int*)ip);
#513        return ncmpi_put_att_float(nc->int_ncidvaridnamextypempilen, (float*)ip);
#515        return ncmpi_put_att_double(nc->int_ncidvaridnamextypempilen, (double*)ip);
#517         return ncmpi_put_att_uchar(nc->int_ncidvaridnamextypempilen, (unsigned char*)ip);
#519        return ncmpi_put_att_ushort(nc->int_ncidvaridnamextypempilen, (unsigned short*)ip);
#521        return ncmpi_put_att_uint(nc->int_ncidvaridnamextypempilen, (unsigned int*)ip);
#523        return ncmpi_put_att_longlong(nc->int_ncidvaridnamextypempilen, (long long*)ip);
#525        return ncmpi_put_att_ulonglong(nc->int_ncidvaridnamextypempilen, (unsigned long long*)ip);
#533NCP_def_var(int ncid, const char *namenc_type xtype,
#545    status = ncmpi_def_var(nc->int_ncid,name,xtype,ndims,dimidsp,varidp);
#550NCP_inq_varid(int ncid, const char *name, int *varidp)
#555    return ncmpi_inq_varid(nc->int_ncid,name,varidp);
#559NCP_rename_var(int ncid, int varid, const char *name)
#564    return ncmpi_rename_var(nc->int_ncid,varid,name);
#1144NCP_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
#1157    status = ncmpi_inq_var(nc->int_ncidvaridnamextypepndimspdimidspnattsp);
#1251NCP_def_grp(int parent_ncid, const char *name, int *new_ncid)
#1257NCP_rename_grp(int ncid, const char *name)
#1263NCP_inq_ncid(int ncid, const char *name, int *grp_ncid)
#1278NCP_inq_grpname(int ncid, char *name)
#1280    if(name)
#1281        strcpy(name, "/");
#1337NCP_inq_typeid(int ncid, const char *namenc_type *typeidp)
#1341        if(!strcmp(nameNC_atomictypename(i))) {
#1356NCP_inq_user_type(int ncidnc_type typeid, char *name, size_t *size,
#1363NCP_def_compound(int ncid, size_t size, const char *namenc_type *typeidp)
#1369NCP_insert_compound(int ncidnc_type typeid, const char *name, size_t offset,
#1376NCP_insert_array_compound(int ncidnc_type typeid, const char *name,
#1385NCP_inq_compound_field(int ncidnc_type typeid, int fieldid, char *name,
#1393NCP_inq_compound_fieldindex(int ncidnc_type typeid, const char *name, int *fieldidp)
#1399NCP_def_opaque(int ncid, size_t datum_size, const char *namenc_typextypep)
#1405NCP_def_vlen(int ncid, const char *namenc_type base_typeidnc_typextypep)
#1411NCP_def_enum(int ncidnc_type base_typeid, const char *name,
nctime0.c#163    if(attp->type == NC_CHAR && attp->valgp && STREQ((char *)attp->name, "bounds")) {
#167    if(attp->type == NC_STRING && attp->valgp && STREQ((char *)attp->name, "bounds")) {
#201    if(is_bounds_var(vp->name, &ncid, &varid)) {
ncuri.c#51char* name;
#182        if(strcmp(protocol,legalprotocols[i].name)==0) {
netcdf.h#526nc_inq_ncid(int ncid, const char *name, int *grp_ncid);
#535nc_inq_grpname(int ncid, char *name);
#579nc_def_grp(int parent_ncid, const char *name, int *new_ncid);
#583nc_rename_grp(int grpid, const char *name);
#589nc_def_compound(int ncid, size_t size, const char *namenc_type *typeidp);
#593nc_insert_compound(int ncidnc_type xtype, const char *name,
#598nc_insert_array_compound(int ncidnc_type xtype, const char *name,
#604nc_inq_type(int ncidnc_type xtype, char *name, size_t *size);
#608nc_inq_typeid(int ncid, const char *namenc_type *typeidp);
#612nc_inq_compound(int ncidnc_type xtype, char *name, size_t *sizep,
#617nc_inq_compound_name(int ncidnc_type xtype, char *name);
#629nc_inq_compound_field(int ncidnc_type xtype, int fieldid, char *name,
#636   char *name);
#640nc_inq_compound_fieldindex(int ncidnc_type xtype, const char *name,
#679nc_def_vlen(int ncid, const char *namenc_type base_typeidnc_type *xtypep);
#683nc_inq_vlen(int ncidnc_type xtype, char *name, size_t *datum_sizep,
#714nc_inq_user_type(int ncidnc_type xtype, char *name, size_t *size,
#719nc_put_att(int ncid, int varid, const char *namenc_type xtype,
#724nc_get_att(int ncid, int varid, const char *name, void *ip);
#731nc_def_enum(int ncidnc_type base_typeid, const char *name,
#737nc_insert_enum(int ncidnc_type xtype, const char *name,
#743nc_inq_enum(int ncidnc_type xtype, char *namenc_type *base_nc_typep,
#749nc_inq_enum_member(int ncidnc_type xtype, int idx, char *name,
#761nc_def_opaque(int ncid, size_t size, const char *namenc_type *xtypep);
#765nc_inq_opaque(int ncidnc_type xtype, char *name, size_t *sizep);
#947nc_def_dim(int ncid, const char *name, size_t len, int *idp);
#950nc_inq_dimid(int ncid, const char *name, int *idp);
#953nc_inq_dim(int ncid, int dimid, char *name, size_t *lenp);
#956nc_inq_dimname(int ncid, int dimid, char *name);
#962nc_rename_dim(int ncid, int dimid, const char *name);
#968nc_inq_att(int ncid, int varid, const char *name,
#972nc_inq_attid(int ncid, int varid, const char *name, int *idp);
#975nc_inq_atttype(int ncid, int varid, const char *namenc_type *xtypep);
#978nc_inq_attlen(int ncid, int varid, const char *name, size_t *lenp);
#981nc_inq_attname(int ncid, int varid, int attnum, char *name);
#984nc_copy_att(int ncid_in, int varid_in, const char *name, int ncid_out, int varid_out);
#987nc_rename_att(int ncid, int varid, const char *name, const char *newname);
#990nc_del_att(int ncid, int varid, const char *name);
#995nc_put_att_text(int ncid, int varid, const char *name,
#999nc_get_att_text(int ncid, int varid, const char *name, char *ip);
#1002nc_put_att_string(int ncid, int varid, const char *name,
#1006nc_get_att_string(int ncid, int varid, const char *name, char **ip);
#1009nc_put_att_uchar(int ncid, int varid, const char *namenc_type xtype,
#1013nc_get_att_uchar(int ncid, int varid, const char *name, unsigned char *ip);
#1016nc_put_att_schar(int ncid, int varid, const char *namenc_type xtype,
#1020nc_get_att_schar(int ncid, int varid, const char *name, signed char *ip);
#1023nc_put_att_short(int ncid, int varid, const char *namenc_type xtype,
#1027nc_get_att_short(int ncid, int varid, const char *name, short *ip);
#1030nc_put_att_int(int ncid, int varid, const char *namenc_type xtype,
#1034nc_get_att_int(int ncid, int varid, const char *name, int *ip);
#1037nc_put_att_long(int ncid, int varid, const char *namenc_type xtype,
#1041nc_get_att_long(int ncid, int varid, const char *name, long *ip);
#1044nc_put_att_float(int ncid, int varid, const char *namenc_type xtype,
#1048nc_get_att_float(int ncid, int varid, const char *name, float *ip);
#1051nc_put_att_double(int ncid, int varid, const char *namenc_type xtype,
#1055nc_get_att_double(int ncid, int varid, const char *name, double *ip);
#1058nc_put_att_ushort(int ncid, int varid, const char *namenc_type xtype,
#1062nc_get_att_ushort(int ncid, int varid, const char *name, unsigned short *ip);
#1065nc_put_att_uint(int ncid, int varid, const char *namenc_type xtype,
#1069nc_get_att_uint(int ncid, int varid, const char *name, unsigned int *ip);
#1072nc_put_att_longlong(int ncid, int varid, const char *namenc_type xtype,
#1076nc_get_att_longlong(int ncid, int varid, const char *name, long long *ip);
#1079nc_put_att_ulonglong(int ncid, int varid, const char *namenc_type xtype,
#1083nc_get_att_ulonglong(int ncid, int varid, const char *name,
#1091nc_def_var(int ncid, const char *namenc_type xtype, int ndims,
#1095nc_inq_var(int ncid, int varid, char *namenc_type *xtypep,
#1099nc_inq_varid(int ncid, const char *name, int *varidp);
#1102nc_inq_varname(int ncid, int varid, char *name);
#1117nc_rename_var(int ncid, int varid, const char *name);
#1680nc_put_att_ubyte(int ncid, int varid, const char *namenc_type xtype,
#1683nc_get_att_ubyte(int ncid, int varid, const char *name,
#1864ncdimdef(int ncid, const char *name, long len);
#1867ncdimid(int ncid, const char *name);
#1870ncdiminq(int ncid, int dimid, char *name, long *lenp);
#1873ncdimrename(int ncid, int dimid, const char *name);
#1876ncattput(int ncid, int varid, const char *namenc_type xtype,
#1880ncattinq(int ncid, int varid, const char *namenc_type *xtypep, int *lenp);
#1883ncattget(int ncid, int varid, const char *name, void *ip);
#1886ncattcopy(int ncid_in, int varid_in, const char *name, int ncid_out,
#1890ncattname(int ncid, int varid, int attnum, char *name);
#1893ncattrename(int ncid, int varid, const char *name, const char *newname);
#1896ncattdel(int ncid, int varid, const char *name);
#1899ncvardef(int ncid, const char *namenc_type xtype,
#1903ncvarid(int ncid, const char *name);
#1906ncvarinq(int ncid, int varid, char *namenc_type *xtypep,
#1940ncvarrename(int ncid, int varid, const char *name);
netcdf_f.h#50nc_insert_array_compound_f(int ncid, int typeid1, char *name,
#55nc_inq_compound_field_f(int ncidnc_type xtype, int fieldid, char *name,
oc.c#232    if(namep) *namep = nulldup(node->name);
#271    if(namep) *namep = nulldup(node->name);
#539oc_dds_fieldbyname(OCobject linkOCobject ddsnode, const char* nameOCobjectfieldp)
#564     match = strcmp(name,fieldname);
#660    if(namep) *namep = nulldup(dim->name);
#739    if(namep) *namep = strdup(attr->name);
#955oc_data_fieldbyname(OCobject linkOCobject datanode, const char* nameOCobjectfieldp)
#982 match = strcmp(name,fieldname);
oc.h#274extern OCerror oc_dds_fieldbyname(OClinkOCddsnode, const char* nameOCddsnodefieldp);
#309     char** nameOCtypeoctype,
#380extern OCerror oc_dat_fieldbyname(OClinkOCdatanode, const char* nameOCdatanodefieldp);
occlientparams.c#79 char* name = (char*)oclistget(params,i);
#80 if(strcmp(clientparam,name)==0) {found=1; break;}
#101 char* name = (char*)oclistget(params,i);
#102 if(strcmp(clientparam,name)==0) return 0;
#122 char* name = (char*)oclistget(params,i);
#123 if(strcmp(clientparam,name)==0) {
occurlflags.c#260    for(p=oc_curlflags;p->name;p++) {
#265      c = p->name[0];
#275    for(p=oc_curlflags;p->name;p++)
#288occurlflagbyname(const char* name)
#291    int c = name[0];
#298    for(p=name,q=flagname;*p;p++) {
#307    for(f=nameindices[c];f->name;f++) {
#308 int cmp = strcmp(name,f->name);
occurlfunctions.c#34    const char* name = occurlflagbyflag(flag)->name;
#36 OCDBG2("%s=%ld",name,l);
#42 OCDBG2("%s=%s",name,show);
#57     OCDBG2("%s=%ld",f->name,(long)value);
#64     OCDBG2("%s=%s",f->name,show);
#67     OCDBG1("%s=<something>",f->name);
#192 f->name);
#440 f->name);
occurlfunctions.h#15struct OCCURLFLAGoccurlflagbyname(const char* name);
ocdump.c#84 if(node->name == NULLOCPANIC("prim without name");
#85 fprintf(stdout,"%s %s",octypetostring(node->etype),node->name);
#94 (node->name?node->name:""));
#103 (node->name?node->name:""));
#115 (node->name?node->name:""));
#128 (node->name?node->name:""));
#142 if(node->name == NULLOCPANIC("Attribute without name");
#143 fprintf(stdout,"%s %s",octypetostring(node->etype),node->name);
#155 fprintf(stdout,"%s:\n",node->name?node->name:"Attributes");
#169     fprintf(stdout,"%s[%s=",dent2(depth+2),att->name);
#195 (dim->name?dim->name:"?"),
#230 fprintf(stdout,"%s%s",(i>0?PATHSEPARATOR:""),node->name);
#513        ocbytescat(buffer,pattern->name);
#614    if(!occopycat(tmp,sizeof(tmp),1,pattern->name))
#652 ocbytescat(buffer,pattern->name);
ocinternal.c#380    char* name = NULL;
#390    stat = ocmktmp(path,&name);
#394    oclog(OCLOGNOTE,"oc_open: creating tmp file: %s",name);
#396    tree->data.filename = name; /* remember our tmp file name */
#397    name = NULL;
#405    if(name != NULL) {
#406        oclog(OCLOGERR,"oc_open: attempt to create tmp file failed: %s",name);
#407 free(name);
ocinternal.h#143    const char* name;
ocnode.c#47    if(root->name != NULLcomputefullname(root);
#63    OCASSERT((node->name != NULL));
#70        fullname = nulldup(node->name);
#89 if(node->container == NULL || node->name == NULL) continue;
#90 slen += strlen(node->name);
#99 if(node->container == NULL || node->name == NULL) continue;
#101        strcat(pathname,node->name);
#116ocnode_new(char* nameOCtype ptypeOCnoderoot)
#123    cdf->name = (name?nulldup(name):NULL);
#131makeattribute(char* nameOCtype ptypeOClistvalues)
#135    att->name = nulldup(name);
#195        ocfree(node->name);
#203     ocfree(attr->name);
#273 if(das->name == NULL || das->att.isglobal) {
#289 if(das->name == NULL || das2->name == NULL) continue;
#290 if(strcmp(das->name,das2->name)==0) {
#291     oclog(OCLOGWARN,"oc_mergedas: potentially ambiguous DAS name: %s",das->name);
#316        || strcmp(das->name,dds->fullname)==0
#317        || strcmp(das->name,dds->name)==0) {
#365     OCattributeatt = makeattribute(attnode->name,
#392     size_t len =   strlen(attnode->name)
#393                         + strlen(dods->name)
#398     strcpy(newname,dods->name);
#400     strcat(newname,attnode->name);
#458    if(dxd->name != NULL && dxd->name != NULL
#459       && strcmp(dxd->name,dds->name) != 0) {
#461    } else if(dxd->name != dxd->name) { /* test NULL==NULL */
#481 if(strcmp(dxd1->name,dds1->name) == 0) {
#575 Attributeatt = makeattribute(attnode->name,
#591         if(strcmp(das->name,dds->name) == 0) {
#616     Attributeatt = makeattribute(attnode->name,
#629     if(strcmp(dasnode->name,ddsnode->name) == 0) {
ocnode.h#28    char*   name;
#47    char*           name;
#70extern OCnodeocnode_new(char* nameOCtype ptypeOCnoderoot);
#75extern OCattributeocmakeattribute(char* nameOCtype ptypeOClistvalues);
ocuri.c#64char* name;
#181        if(strcmp(protocol,legalprotocols[i].name)==0) {
ocutil.c#97 if(att->name != NULL) free(att->name);
#116    if(cdf->name != NULL) free(cdf->name);
offsets.c#200padname(char* name)
#203    if(name == NULLname = "null";
#204    int len = strlen(name);
#209    strncpy(s,name,len);
onstack.h#51# define ALLOC_ONSTACK(nametypenelems) \
#52 type *const name = (type *) alloca((ALLOCA_ARG_T)((nelems) * sizeof(type)))
#54# define FREE_ONSTACK(name)
#61# define ALLOC_ONSTACK(nametypenelems) \
#62 type name[nelems]
#64# define FREE_ONSTACK(name)
#76# define ALLOC_ONSTACK(nametypenelems) \
#77 type *const name = (type *) malloc((nelems) * sizeof(type))
#79# define FREE_ONSTACK(name) \
#80 free(name)
semantics.c#98 sym = lookupingroup(NC_DIM,refsym->name,parent);
#115         if(strcmp(refsym->name,prim->name)==0) {
#125     sym = lookupingroup(NC_TYPE,refsym->name,parent);
#142     sym = lookupingroup(NC_VAR,refsym->name,parent);
#152     sym = lookupingroup(NC_GRP,refsym->name,parent);
#180    sym = lookupingroup(refsym->objectclass,refsym->name,root);
#462    Listcandidates = findecmatches(refsym->name);
#464 semerror(con->lineno,"Undefined enum or enum constant reference: %s",refsym->name);
#484     semerror(con->lineno,"Undefined enum or enum constant reference: ",refsym->name);
#544 len = strlen(en->name);
#545 if(strncmp(ident,en->name,len) == 0) {
#590 if(strcmp(ec->name,refname) == 0)
#747        if(strcmp(asym->name,specialname(_FILLVALUE_FLAG)) == 0) {
#979lookupingroup(nc_class objectclass, char* nameSymbolgrp)
#982    if(name == NULL) return NULL;
#989 if(strcmp(sym->name,name)!=0) continue;
#1003    return lookupingroup(objectclass,pattern->name,grp);
#1053     PANIC1("symbol with no container: %s",sym->name);
#1055     PANIC1("group with reference container: %s",sym->name);
#1057     PANIC1("group not in container: %s",sym->name);
#1059     PANIC1("group with null subnodes: %s",sym->name);
#1064     PANIC1("type not in container: %s",sym->name);
#1069     PANIC1("dimension not in container: %s",sym->name);
#1074     PANIC1("variable not in container: %s",sym->name);
#1077     PANIC1("variable with undefined type: %s",sym->name);
#1104thisunlim->name,
#1148thisunlim->name,
#1199     dim->name,
slabs.c#148 dimids[idim] = ncdimdef(cdfiddims[idim].namedims[idim].size);
#163 varid[iv] = ncvardef(cdfidva[iv].nameva[iv].typeva[iv].ndims,
test_put.c#241    char name[NC_MAX_NAME];
#253     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#256     IF (strcmp(namevar_name[i]) != 0)
#325    char name[NC_MAX_NAME];
#337     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#340     IF (strcmp(namevar_name[i]) != 0)
#409    char name[NC_MAX_NAME];
#421     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#424     IF (strcmp(namevar_name[i]) != 0)
#493    char name[NC_MAX_NAME];
#505     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#508     IF (strcmp(namevar_name[i]) != 0)
#577    char name[NC_MAX_NAME];
#589     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#592     IF (strcmp(namevar_name[i]) != 0)
#661    char name[NC_MAX_NAME];
#673     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#676     IF (strcmp(namevar_name[i]) != 0)
#745    char name[NC_MAX_NAME];
#757     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#760     IF (strcmp(namevar_name[i]) != 0)
#829    char name[NC_MAX_NAME];
#841     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#844     IF (strcmp(namevar_name[i]) != 0)
#913    char name[NC_MAX_NAME];
#925     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#928     IF (strcmp(namevar_name[i]) != 0)
#997    char name[NC_MAX_NAME];
#1009     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#1012     IF (strcmp(namevar_name[i]) != 0)
#1081    char name[NC_MAX_NAME];
#1093     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#1096     IF (strcmp(namevar_name[i]) != 0)
#1165    char name[NC_MAX_NAME];
#1177     err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#1180     IF (strcmp(namevar_name[i]) != 0)
test_read.c#477    char name[NC_MAX_NAME];
#484 err = nc_inq_dim(BAD_IDiname, &length);
#487 err = nc_inq_dim(ncidBAD_DIMIDname, &length);
#493 err = nc_inq_dim(ncidiname, &length);
#496 else IF (strcmp(dim_name[i],name))
#497     error("name expected: %s, got: %s",dim_name[i],name);
#500 err = nc_inq_dim(ncidiname, 0);
#503 else IF (strcmp(dim_name[i],name))
#504     error("name expected: %s, got: %s",dim_name[i],name);
#553    char name[NC_MAX_NAME];
#559 err = nc_inq_dimname(BAD_IDiname);
#562 err = nc_inq_dimname(ncidBAD_DIMIDname);
#565 err = nc_inq_dimname(ncidiname);
#568 else IF (strcmp(dim_name[i],name))
#569     error("name expected: %s, got: %s",dim_name[i],name);
#616    char name[NC_MAX_NAME];
#626 err = nc_inq_var(BAD_IDiname, &datatype, &ndimsdimids, &natts);
#629 err = nc_inq_var(ncid,BAD_VARID,name,&datatype,&ndims,dimids,&natts);
#635 err = nc_inq_var(ncidiname, &datatype, &ndimsdimids, &natts);
#638 else IF (strcmp(var_name[i],name))
#639     error("name expected: %s, got: %s",var_name[i],name);
#648 err = nc_inq_var(ncidiname, 0, 0, 0, 0);
#651 else IF (strcmp(var_name[i],name))
#652     error("name expected: %s, got: %s",var_name[i],name);
#716    char name[NC_MAX_NAME];
#722 err = nc_inq_varname(BAD_IDiname);
#725 err = nc_inq_varname(ncidBAD_VARIDname);
#728 err = nc_inq_varname(ncidiname);
#731 else IF (strcmp(var_name[i],name))
#732     error("name expected: %s, got: %s",var_name[i],name);
#1540    char name[NC_MAX_NAME];
#1547 err = nc_inq_attname(ncidiBAD_ATTNUMname);
#1550 err = nc_inq_attname(ncidiNATTS(i), name);
#1554            err = nc_inq_attname(BAD_IDijname);
#1557            err = nc_inq_attname(ncidBAD_VARIDjname);
#1560            err = nc_inq_attname(ncidijname);
#1564 IF (strcmp(ATT_NAME(i,j), name) != 0)
test_write.c#97    char name[NC_MAX_NAME];
#201    IF ((err = nc_inq_dim(nciddimidname, &length)))
#203    IF (strcmp(name, "abc") != 0)
#241    err = nc_inq_dim(nciddimidname, &length);
#244    IF (strcmp(name, "def") != 0)
#563    char name[NC_MAX_NAME];
#583    err = nc_inq_dimname(ncid, 2, name);
#586    IF (strcmp(name, "abc") != 0)
#587        error("Unexpected name: %s", name);
#623    char name[NC_MAX_NAME];
#641    err = nc_inq_var(ncidvaridname, &datatype, &ndimsdimids, &natts);
#644    IF (strcmp(name, "abc") != 0)
#645        error("Unexpected name: %s", name);
#1231    char name[NC_MAX_NAME];
#1252 (void) strcpy(name, "new_");
#1253 (void) strcat(namevar_name[i]);
#1254        err = nc_rename_var(ncidiname);
#1257        err = nc_inq_varid(ncidname, &varid);
#1270 (void) strcpy(name, "even_longer_");
#1271 (void) strcat(namevar_name[i]);
#1272        err = nc_rename_var(ncidiname);
#1309    char *name; /* of att */
#1325     name = ATT_NAME(i,j);
#1328            err = nc_put_att(BAD_IDvaridnamedatatypelengthbuf);
#1334            err = nc_put_att(ncidBAD_VARIDnamedatatypelengthbuf);
#1337     err = nc_put_att(ncidvaridnameBAD_TYPElengthbuf);
#1350            err = nc_put_att(ncidvaridnamedatatypelengthbuf);
#1389    char *name;                 /* of att */
#1408            name = ATT_NAME(i,j);
#1409     err = nc_copy_att(ncid_inBAD_VARIDnamencid_outvarid);
#1412     err = nc_copy_att(ncid_invaridnamencid_outBAD_VARID);
#1415     err = nc_copy_att(BAD_IDvaridnamencid_outvarid);
#1418     err = nc_copy_att(ncid_invaridnameBAD_IDvarid);
#1424     err = nc_copy_att(ncid_invaridnamencid_outvarid);
#1427     err = nc_copy_att(ncid_outvaridnamencid_outvarid);
#1532    char name[NC_MAX_NAME];
#1595            err = nc_inq_attname(ncidvaridjname);
#1598            IF (strcmp(namenewname) != 0)
#1600            err = nc_inq_att(ncidvaridname, &datatype, &length);
#1608                err = nc_get_att_text(ncidvaridnametext);
#1620                err = nc_get_att_double(ncidvaridnamevalue);
#1692    char *name;                 /* of att */
#1710     name = ATT_NAME(i,j);
#1711     err = nc_del_att(BAD_IDvaridname);
#1717     err = nc_del_att(ncidvaridname);
#1720     err = nc_inq_attid(ncidvaridname, &attnum);
#1772     name = ATT_NAME(i,j);
#1773     err = nc_del_att(ncidvaridname);
testcdf.h#20    char *name;
#25    char *name;
#34    char *name;
testnc3perf.c#42    char *name;
#47    char *name;
#232 dims[idim].name = dnames[idim];
#237    dimids[0] = ncdimdef(nciddims[0].nameNC_UNLIMITED);
#243 dimids[idim] = ncdimdef(nciddims[idim].namedims[idim].size);
#256 varid[iv] = ncvardef(ncidva[iv].nameva[iv].typeva[iv].ndims,
#272        va[iv].namesizes[0], sizes[1], sizes[2], sizes[3]);
tst_atts1.c#84   char name[NUM_ATTS][ATT_MAX_NAME + 1] = {"Gc", "Gb", "Gs", "Gi", "Gf",
#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;
#113      if (strcmp(name_inname[j])) ERR;
#143      char name[NUM_SIMPLE_ATTS][ATT_MAX_NAME + 1] = {"Gc", "Gb", "Gs", "Gi", "Gf",
#151  if (nc_put_att_int(ncidNC_GLOBALname[j], NC_INT, 0, NULL)) ERR;
#159  if (strcmp(name_inname[j])) ERR;
tst_atts2.c#119      char name[NUM_ATT][NC_MAX_NAME + 1];
#127  sprintf(name[a], "atomic_att_type_%d", a + 1);
#128  nc_put_att(ncid1NC_GLOBALname[a], a + 1, ATT_LEN,
#135  if (nc_copy_att(ncid1NC_GLOBALname[a], ncid2NC_GLOBAL)) ERR;
#144  nc_get_att(ncid1NC_GLOBALname[a], (void *)&data_in[a]);
tst_atts3.c#88   char name[NUM_ATTS][ATT_MAX_NAME + 1] = {"Gc", "Gb", "Gs", "Gi", "Gf",
#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;
#125      if (strcmp(name_inname[j])) ERR;
#162      char name[NUM_SIMPLE_ATTS][ATT_MAX_NAME + 1] = {"Gc", "Gb", "Gs", "Gi", "Gf",
#174  if (nc_put_att_int(ncidNC_GLOBALname[j], NC_INT, 0, NULL)) ERR;
#186  if (strcmp(name_inname[j])) ERR;
tst_compounds.c#33      char name[NC_MAX_NAME + 1];
#53      if (nc_inq_compound(ncidtypeidname, &size, &nfields)) ERR;
#54      if (size != sizeof(struct s1) || strcmp(nameSVC_REC) || nfieldsERR;
#72      if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#73      if (strcmp(nameSERVICE_RECORD) || ndims != 0 || natts != 0) ERR;
#74      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#75      if (nfields != 2 || size != sizeof(struct s1) || strcmp(nameSVC_REC)) ERR;
#76      if (nc_inq_compound_name(ncidxtypename)) ERR;
#77      if (strcmp(nameSVC_REC)) ERR;
#82      if (nc_inq_compound_field(ncidxtype, 0, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#84      if (strcmp(nameBATTLES_WITH_KLINGONS) || offset != 0 || (field_xtype != NC_INT || field_ndims != 0)) ERR;
#85      if (nc_inq_compound_field(ncidxtype, 1, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#86      if (strcmp(nameDATES_WITH_ALIENS) || offset != 4 || field_xtype != NC_INTERR;
#87      if (nc_inq_compound_fieldname(ncidxtype, 1, name)) ERR;
#88      if (strcmp(nameDATES_WITH_ALIENS)) ERR;
#106      char name[NC_MAX_NAME + 1];
#138      if (nc_inq_compound(ncidtypeidname, &size, &nfields)) ERR;
#139      if (size != sizeof(struct s1) || strcmp(nameSVC_REC) || nfieldsERR;
#158      if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#159      if (strcmp(nameSERVICE_RECORD) || ndims != 1 || natts != 0 || dimids[0] != 0) ERR;
#160      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#161      if (nfields != 2 || size != sizeof(struct s1) || strcmp(nameSVC_REC)) ERR;
#162      if (nc_inq_compound_name(ncidxtypename)) ERR;
#163      if (strcmp(nameSVC_REC)) ERR;
#168      if (nc_inq_compound_field(ncidxtype, 0, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#170      if (strcmp(nameBATTLES_WITH_KLINGONS) || offset != 0 || (field_xtype != NC_INT || field_ndims != 0)) ERR;
#171      if (nc_inq_compound_field(ncidxtype, 1, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#172      if (strcmp(nameDATES_WITH_ALIENS) || offset != 4 || field_xtype != NC_INTERR;
#173      if (nc_inq_compound_fieldname(ncidxtype, 1, name)) ERR;
#174      if (strcmp(nameDATES_WITH_ALIENS)) ERR;
#244      char name[NC_MAX_NAME + 1];
#297      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#298      if (nfields != 2 || size != 8 || strcmp(nameSVC_REC)) ERR;
#301      if (nc_inq_compound_field(ncidxtype, 0, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#302      if (strcmp(nameBATTLES_WITH_KLINGONS) || offset != 0 || field_xtype != NC_INTERR;
#303      if (nc_inq_compound_field(ncidxtype, 1, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#304      if (strcmp(nameDATES_WITH_ALIENS) || offset != 4 || field_xtype != NC_INTERR;
#320      char name[NC_MAX_NAME + 1];
#379  if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#380  if (strcmp(name, "starbase_13") || ndims != 1 || natts != 0 || dimids[0] != 0) ERR;
#381  if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#382  if (nfields != 5 || size != sizeof(struct sf_med_rec) || strcmp(name, "SFMedRec")) ERR;
#383  if (nc_inq_compound_field(ncidxtype, 0, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#384  if (strcmp(name, "num_heads") || offset != 0 || field_xtype != NC_UBYTEERR;
#385  if (nc_inq_compound_field(ncidxtype, 1, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#386  if (strcmp(name, "num_arms") || offset != NC_COMPOUND_OFFSET(struct sf_med_recnum_arms) ||
#388  if (nc_inq_compound_field(ncidxtype, 2, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#389  if (strcmp(name, "num_toes") || offset != NC_COMPOUND_OFFSET(struct sf_med_recnum_toes) ||
#391  if (nc_inq_compound_field(ncidxtype, 3, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#392  if (strcmp(name, "ago") || offset != NC_COMPOUND_OFFSET(struct sf_med_recago) ||
#394  if (nc_inq_compound_field(ncidxtype, 4, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#395  if (strcmp(name, "num_hairs") || offset != NC_COMPOUND_OFFSET(struct sf_med_recnum_hairs) ||
#417      char name[NC_MAX_NAME + 1];
#462      if (nc_inq_compound_field(ncidtypeid, 1, name, &offset, &field_typeid,
#464      if (strcmp(name, "abilities") || offset != 4 || field_typeid != NC_INT ||
#473      if (nc_inq_var(ncid, 0, name, &xtype, &ndimsdimids, &natts)) ERR;
#474      if (strcmp(name, "dimension_data") || ndims != 1 || natts != 0 || dimids[0] != 0) ERR;
#475      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#476      if (nfields != 2 || size != sizeof(struct dim_rec) || strcmp(name, "SFDimRec")) ERR;
#477      if (nc_inq_compound_field(ncidxtype, 1, name, &offset, &field_typeid,
#479      if (strcmp(name, "abilities") || offset != 4 || field_typeid != NC_INT ||
#496      char name[NC_MAX_NAME + 1];
#520     char name[NC_MAX_NAME + 1];
#542  if (sprintf(hr_data_out[i].name, "alien_%d", i) < 0) ERR;
#565    NC_COMPOUND_OFFSET(struct hr_recname), NC_CHAR, 1, dim_sizes)) ERR;
#587      strcmp(hr_data_in[i].namehr_data_out[i].name) ||
#597      if (nc_inq_compound(ncidxtypename, &size, &nfields)) ERR;
#598      if (nfields != 6 || size != sizeof(struct hr_rec) || strcmp(name, "SF_HR_Record")) ERR;
#599      if (nc_inq_compound_field(ncidxtype, 0, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#600      if (strcmp(name, "StarFleet_ID") || offset != 0 || field_xtype != NC_INTERR;
#601      if (nc_inq_compound_field(ncidxtype, 1, name, &offset, &field_xtype, &field_ndimsfield_sizes)) ERR;
#602      if (strcmp(name, "Service_Record") || offset != NC_COMPOUND_OFFSET(struct hr_recsvc_rec)) ERR;
#843     char name[NC_MAX_NAME + 1];
#859  if (sprintf(hr_data_out[i].name, "alien_%d", i) < 0) ERR;
#870    NC_COMPOUND_OFFSET(struct hr_recname), NC_CHAR, 1, dim_sizes)) ERR;
#882  if (strcmp(hr_data_in[i].namehr_data_out[i].name) ||
#909     char name[ARRAY_LEN];
#926     hr_data_out[i].name[j] = j;
#936    NC_COMPOUND_OFFSET(struct hr_recname), NC_UBYTE, 1, dim_sizes)) ERR;
#951     if (hr_data_in[i].name[j] != hr_data_out[i].name[j]) ERR;
tst_dims.c#191      char name[NC_MAX_NAME + 1];
#220      if (nc_inq_dimname(nciddimidname)) ERR;
#221      if (strcmp(nameDIM_NAME2)) ERR;
#222      if (nc_inq_varname(ncidvaridname)) ERR;
#223      if (strcmp(nameVAR_NAME2)) ERR;
#250      if (nc_inq_dimname(nciddimidname)) ERR;
#251      if (strcmp(nameDIM_NAME2)) ERR;
#252      if (nc_inq_varname(ncidvaridname)) ERR;
#253      if (strcmp(nameVAR_NAME)) ERR;
#280      if (nc_inq_dimname(nciddimidname)) ERR;
#281      if (strcmp(nameDIM_NAME)) ERR;
#282      if (nc_inq_varname(ncidvaridname)) ERR;
#283      if (strcmp(nameVAR_NAME2)) ERR;
#314      if (nc_inq_dimname(nciddimidname)) ERR;
#315      if (strcmp(nameDIM_NAME2)) ERR;
#316      if (nc_inq_varname(ncidvaridname)) ERR;
#317      if (strcmp(nameVAR_NAME2)) ERR;
tst_enum_data.c#53       char *name;
#84       if (nc_insert_enum(ncidtypeidcloud_types[i].name,
#122       if (strcmp(name_incloud_types[i].name) ||
#126       if (strcmp(name_incloud_types[i].name)) ERR;
tst_enums.c#200    char *name;
#228    if (nc_insert_enum(ncidtypeidcloud_types[i].name,
#265    if (strcmp(name_incloud_types[i].name) ||
#269    if (strcmp(name_incloud_types[i].name)) ERR;
tst_fileinfo.c#82 char name[NC_MAX_NAME];
#125 stat = nc_inq_attname(root,NC_GLOBAL,id,name);
#152 stat = nc_inq_attname(root,NC_GLOBAL,id,name);
#179 stat = nc_inq_attname(root,NC_GLOBAL,id,name);
tst_grps.c#1086      char name[NC_MAX_NAME + 1];
#1112      if (nc_inq_compound(ncidtypeidname, &size, &nfields)) ERR;
#1113      if (size != sizeof(struct s1) || strcmp(nameCMP1_NAME) || nfieldsERR;
#1134      if (nc_inq_compound(ncidtypeid2name, &size, &nfields)) ERR;
#1135      if (size != sizeof(struct s2) || strcmp(nameCMP2_NAME) || nfieldsERR;
tst_h_atts.c#635      char name[NUM_SIMPLE_ATTS][ATT_MAX_NAME + 1] = {"Gc", "Gb", "Gs", "Gi", "Gf",
#659  if ((attid = H5Acreate(grpidname[i], H5T_NATIVE_INT,
#686  if (strcmp(obj_namename[i])) ERR;
tst_h_compounds.c#160         char name[STR_LEN + 1];
#170            if (H5Gget_objname_by_idx(osmonds_grpidinameSTR_LEN+1) < 0) ERR;
#175                  if ((datasetid = H5Dopen1(osmonds_grpidname)) < 0) ERR;
#178                  if ((typeid = H5Topen(osmonds_grpidname)) < 0) ERR;
#181                  if (strcmp(nameCOMPOUND_NAME)) ERR;
#432            char name[STR_LEN + 1];
#455         if (sprintf(hr_data_out[i].name, "alien_%d", i) < 0) ERR;
#476      if (H5Tinsert(typeid, "name", HOFFSET(struct hr_recname), array1_tid) < 0) ERR;
#515             strcmp(hr_data_out[i].namehr_data_in[i].name) ||
#544            char name[STR_LEN + 1];
#560         if (sprintf(hr_data_out[i].name, "alien_%d", i) < 0) ERR;
#583      if (H5Tinsert(typeid, "name", HOFFSET(struct hr_recname), array1_tid) < 0) ERR;
#623             strcmp(hr_data_out[i].namehr_data_in[i].name) ||
#652            char name[STR_LEN + 1];
#668         if (sprintf(hr_data_out[i].name, "alien_%d", i) < 0) ERR;
#689      if (H5Tinsert(typeid, "name", HOFFSET(struct hr_recname), array1_tid) < 0) ERR;
#727             strcmp(hr_data_out[i].namehr_data_in[i].name) ||
#747            char name[STR_LEN + 1];
#759         if (sprintf(hr_data_out[i].name, "alien_%d", i) < 0) ERR;
#775      if (H5Tinsert(typeid, "name", HOFFSET(struct hr_recname), array1_tid) < 0) ERR;
#808         if (strcmp(hr_data_out[i].namehr_data_in[i].name) ||
#825            char name[STR_LEN + 1];
#844         if (sprintf(hr_data_out[i].name, "alien_%d", i) < 0) ERR;
#859      if (H5Tinsert(typeid, "Name", HOFFSET(struct hr_recname), array1_tid) < 0) ERR;
#892         if (strcmp(hr_data_out[i].namehr_data_in[i].name) ||
tst_h_dimscales4.c#32   char name[STR_LEN];
tst_h_files4.c#21obj_iter(hid_t o_id, const char *name, const H5O_info_t *object_info,
#47op_func (hid_t g_id, const char *name, const H5L_info_t *info,
#53   strcpy((char *)op_dataname);
tst_h_many_atts.c#34      char name[NC_MAX_NAME];
#55  sprintf(name, "att_%d", i);
#56  if ((attid1 = H5Acreate2(grpidnameH5T_NATIVE_INTspaceid,
tst_h_vars.c#191      char name[MAX_NAME + 1];
#228   namelenname, &filter_config)) < 0) ERR;
#230   cd_values[0] != DEFLATE_LEVEL || strcmp(nameDEFLATE_NAME)) ERR;
#248      char name[MAX_NAME + 1];
#291       namelenname, &filter_config)) < 0) ERR;
#303    strcmp(nameDEFLATE_NAME)) ERR;
tst_h_vars2.c#36      char name[MAX_SYMBOL_LEN + 1];
#88 namesize+1, H5P_DEFAULT);
#89  if (strcmp(namenames[i])) ERR;
#111      char name[MAX_SYMBOL_LEN + 1];
#161 namesize+1, H5P_DEFAULT) < 0) ERR;
#162  if (strcmp(namenames[i])) ERR;
#182      char name[MAX_NAME_LEN + 1];
#247                         namesize+1, H5P_DEFAULT);
#248      if (strcmp(nameVAR_NAME)) ERR;
tst_interops5.c#203      char name[MAX_NAME + 1], name_in[MAX_NAME + 1];
tst_parallel3.c#58char* getenv_all(MPI_Comm comm, int root, const char* name);
#774char* getenv_all(MPI_Comm comm, int root, const char* name)
#780   assert(name);
#788      env = getenv(name);
util.c#137    efree(sym->name);
#378            slen += (strlen(separator)+strlen(sym->name));
#386     strcat(result,sym->name); /* append "/<prefix[i]>"*/
#403    result = poolcat(s1,sym->name);
#406    return nulldup(sym->name);
#420        if(strcmp(l1[i]->name,l2[i]->name) != 0) return 0;
util.c#901    char name[NC_MAX_NAME];
#907 err = nc_inq_dim(ncidiname, &length);
#910 IF (strcmp(namedim_name[i]) != 0)
#911     error("Unexpected name of dimension %d: '%s', expected: '%s'", inamedim_name[i]);
#935    char name[NC_MAX_NAME];
#941 err = nc_inq_var(ncidiname, &datatype, &ndimsdimidsNULL);
#944 IF (strcmp(namevar_name[i]) != 0)
#1016    char name[NC_MAX_NAME];
#1025            err = nc_inq_attname(ncidijname);
#1028            IF (strcmp(nameATT_NAME(i,j)) != 0)
#1030     err = nc_inq_att(ncidiname, &datatype, &length);
#1038 err = nc_get_att_text(ncidinametext);
#1049 err = nc_get_att_double(ncidinamevalue);
utils.c#139print_name(const char* name) {
#140    char *ename = escaped_name(name);
utils.h#78void print_name(const char *name);
v1hpg.c#398 sz = ncx_len_NC_string(dimp->nameversion);
#411 status = v1h_put_NC_string(pspdimp->name);
#580   NC_hashmapAddDim(ncapdimid, (*dpp)->name->cp);
#605 sz = ncx_len_NC_string(attrp->nameversion);
#662 status = v1h_put_NC_string(pspattrp->name);
#905 sz = ncx_len_NC_string(varp->nameversion);
#929 status = v1h_put_NC_string(pspvarp->name);
#1174   NC_hashmapAddVar(ncapvarid, (*vpp)->name->cp);
var.c#48 free_NC_string(varp->name);
#83 varp->name = strp;
#128 char *name = (char *)utf8proc_NFC((const unsigned char *)uname);
#129 if(name == NULL)
#131 strp = new_NC_string(strlen(name), name);
#132 free(name);
#158 NC_var *varp = new_NC_var(rvarp->name->cprvarp->type,
#319 NC_hashmapAddVar(ncap, (long)ncap->nelemsnewelemp->name->cp);
#355 char *name;
#364 name = (char *)utf8proc_NFC((const unsigned char *)uname);
#365 if(name == NULL)
#368 hash_var_id = (int)NC_hashmapGetVar(ncapname);
#369 free(name);
#570NC3_def_var( int ncid, const char *namenc_type type,
#589 status = NC_check_name(name);
#608 varid = NC_findvar(&ncp->varsname, &varp);
#614 varp = new_NC_var(nametypendimsdimids);
#639NC3_inq_varid(int ncid, const char *name, int *varid_ptr)
#652 varid = NC_findvar(&ncp->varsname, &varp);
#666 char *name,
#687 if(name != NULL)
#689 (void) strncpy(namevarp->name->cpvarp->name->nchars);
#690 name[varp->name->nchars] = 0;
#754 old = varp->name;
#767 varp->name = newStr;
#778 status = set_NC_string(varp->namenewname);
#783 NC_hashmapAddVar(&ncp->varsvaridvarp->name->cp);
vardata.c#251    print_name(vp->name);
#297    print_name(vp->name);
#560    print_name(vp->name);
#563 set_indent ((int)strlen(vp->name) + 4 + indent_get());
vardef.c#142    if (ncvardef(cdfidva[0].nameva[0].typeva[0].ndimsva[0].dims)
#155 if ((di_id[id] = ncdimdef(cdfiddi[id].namedi[id].size)) == -1) {
#157   pnamedi[id].namedi[id].size);
#164    tmp.name = (char *) emalloc(MAX_NC_NAME);
#172 if ((va_id[iv] = ncvardef(cdfidva[iv].nameva[iv].type,
#186 if (ncvarinq(cdfidva_id[iv], tmp.name, &tmp.type,
#192 if (strcmp(tmp.nameva[iv].name) != 0 ||
#197   pnameva[iv].name);
#205   pnameva[iv].name);
#213    if (ncvardef(cdfidva[0].nameva[0].type,
#342    free (tmp.name);
vartests.c#55    xx.namexx.typexx.ndimsxx.dims)) == -1) {
#62    if (ncvarid(cdfidxx.name) != varid) {
#71    if (ncvarid(cdfidxx.name) != varid) {
#85    if (ncvarid(cdfidxx.name) != -1) {
#125    var.name = (char *) emalloc(MAX_NC_NAME);
#127 if (ncvarinq(cdfidvaridvar.name, &var.type,
#134 if (strcmp(var.nametest.vars[varid].name) != 0) {
#136   pnamevar.nametest.vars[varid].namevarid);
#165 if (ncvarinq(cdfidvaridvar.name, &var.type,
#171 if (strcmp(var.nametest.vars[varid].name) != 0) {
#173   pnamevar.nametest.vars[varid].namevarid);
#197    if (ncvarinq(cdfid, -1, var.name, &var.type,
#199 ncvarinq(cdfidtest.nvarsvar.name, &var.type,
#215 if (ncvarinq(cdfidvaridvar.name, &var.type,
#222    if(var.name != NULL) free(var.name);
#316       pnameietest.vars[iv].name);
#323       pnameietest.vars[iv].name);
#591    yy.nameyy.typeyy.ndimsyy.dims)) == -1) {
#599    if (ncvardef(cdfidzz.namezz.typezz.ndimszz.dims) == -1) {
#615    var.name = (char *) emalloc(MAX_NC_NAME);
#616    if (ncvarinq(cdfidyy_idvar.name,
#621    if (strcmp(var.name,yy.name) == 0) {
#625    if (strcmp(var.name,newname) != 0) {
#627       pnamevar.namenewname);
#630    (void) strcpy(test.vars[yy_id].namenewname); /* keep test consistent */
#632    if (ncvarrename(cdfidyy_idzz.name) != -1) {
#637    if (ncvarrename(cdfid, -1, var.name) != -1 ||
#638 ncvarrename(cdfidtest.nvarsvar.name) != -1) {
#656    (void) strcpy(test.vars[yy_id].nameshortname); /* keep test consistent */
#667    if (ncvarrename (cdfid, 0, var.name) != -1) {
#673    free(var.name);
vputget.c#89   pnameietest.vars[iv].name);
#108       pnameietest.vars[iv].name);
vputgetg.c#125       pnameietest.vars[iv].name);
#160   pnameietest.vars[iv].name);


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