add.c#59    test->vars[test->nvars].name = (char *) emalloc(strlen(ivar->name) + 1);
#60    (void) strcpy(test->vars[test->nvars].nameivar->name);
#61    test->vars[test->nvars].type = ivar->type;
#62    test->vars[test->nvars].ndims = ivar->ndims;
#63    test->vars[test->nvars].dims = (int *) emalloc(sizeof(int)*ivar->ndims);
#65      test->vars[test->nvars].dims[i] = ivar->dims[i];
#66    test->vars[test->nvars].natts = 0;
#106      test->vars[varid].natts++;
#146       test->vars[varid].natts--;
#152    test->vars[varid].nameiatt->name);
attr.c#318 else if(varid >= 0 && (size_t) varid < ncp->vars.nelems)
#321 vpp = (NC_var **)ncp->vars.value;
atttests.c#533   cdfidtest.vars[test.atts[ia].var].name,
#578   cdfidtest.vars[test.atts[ia].var].name,
#961 for (ia = 0; ia < test.vars[iv].nattsia++) {
#976       pnametest.vars[iv].nameatt.nametest.atts[ib].name);
#1031 for (ia = 0; ia < test.vars[iv].nattsia++) {
#1046       pnametest.vars[iv].nameatt.nametest.atts[ib].name);
cache.c#39        for(found=0,i=0;i<nclistlength(cachenode->vars);i++) {
#40            CDFnodevar = (CDFnode*)nclistget(cachenode->vars,i);
#58        for(found=0,j=0;j<nclistlength(cachenode->vars);j++) {
#59            CDFnodevar = (CDFnode*)nclistget(cachenode->vars,j);
#100    NClistvars = nclistnew();
#109         nclistpush(vars,nclistget(allvars,i));
#131     nclistpush(vars,(void*)var);
#139    if(nclistlength(vars) == 0) {
#153    for(i=0;i<nclistlength(vars);i++) {
#154        CDFnodevar = (CDFnode*)nclistget(vars,i);
#169    if(nclistlength(allvars) == nclistlength(vars)) flags |= NCF_PREFETCH_ALL;
#171    ncstat = buildcachenode(nccomm,newconstraint,vars,&cache,flags);
#188for(i=0;i<nclistlength(vars);i++) {
#189CDFnodevar = (CDFnode*)nclistget(vars,i);
#201    nclistfree(vars);
#248    cachenode->vars = nclistclone(varlist);
#334    nclistfree(node->vars);
cdf.c#17static NCerror sequencecheckr(CDFnodenodeNClistvarsCDFnodetopseq);
#307sequencecheckr(CDFnodenodeNClistvarsCDFnodetopseq)
#320     err = sequencecheckr(sub,vars,node);
#335    } else if(nclistcontains(vars,(void*)node)) {
#342     err = sequencecheckr(sub,vars,topseq);
constraints.c#848    NClistvars = NULL;
#851    vars = nclistnew();
#855    dapcomm->cdf.projectedvars = vars;
#865 if(!nclistcontains(vars,(void*)node)) {
#866     nclistpush(vars,(void*)node);
dapdump.c#93    hdr->vars = (Var*)malloc(hdr->nvars*sizeof(Var));
#94    MEMCHECK(hdr->vars,NC_ENOMEM);
#96 Varvar = &hdr->vars[i];
#519    if(nclistlength(node->vars)==0)
#521    else for(i=0;i<nclistlength(node->vars);i++) {
#522 CDFnodevar = (CDFnode*)nclistget(node->vars,i);
dapdump.h#36    Varvars;
driver.c#114      free(test.vars[i].name);
#115      free(test.vars[i].dims);
genlib.c#57   vars[ivar].name,
#58   vars[ivar].type,
#59   vars[ivar].ndims,
#60   vars[ivar].dims,
#261      if (vars[ivar].ndims > maxdims)
#262 maxdims = vars[ivar].ndims;
#268     sprintf(stmnt, "   int %s_id;", vars[ivar].lname);
#275     sprintf(stmnt, "#  define RANK_%s %d", vars[ivar].lname,
#276     vars[ivar].ndims);
#283 if (vars[ivar].ndims > 0) {
#285     vars[ivar].lnamevars[ivar].lname);
#308     atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname,
#363     for (idim = 0; idim < vars[ivar].ndimsidim++) {
#366 vars[ivar].lname,
#368 dims[vars[ivar].dims[idim]].lname);
#371     if (vars[ivar].ndims > 0) { /* a dimensioned variable */
#374 vars[ivar].name,
#375 nctype(vars[ivar].type),
#376 vars[ivar].lname,
#377 vars[ivar].lname,
#378 vars[ivar].lname);
#382 vars[ivar].name,
#383 nctype(vars[ivar].type),
#384 vars[ivar].lname,
#385 vars[ivar].lname);
#401 atts[iatt].var == -1 ? "NC_GLOBAL" : vars[atts[iatt].var].lname,
#413     atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname,
#424 atts[iatt].var == -1 ? "NC_GLOBAL" : vars[atts[iatt].var].lname,
#429 atts[iatt].var == -1 ? "cdf" : vars[atts[iatt].var].lname,
#638      if (vars[ivar].ndims > maxdims)
#639 maxdims = vars[ivar].ndims;
#644     sprintf(stmnt, "integer  %s_id", vars[ivar].lname);
#650     sprintf(stmnt, "integer  %s_rank", vars[ivar].lname);
#654     sprintf(stmnt, "parameter (%s_rank = %d)", vars[ivar].lname,
#655     vars[ivar].ndims);
#661     if (vars[ivar].ndims > 0) {
#663 vars[ivar].lnamevars[ivar].lname);
#673     struct vars *v = &vars[ivar];
#767     for (idim = 0; idim < vars[ivar].ndimsidim++) {
#769 vars[ivar].lname,
#770 vars[ivar].ndims - idim, /* reverse dimensions */
#771 dims[vars[ivar].dims[idim]].lname);
#774     if (vars[ivar].ndims > 0) { /* a dimensioned variable */
#777 vars[ivar].name,
#778 ftypename(vars[ivar].type),
#779 vars[ivar].lname,
#780 vars[ivar].lname,
#781 vars[ivar].lname);
#785 vars[ivar].name,
#786 ftypename(vars[ivar].type),
#787 vars[ivar].lname,
#788 vars[ivar].lname);
#803 atts[iatt].var == -1 ? "NF_GLOBAL" : vars[atts[iatt].var].lname,
#825 atts[iatt].var == -1 ? "NCGLOBAL" : vars[atts[iatt].var].lname,
#1288 if (vars[ivar].ndims > 0 && vars[ivar].dims[0] == rec_dim) {
#1290     for (jdim = 0; jdim < vars[ivar].ndimsjdim++) {
#1291 if (vars[ivar].dims[jdim] == idim)
#1339 struct vars *v = &vars[ivar];
#1352            struct vars *v = &vars[ivar];
#1377            struct vars *v = &vars[ivar];
#1395     struct vars *v = &vars[ivar];
#1427     struct vars *v = &vars[ivar];
#1434     struct vars *v = &vars[ivar];
#1444     struct vars *v = &vars[ivar];
#1457            struct vars *v = &vars[ivar];
#1500            struct vars *v = &vars[ivar];
#1519     struct vars *v = &vars[ivar];
#1777     struct vars **arpp) /* address of start of var array */
#1780    *arpp = (struct vars *) emalloc(1 * sizeof(struct vars));
#1785  *arpp = (struct vars *) erealloc(*arpp, 2 * nar * sizeof(struct vars));
genlib.h#47extern void grow_varray ( int narray, struct vars **array );
getvara.c#115    NClistvars = NULL;
#269    vars = nclistnew();
#270    nclistpush(vars,(void*)varainfo->target);
#306        ncstat = buildcachenode(dapcomm,fetchconstraint,vars,&cachenode,0);
#345 ncstat = buildcachenode(dapcomm,fetchconstraint,vars,&cachenode,0);
#381        ncstat = buildcachenode(dapcomm,fetchconstraint,vars,&cachenode,0);
#420    if(vars != NULLnclistfree(vars);
init.c#32struct vars *vars; /* a malloc'ed list */
load.c#80    if (!vars[varnum].has_data)
#84    sprintf(stmnt, "   {\t\t\t/* store %s */", vars[varnum].name);
#87    if (vars[varnum].ndims > 0) {
#88 if (vars[varnum].dims[0] == rec_dim) {
#90     vars[varnum].lnamevars[varnum].lname);
#94     vars[varnum].lnamevars[varnum].lname);
#100 ncctype(vars[varnum].type),
#101 vars[varnum].lname);
#104 switch (vars[varnum].type) {
#112     switch (vars[varnum].type) {
#131 switch (vars[varnum].type) {
#166       switch (vars[varnum].type) {
#204 if (vars[varnum].dims[0] == rec_dim) {
#208     (unsigned long)vars[varnum].nrecs, /* number of recs for this variable */
#209     vars[varnum].name);
#212     for (idim = 0; idim < vars[varnum].ndimsidim++) {
#214 vars[varnum].lname,
#219     for (idim = 0; idim < vars[varnum].ndimsidim++) {
#221 vars[varnum].lname,
#223 dims[vars[varnum].dims[idim]].lname);
#228 if (vars[varnum].dims[0] == rec_dim) {
#231     ncstype(vars[varnum].type),
#232     vars[varnum].lname,
#233     vars[varnum].lname,
#234     vars[varnum].lname,
#235     vars[varnum].lname);
#239     ncstype(vars[varnum].type),
#240     vars[varnum].lname,
#241     vars[varnum].lname);
#247 ncctype(vars[varnum].type),
#248 vars[varnum].lname);
#250 switch (vars[varnum].type) {
#285 ncstype(vars[varnum].type),
#286 vars[varnum].lname,
#287 vars[varnum].lname);
#347    sprintf(stmnt, "data %s /",vars[varnum].lname);
#349    switch (vars[varnum].type) {
#411    if (vars[varnum].ndims > 0 && vars[varnum].dims[0] == rec_dim) {
#414 vars[varnum].data_stmnt = dup_stmnt;
#428    struct vars *v = &vars[varnum];
#514    switch (vars[varnum].type) {
#533    if (vars[varnum].ndims > 0) {
#536 if (vars[varnum].dims[0] == rec_dim) {
#537     count[0] = vars[varnum].nrecs;
#540     count[0] = dims[vars[varnum].dims[0]].size;
#544    for (idim = 1; idim < vars[varnum].ndimsidim++) {
#546 count[idim] = dims[vars[varnum].dims[idim]].size;
#549    switch (vars[varnum].type) {
nc3internal.c#42 free_NC_vararrayV(&nc3->vars);
#72 if(dup_NC_vararrayV(&ncp->vars, &ref->vars) != NC_NOERR)
#173 if(ncp->vars.nelems == 0)
#199 vpp = ncp->vars.value;
#200 for(ii = 0; ii < ncp->vars.nelems ; ii++, vpp++)
#220          for (; j<ncp->old->vars.nelemsj++) {
#221            if (!IS_RECVAR(ncp->old->vars.value[j]))
#225          if (j < ncp->old->vars.nelems) {
#226            if ((*vpp)->begin < ncp->old->vars.value[j]->begin) {
#230              (*vpp)->begin = ncp->old->vars.value[j]->begin;
#270 vpp = (NC_var **)ncp->vars.value;
#271 for(ii = 0; ii < ncp->vars.nelemsii++, vpp++)
#290                    for (; j<ncp->old->vars.nelemsj++)
#291                        if (IS_RECVAR(ncp->old->vars.value[j]))
#293                    if (j < ncp->old->vars.nelems) {
#294                        if ((*vpp)->begin < ncp->old->vars.value[j]->begin)
#296                            (*vpp)->begin = ncp->old->vars.value[j]->begin;
#422 free_NC_vararrayV(&ncp->vars);
#490 varpp = ncp->vars.value;
#491 for(ii = 0; ii < ncp->vars.nelemsii++, varpp++)
#513 NC_var ** const gnu_varpp = (NC_var **)gnu->vars.value;
#518 NC_var *const *const end = &vpp[gnu->vars.nelems];
#531 int varid = (int)old->vars.nelems;
#532 for(; varid < (int)gnu->vars.nelemsvarid++)
#557 NC_var ** const gnu_varpp = (NC_var **)gnu->vars.value;
#558 int varid = (int)old->vars.nelems;
#560 for(; varid < (int)gnu->vars.nelemsvarid++)
#590 NC_var **gnu_varpp = (NC_var **)gnu->vars.value;
#591 NC_var **old_varpp = (NC_var **)old->vars.value;
#602 for(varid = (int)old->vars.nelems -1; varid >= 0; varid--)
#646 NC_var **gnu_varpp = (NC_var **)gnu->vars.value;
#647 NC_var **old_varpp = (NC_var **)old->vars.value;
#654 for(varid = (int)old->vars.nelems -1;
#696    if(ncp->vars.nelems == 0)
#713    vpp = ncp->vars.value;
#714    for (ii = 0; ii < ncp->vars.nelemsii++, vpp++) {
#741 vpp = ncp->vars.value;
#742 for (ii = 0; ii < ncp->vars.nelemsii++, vpp++) {
#795 if(ncp->vars.nelems != 0)
#847                                         : (ncp->vars.nelems > ncp->old->vars.nelems))
#891 NC_var **vpp = (NC_var **)ncp->vars.value;
#892 NC_var *const *const end = &vpp[ncp->vars.nelems];
#896 if(ncp->vars.nelems == 0) { /* no non-record variables and
#1350 *nvarsp = (int) nc3->vars.nelems;
nc3internal.h#309 NC_vararray vars;
nccommon.h#109    NClistvars; /* vars potentially covered by this cache node */
ncgen.h#34extern struct vars {
#46} *vars; /* table of variables */
ncgentab.c#1682     static struct vars dummyvar;
#1701 &vars); /* grow as needed */
#1702     vars[nvars] = dummyvar; /* to make Purify happy */
#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);
#1707     vars[nvars].type = type_code;
#1710     nc_getfill(type_code, &vars[nvars].fill_value);
#1711     vars[nvars].has_data = 0; /* has no data (yet) */
#1719     vars[nvars].ndims = nvdims;
#1729        derror("%s has too many dimensions",vars[nvars].name);
#1742 &vars[nvars].dims); /* grow as needed */
#1743     vars[nvars].dims[nvdims] = dimnum;
#1907        valtype = vars[varnum].type; /* variable type */
#1909        vars[varnum].has_data = 1;
#1912        if (vars[varnum].ndims == 0) { /* scalar */
#1914        } else if (vars[varnum].dims[0] == rec_dim) {
#1917    var_len = dims[vars[varnum].dims[0]].size;
#1919        for(dimnum = 1; dimnum < vars[varnum].ndimsdimnum++)
#1920  var_len = var_len*dims[vars[varnum].dims[dimnum]].size;
#1924   vars[varnum].name);
#1966     vars[varnum].fill_value);
#1970        vars[varnum].nrecs = var_len / rec_len;
#1982    if (vars[varnum].dims[0] != rec_dim) { /* not recvar */
#2076        if (vars[varnum].dims[0] != rec_dim) {
#2095    ld = vars[varnum].ndims-1;
#2097        sl = dims[vars[varnum].dims[ld]].size;
#2286    vars[varnum].fill_value);
#2290    vars[varnum].fill_value);
#2294    vars[varnum].fill_value);
#2298    vars[varnum].fill_value);
#2302    vars[varnum].fill_value);
#2306    vars[varnum].fill_value);
#2575                   vars[varnum].name,atts[natts].name);
#2587                   &vars[atts[natts].var].fill_value);
#2588        if(atts[natts].type != vars[atts[natts].var].type) {
#2590                   vars[atts[natts].var].name_FillValue);
putget.c#509 for(; ii < ncp->vars.nelemsii++, varpp++)
#559 for(; ii < ncp->vars.nelemsii++, varpp++)
#638 (const NC_var *const*)ncp->vars.value,
#658     NC_var **vpp = (NC_var **)ncp->vars.value;
#659     NC_var *const *const end = &vpp[ncp->vars.nelems];
#677 (const NC_var *const*)ncp->vars.value,
testcdf.h#51    struct cdfvar vars[MAX_TEST_VARS]; /* variables */
v1hpg.c#1197 NC_var **vpp = (NC_var **)ncp->vars.value;
#1198 NC_var *const *const end = &vpp[ncp->vars.nelems];
#1207 if(ncp->vars.nelems == 0)
#1284 xlen += ncx_len_NC_vararray(&ncp->varssizeof_off_tversion);
#1376 status = v1h_put_NC_vararray(&ps, &ncp->vars);
#1513 status = v1h_get_NC_vararray(&gs, &ncp->vars);
var.c#555    *varp = elem_NC_vararray(&ncp->vars, (size_t)varid);
#603 if(ncp->vars.nelems >= NC_MAX_VARS)
#608 varid = NC_findvar(&ncp->varsname, &varp);
#625 status = incr_NC_vararray(&ncp->varsvarp);
#633 *varidp = (int)ncp->vars.nelems -1; /* varid */
#652 varid = NC_findvar(&ncp->varsname, &varp);
#683 varp = elem_NC_vararray(&ncp->vars, (size_t)varid);
#740 other = NC_findvar(&ncp->varsunewname, &varp);
#761 NC_hashmapRemoveVar(&ncp->varsold->cp);
#768 NC_hashmapAddVar(&ncp->varsvaridnewStr->cp);
#776 NC_hashmapRemoveVar(&ncp->varsold->cp);
#783 NC_hashmapAddVar(&ncp->varsvaridvarp->name->cp);
varget.c#54    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#60 for (id = 0; id < test.vars[iv].ndimsid++) {
#65 hc.vals = emalloc(nctypelen(test.vars[iv].type) + 8);
#67 id = test.vars[iv].ndims - 1;
#84 long mqv = test.vars[iv].ndims -1 ;
#85 int dim = test.vars[iv].dims[mqv] ;
vargetg.c#53    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#60 for (id = 0; id < test.vars[iv].ndimsid++) {
#67 hc.vals = emalloc(nctypelen(test.vars[iv].type) + 8);
#73 id = test.vars[iv].ndims - 1;
varput.c#60    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#64 for (id = 0; id < test.vars[iv].ndimsid++) {
#69 hc.vals = emalloc(nctypelen(test.vars[iv].type));
#70 val_fill(test.vars[iv].type, 1, hc.vals);
#72 id = test.vars[iv].ndims - 1;
#88 long mqv = test.vars[iv].ndims -1 ;
#89 int dim = test.vars[iv].dims[mqv] ;
varputg.c#57    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#62 for (id = 0; id < test.vars[iv].ndimsid++) {
#69 hc.vals = emalloc(nctypelen(test.vars[iv].type));
#70 val_fill(test.vars[iv].type, 1, hc.vals);
#76 id = test.vars[iv].ndims - 1;
vartests.c#134 if (strcmp(var.nametest.vars[varid].name) != 0) {
#136   pnamevar.nametest.vars[varid].namevarid);
#139 if (var.type != test.vars[varid].type) {
#141   pnamevar.typetest.vars[varid].typevarid);
#144 if (var.ndims != test.vars[varid].ndims) {
#146   pnamevar.ndimstest.vars[varid].ndimsvarid);
#151       if (var.dims[idim] != test.vars[varid].dims[idim]) {
#154 test.vars[varid].dims[idim]);
#171 if (strcmp(var.nametest.vars[varid].name) != 0) {
#173   pnamevar.nametest.vars[varid].namevarid);
#176 if (var.type != test.vars[varid].type) {
#178   pnamevar.typetest.vars[varid].typevarid);
#181 if (var.ndims != test.vars[varid].ndims) {
#183   pnamevar.ndimstest.vars[varid].ndimsvarid);
#188       if (var.dims[idim] != test.vars[varid].dims[idim]) {
#191 test.vars[varid].dims[idim]);
#270 for (id = 0; id < test.vars[iv].ndimsid++) { /* set corners */
#275     dsize = (int) test.dims[test.vars[iv].dims[id]].size;
#284     switch (test.vars[iv].type) { /* get values of right type to put */
#316       pnameietest.vars[iv].name);
#323       pnameietest.vars[iv].name);
#326     switch (test.vars[iv].type) { /* compare values of right type */
#403    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#408 for (id = 0; id < test.vars[iv].ndimsid++)
#411 elm.coords[test.vars[iv].ndims/2] = -1;
#416 elm.coords[test.vars[iv].ndims/2] =
#417   test.dims[test.vars[iv].dims[test.vars[iv].ndims/2]].size;
#491    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#496 for (id = 0; id < test.vars[iv].ndimsid++)
#499 elm.coords[test.vars[iv].ndims/2] = -1;
#504 elm.coords[test.vars[iv].ndims/2] =
#505   test.dims[test.vars[iv].dims[test.vars[iv].ndims/2]].size;
#630    (void) strcpy(test.vars[yy_id].namenewname); /* keep test consistent */
#656    (void) strcpy(test.vars[yy_id].nameshortname); /* keep test consistent */
vputget.c#55 for (id = 0; id < test.vars[iv].ndimsid++) { /* set cubes */
#58     int dsize = (int)test.dims[test.vars[iv].dims[id]].size;
#80     hc[ie].vals = emalloc(nel[ie]*nctypelen(test.vars[iv].type) + 8);
#81     tmp.vals = emalloc(nel[ie]*nctypelen(test.vars[iv].type) + 8);
#84     val_fill(test.vars[iv].typenel[ie], hc[ie].vals);
#89   pnameietest.vars[iv].name);
#91     errvar(&test, &test.vars[iv]);
#93     for (id = 0 ; id < test.vars[iv].ndimsid++)
#95     (id < test.vars[iv].ndims-1) ? ", " : "");
#98     for (id = 0 ; id < test.vars[iv].ndimsid++)
#100     (id < test.vars[iv].ndims-1) ? ", " : "");
#108       pnameietest.vars[iv].name);
#112 if (val_cmp(test.vars[iv].typenel[ie],
#117     errvar(&test, &test.vars[iv]); /* describe var */
vputgetg.c#65     (test.dims[test.vars[varid].dims[id]].size == NC_UNLIMITED \
#67test.dims[test.vars[varid].dims[id]].size)
#72 for (id = test.vars[iv].ndims-1; id >= 0; --id) { /* set cubes */
#79     hc[0].imap[id] = id == test.vars[iv].ndims-1
#80nctypelen(test.vars[iv].type)
#90     hc[1].imap[id] = id == test.vars[iv].ndims-1
#91nctypelen(test.vars[iv].type)
#103     hc[2].imap[id] = id == test.vars[iv].ndims-1
#104 ? -nctypelen(test.vars[iv].type)
#108 hc[2].offset = (nel[2]-1)*nctypelen(test.vars[iv].type);
#112     int nelms = (int)nel[ie]*nctypelen(test.vars[iv].type) + 8;
#118     val_fill(test.vars[iv].typenel[ie], hc[ie].vals);
#125       pnameietest.vars[iv].name);
#127 errvar(&test, &test.vars[iv]);
#129 for (id = 0 ; id < test.vars[iv].ndimsid++)
#131 (id < test.vars[iv].ndims-1) ? ", " : "");
#134 for (id = 0 ; id < test.vars[iv].ndimsid++)
#136 (id < test.vars[iv].ndims-1) ? ", " : "");
#139 for (id = 0 ; id < test.vars[iv].ndimsid++)
#141 (id < test.vars[iv].ndims-1) ? ", " : "");
#144 for (id = 0 ; id < test.vars[iv].ndimsid++)
#146 (id < test.vars[iv].ndims-1) ? ", " : "");
#151 for (id = 0; id < test.vars[iv].ndimsid++)
#160   pnameietest.vars[iv].name);
#164     if (val_cmp(test.vars[iv].typenel[ie],
#169 errvar(&test, &test.vars[iv]); /* describe var */


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