add.c#20struct netcdf test; /*
#26add_dim (testidim) /* add the dimension idim to the netcdf test */
#27     struct netcdf *test;
#32    if (test->ndims >= MAX_NC_DIMS) {
#34       "%s: too many dimensions (%d)", pnametest->ndims);
#37    test->dims[test->ndims].size = idim->size;
#38    test->dims[test->ndims].name = (char *) emalloc(strlen(idim->name) + 1);
#39    (void) strcpy(test->dims[test->ndims].nameidim->name);
#41      test->xdimid = test->ndims;
#42    test->ndims++;
#46add_var (testivar) /* add the variable ivar to the netcdf test */
#47     struct netcdf *test;
#53    if (test->nvars >= MAX_NC_VARS) {
#55       "%s: too many variables (%d)", pnametest->nvars);
#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;
#67    test->nvars++;
#71add_att (testvaridiatt) /* add attribute iatt to the netcdf test */
#72     struct netcdf *test;
#79    if (test->natts >= MAX_TEST_ATTS) {
#81       "%s: too many attributes (%d)", pnametest->natts);
#86    for (ia = 0; ia < test->natts ; ia++) {
#87 if (test->atts[ia].var == varid &&
#88     strcmp(test->atts[ia].nameiatt->name) == 0) {
#89     test->atts[ia].type = iatt->type;
#90     test->atts[ia].len = iatt->len;
#91     test->atts[ia].val = iatt->val;
#96    test->atts[test->natts].var = varid;
#97    test->atts[test->natts].name = (char *) emalloc(strlen(iatt->name) + 1);
#98    (void) strcpy(test->atts[test->natts].nameiatt->name);
#99    test->atts[test->natts].type = iatt->type;
#100    test->atts[test->natts].len = iatt->len;
#101    test->atts[test->natts].val = iatt->val;
#102    test->natts++;
#104      test->ngatts++;
#106      test->vars[varid].natts++;
#111add_reset(test) /* reset in-memory netcdf test to empty */
#112     struct netcdf *test;
#114    test->ndims = 0;
#115    test->nvars = 0;
#116    test->natts = 0;
#117    test->ngatts = 0;
#118    test->xdimid = -1; /* no unlimited dimension */
#123del_att (testvaridiatt) /* delete attribute iatt in the netcdf test */
#124     struct netcdf *test;
#131    for (ia = 0; ia < test->natts ; ia++) { /* find attribute to delete */
#132 if (test->atts[ia].var == varid &&
#133     strcmp(test->atts[ia].nameiatt->name) == 0) {
#134     free(test->atts[ia].name);
#135     for (ib = ia+1; ib < test->nattsib++) { /* move down */
#136 test->atts[ib-1].var =   test->atts[ib].var;
#137 test->atts[ib-1].name =  test->atts[ib].name;
#138 test->atts[ib-1].type =  test->atts[ib].type;
#139 test->atts[ib-1].len =   test->atts[ib].len;
#140 test->atts[ib-1].val =   test->atts[ib].val;
#142     test->natts--;
#144       test->ngatts--;
#146       test->vars[varid].natts--;
#152    test->vars[varid].nameiatt->name);
#156add_data(testvaridstartedges) /* keep max record written updated */
#157     struct netcdf *test;
#162    if (varid != test->xdimid) /* not a record variable */
#164    if (start[0] + edges[0] > test->dims[test->xdimid].size)
#165      test->dims[test->xdimid].size = start[0] + edges[0];
atttests.c#103 add_att(&testNC_GLOBAL, &atts[ia]); /* keep in-memory netcdf updated */
#149    add_var(&test, &ww); /* keep in-memory netcdf in sync */
#157 add_att(&testww_id, &atts[ia]); /* keep in-memory netcdf updated */
#201 add_att(&testww_id, &tmp); /* keep in-memory netcdf updated */
#281 add_att(&testww_id, &tmp); /* keep in-memory netcdf updated */
#310    if (ncattput(cdfidtest.nvarsatts[0].nameatts[0].typeatts[0].len,
#364    for (ia = 0; ia < test.nattsia++) {
#365 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#371 if (type != test.atts[ia].type) {
#376 if (len != test.atts[ia].len) {
#397    add_var(&test, &vv); /* keep in-memory netcdf in sync */
#405    if (ncattinq(cdfidtest.nvarstest.atts[0].name, &type, &len) != -1) {
#410    for (ia = 0; ia < test.nattsia++) {
#411 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#417 if (type != test.atts[ia].type) {
#422 if (len != test.atts[ia].len) {
#436    if (ncattinq(cdfidNC_GLOBALtest.atts[0].name, &type, &len) != -1) {
#495    add_var(&test, &uu); /* keep in-memory netcdf in sync */
#504    add_att(&testuu_id, &vmax); /* keep in-memory netcdf updated */
#507    for (ia = 0; ia < test.nattsia++) {
#508 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#513 if (tmp.type != test.atts[ia].type) {
#518 if (tmp.len != test.atts[ia].len) {
#524 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#530 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#533   cdfidtest.vars[test.atts[ia].var].name,
#534   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#536     val_out(test.atts[ia].typetest.atts[ia].len,
#537    test.atts[ia].val);
#550    for (ia = 0; ia < test.nattsia++) {
#551 if (ncattinq(cdfidtest.atts[ia].vartest.atts[ia].name,
#557 if (tmp.type != test.atts[ia].type) {
#562 if (tmp.len != test.atts[ia].len) {
#569 if (ncattget(cdfidtest.atts[ia].vartest.atts[ia].nametmp.val)
#575 if (val_cmp(tmp.typetmp.lentmp.valtest.atts[ia].val) != 0) {
#578   cdfidtest.vars[test.atts[ia].var].name,
#579   test.atts[ia].nametest.atts[ia].typetest.atts[ia].len);
#581     val_out(test.atts[ia].typetest.atts[ia].len,
#582    test.atts[ia].val);
#590    if (ncattget(cdfidtest.nvarsvmax.namevmax.val) != -1) {
#669    add_att(&testNC_GLOBAL, &att); /* keep in-memory netcdf consistent */
#677    add_var(&test, &tt); /* keep in-memory netcdf consistent */
#682    add_att(&testtt_id, &att); /* keep in-memory netcdf consistent */
#691    add_var(&test, &tu); /* keep in-memory netcdf consistent */
#696    add_att(&testtu_id, &att); /* keep in-memory netcdf consistent */
#712 if ((tu.dims[id] =ncdimdef(cdfid2test.dims[id].name,
#713     test.dims[id].size)) == -1) {
#790    add_att(&testNC_GLOBAL, &att2); /* keep in-memory netcdf consistent */
#825    add_att(&testtu_id, &att2); /* keep in-memory netcdf consistent */
#861    if (ncattcopy(cdfidtest.nvarsatt.namecdfidtu_id) != -1) {
#938    for (ia = 0; ia < test.ngattsia++) {
#944 while (ib < test.natts && test.atts[ib].var != NC_GLOBAL)
#946 if (ib >= test.natts) {
#951 if (strcmp(att.nametest.atts[ib].name) != 0) {
#953   pnameatt.nametest.atts[ib].name);
#959    for (iv = 0; iv < test.nvarsiv++) {
#961 for (ia = 0; ia < test.vars[iv].nattsia++) {
#967     while (ib < test.natts && test.atts[ib].var != iv)
#969     if (ib >= test.natts) {
#974     if (strcmp(att.nametest.atts[ib].name) != 0) {
#976       pnametest.vars[iv].nameatt.nametest.atts[ib].name);
#989    add_att(&testNC_GLOBAL, &att); /* keep in-memory netcdf consistent */
#992    if (ncattname(cdfidNC_GLOBALtest.ngatts-1, tmp.name) == -1) {
#1008    for (ia = 0; ia < test.ngattsia++) {
#1014 while (ib < test.natts && test.atts[ib].var != NC_GLOBAL)
#1016 if (ib >= test.natts) {
#1021 if (strcmp(att.nametest.atts[ib].name) != 0) {
#1023   pnameatt.nametest.atts[ib].name);
#1029    for (iv = 0; iv < test.nvarsiv++) {
#1031 for (ia = 0; ia < test.vars[iv].nattsia++) {
#1037     while (ib < test.natts && test.atts[ib].var != iv)
#1039     if (ib >= test.natts) {
#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) {
#1062    if (ncattname(cdfidNC_GLOBALtest.ngattsatt.name) != -1) {
#1130    add_att(&testNC_GLOBAL, &atty); /* keep in-memory netcdf in sync */
#1131    ynum = test.natts-1; /* number of attribute just put */
#1137    add_att(&testNC_GLOBAL, &attz); /* keep in-memory netcdf in sync */
#1144    (void) strcpy(test.atts[ynum].namenewname); /* keep test consistent */
#1180    if (ncattrename(cdfidtest.nvarsnewnameatty.name) != -1) {
#1278    add_att(&testNC_GLOBAL, &yaa); /* keep in-memory netcdf in sync */
#1287    add_var(&test, &yav); /* keep in-memory netcdf consistent */
#1292    add_att(&testyav_id, &yaa); /* keep in-memory netcdf consistent */
#1312    del_att(&testNC_GLOBAL, &yaa); /* keep in-memory netcdf consistent */
#1332    del_att(&testyav_id, &yaa); /* keep in-memory netcdf consistent */
#1353    add_att(&testNC_GLOBAL, &yaa); /* keep in-memory netcdf in sync */
#1358    add_att(&testyav_id, &yaa); /* keep in-memory netcdf consistent */
#1365    if (ncattdel(cdfidtest.nvarsyaa.name) != -1) {
cdftests.c#73    add_reset(&test);
#179    add_att(&testNC_GLOBAL, &title); /* keep in-memory netcdf updated */
#274    add_dim(&test, &ii); /* keep in-memory netcdf in sync */
#284    add_var(&test, &aa); /* keep in-memory netcdf in sync */
#293    add_att(&testaa_id, &aa_units); /* keep in-memory netcdf in sync */
#365    add_dim(&test, &jj); /* keep in-memory netcdf in sync */
#366    add_dim(&test, &kk); /* keep in-memory netcdf in sync */
#377    add_var(&test, &bb); /* keep in-memory netcdf in sync */
#385    add_att(&testbb_id, &bb_range); /* keep in-memory netcdf in sync */
#520    if (ndims != test.ndims) {
#522     pnamendimstest.ndims);
#525    if (nvars != test.nvars) {
#527     pnamenvarstest.nvars);
#530    if (ngatts != test.ngatts) {
#532     pnamengattstest.ngatts);
#535    if (xdimid != test.xdimid) {
#537     pnamexdimidtest.xdimid);
#552 add_dim(&test, &dims[id]);
#560    add_dim(&test, &rec);
#573 add_var(&test, &cc[iv]);
#581 add_att(&testcc_id, &cc_units);
#590    if (ndims != test.ndims) {
#592     pnamendimstest.ndims);
#595    if (nvars != test.nvars) {
#597     pnamenvarstest.nvars);
#600    if (ngatts != test.ngatts) {
#602     pnamengattstest.ngatts);
#605    if (xdimid != test.xdimid) {
#607     pnamexdimidtest.xdimid);
#676    add_dim(&test, &ll);
#685    add_var(&test, &dd);
#693    add_att(&testdd_id, &dd_fill_val);
#722 add_data(&test,dd_id,dd_start,dd_edges); /* keep test in sync */
daputil.c#332 void* test = nclistget(l,i);
#333 if(test==elem) {
dimtests.c#67    add_dim(&test, &mm); /* keep in-memory netcdf in sync */
#69    if (dimid != test.ndims - 1) {
#71       pnamedimidtest.ndims-1);
#95 add_dim(&test, &rec);
#158    add_dim(&test, &nn); /* keep in-memory netcdf in sync */
#179    if (ncdimid(cdfid, "rec") != test.xdimid) {
#226    for (dimid = 0 ; dimid < test.ndimsdimid++) { /* loop on all dim ids */
#233 if (strcmp(dim.nametest.dims[dimid].name) != 0) {
#235 pnamedim.nametest.dims[dimid].namedimid);
#238 if (dim.size != test.dims[dimid].size) {
#240 pnamedim.sizetest.dims[dimid].sizedimid);
#249    for (dimid = 0 ; dimid < test.ndimsdimid++) { /* loop on all dim ids */
#256 if (strcmp(dim.nametest.dims[dimid].name) != 0) {
#258 pnamedim.nametest.dims[dimid].namedimid);
#261 if (dim.size != test.dims[dimid].size) {
#263 pnamedim.sizetest.dims[dimid].sizedimid);
#269 ncdiminq(cdfidtest.ndimsdim.name, &dim.size) != -1) {
#283    if (test.ndims >= 1) { /* if any dimensions have been defined */
#337    add_dim(&test, &pp); /* keep in-memory netcdf in sync */
#342    add_dim(&test, &qq); /* keep in-memory netcdf in sync */
#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 */
#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 */
#402    test.dims[pp_dim].name = (char *) erealloc((void *)test.dims[pp_dim].name,
#404    (void) strcpy(test.dims[pp_dim].namepp.name); /* keep test consistent */
driver.c#109   for (i = 0; i < test.ndimsi++)
#110      free(test.dims[i].name);
#112   for (i = 0; i < test.nvarsi++)
#114      free(test.vars[i].name);
#115      free(test.vars[i].dims);
#118   for (i = 0; i < test.nattsi++)
#119      free(test.atts[i].name);
getvara.c#719        CDFnodetest = (CDFnode*) nclistget(node->subnodes,i);
#720        if(test == field) return i;
nctime.c#409 int test;
#411 if ((test = VALCMP(ca.yearcb.year)))
#412 return test;
#413 else if ((test = VALCMP(ca.monthcb.month)))
#414 return test;
#415 else if ((test = VALCMP(ca.daycb.day)))
#416 return test;
slabs.c#154 add_dim(&test, &dims[idim]);
#169 add_var(&test, &va[iv]); /* keep in-memory netcdf in sync */
#211 add_data(&testvarid[iv], corneredge); /* keep test in sync */
t_dap.c#342#define test \
#363#define test for(i=0;i<DIMSIZE;i++) {\
#383    test;
#387    test;
#391    test;
#395    test;
#410    test;
#414    test;
#428    test;
#433    test;
#437    test;
#441    test;
#447    test;
#452    test;
t_dap3a.c#342#define test \
#363#define test for(i=0;i<DIMSIZE;i++) {\
#383    test;
#387    test;
#391    test;
#395    test;
#410    test;
#414    test;
#428    test;
#433    test;
#437    test;
#441    test;
#447    test;
#452    test;
test_cvt.c#342#define test \
#363#define test for(i=0;i<DIMSIZE;i++) {\
#383    test;
#387    test;
#391    test;
#395    test;
#410    test;
#414    test;
#428    test;
#433    test;
#437    test;
#441    test;
#447    test;
#452    test;
testcdf.h#56extern struct netcdf test; /*
vardef.c#160 add_dim(&test, &di[id]); /* keep in-memory netcdf in sync */
#175     errvar(&test,&va[iv]); /* prints details about variable */
#178 add_var(&test, &va[iv]); /* keep in-memory netcdf in sync */
#180 if (va_id[iv] != test.nvars - 1) {
#182   pnameva_id[iv], test.nvars-1);
#189     errvar(&test,&va[iv]); /* prints details about variable */
#199     errvar(&test,&va[iv]);
#200     errvar(&test,&tmp);
#207     errvar(&test,&va[iv]);
#208     errvar(&test,&tmp);
varget.c#54    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#56    if (iv < test.nvars) { /* iv is varid of variable with dimensions */
#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] ;
#88 hc.cor[mqv] = test.dims[dim].size; /* try big coordinate, should fail */
#95 hc.edg[mqv] = test.dims[dim].size + 1; /* try big edge, should fail */
vargetg.c#53    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#55    if (iv < test.nvars) { /* iv is varid of variable with dimensions */
#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;
#89 hc.cor[id] = test.dims[id].size; /* try big coordinate, should fail */
#96 hc.edg[id] = test.dims[id].size + 1; /* try big edge, should fail */
varput.c#60    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#62    if (iv < test.nvars) { /* iv is first varid of var with dimensions */
#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] ;
#92 hc.cor[mqv] = test.dims[dim].size; /* try big coordinate, should fail */
#100 hc.edg[mqv] = test.dims[dim].size + 1; /* try big edge, should fail */
varputg.c#57    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#59    if (iv < test.nvars) { /* iv is first varid of var with dimensions */
#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;
#92 hc.cor[id] = test.dims[id].size; /* try big coordinate, should fail */
#99 hc.edg[id] = test.dims[id].size + 1; /* try big edge, should fail */
vartests.c#59    add_var(&test, &xx); /* keep in-memory netcdf in sync */
#126    for (varid = 0 ; varid < test.nvarsvarid++) { /* loop on all var ids */
#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]);
#164    for (varid = 0 ; varid < test.nvarsvarid++) { /* loop on all var ids */
#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]);
#199 ncvarinq(cdfidtest.nvarsvar.name, &var.type,
#214    if (test.nvars >= 1) { /* if any variables have been defined */
#269    for (iv = 0; iv < test.nvarsiv++) { /* for each var in netcdf */
#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);
#319     add_data(&testivelm[ie].coordsedges); /* keep test in sync */
#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)
#405    if (iv < test.nvars) { /* iv is varid of variable with dimensions */
#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;
#425       ncvarput1 (cdfidtest.nvarselm.coords, (void *) &elm.val) != -1) {
#434    if (test.nvars > 0)
#491    while (test.vars[iv].ndims <= 0 && iv < test.nvars)
#493    if (iv < test.nvars) { /* iv is varid of variable with dimensions */
#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;
#513       ncvarget1 (cdfidtest.nvarselm.coords, (void *) &elm.val) != -1) {
#522    if (test.nvars > 0)
#595    add_var(&test, &yy); /* keep in-memory netcdf in sync */
#603    add_var(&test, &zz); /* keep in-memory netcdf in sync */
#630    (void) strcpy(test.vars[yy_id].namenewname); /* keep test consistent */
#638 ncvarrename(cdfidtest.nvarsvar.name) != -1) {
#656    (void) strcpy(test.vars[yy_id].nameshortname); /* keep test consistent */
vputget.c#51    for (iv = 0; iv < test.nvarsiv++) { /* for each var in netcdf */
#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) ? ", " : "");
#104     add_data(&testivhc[ie].corhc[ie].edg); /* keep test in sync */
#108       pnameietest.vars[iv].name);
#112 if (val_cmp(test.vars[iv].typenel[ie],
#117     errvar(&test, &test.vars[iv]); /* describe var */
vputgetg.c#54    for (iv = 0; iv < test.nvarsiv++) { /* for each var in netcdf */
#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++)
#153 add_data(&testivhc[ie].cordsize);
#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