attr.c#310NC_attrarray0(NC3_INFOncp, int varid)
#316 ap = &ncp->attrs;
#318 else if(varid >= 0 && (size_t) varid < ncp->vars.nelems)
#321 vpp = (NC_var **)ncp->vars.value;
#381 NC3_INFO *ncp;
#388 ncp = NC3_DATA(nc);
#390 ncap = NC_attrarray0(ncpvarid);
#411 NC3_INFO *ncp;
#418 ncp = NC3_DATA(nc);
#420 ncap = NC_attrarray0(ncpvarid);
#440 NC3_INFOncp;
#447 ncp = NC3_DATA(nc);
#449 ncap = NC_attrarray0(ncpvarid);
#492 NC3_INFOncp;
#503 ncp = NC3_DATA(nc);
#505 if(NC_readonly(ncp))
#508 ncap = NC_attrarray0(ncpvarid);
#532 if(NC_indef(ncp))
#548 set_NC_hdirty(ncp);
#550 if(NC_doHsync(ncp))
#552 status = NC_sync(ncp);
#565 NC3_INFOncp;
#575 ncp = NC3_DATA(nc);
#577 if(!NC_indef(ncp))
#580 ncap = NC_attrarray0(ncpvarid);
#1390    NC3_INFOncp;
#1399    ncp = NC3_DATA(nc);
#1401    if(NC_readonly(ncp))
#1404    ncap = NC_attrarray0(ncpvarid);
#1431        if(!NC_indef(ncp)) {
#1447            set_NC_hdirty(ncp);
#1449            if(NC_doHsync(ncp)) {
#1450         const int lstatus = NC_sync(ncp);
#1463        if(!NC_indef(ncp)) return NC_ENOTINDEFINE;
datt.c#109   NCncp;
#110   int stat = NC_check_id(ncid, &ncp);
#113   return ncp->dispatch->rename_att(ncidvaridnamenewname);
#160   NCncp;
#161   int stat = NC_check_id(ncid, &ncp);
#164   stat = ncp->dispatch->del_att(ncidvaridname);
dattget.c#46   NCncp;
#50   if ((stat = NC_check_id(ncid, &ncp)))
#58   return ncp->dispatch->get_att(ncidvaridnamevaluextype);
#139   NCncp;
#140   int stat = NC_check_id(ncid, &ncp);
#143   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_CHAR);
#149   NCncp;
#150   int stat = NC_check_id(ncid, &ncp);
#153   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_BYTE);
#159   NCncp;
#160   int stat = NC_check_id(ncid, &ncp);
#163   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UBYTE);
#169   NCncp;
#170   int stat = NC_check_id(ncid, &ncp);
#173   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_SHORT);
#179   NCncp;
#180   int stat = NC_check_id(ncid, &ncp);
#183   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_INT);
#189   NCncp;
#190   int stat = NC_check_id(ncid, &ncp);
#193   return ncp->dispatch->get_att(ncidvaridname, (void *)valuelongtype);
#199   NCncp;
#200   int stat = NC_check_id(ncid, &ncp);
#203   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_FLOAT);
#209   NCncp;
#210   int stat = NC_check_id(ncid, &ncp);
#213   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_DOUBLE);
#219   NCncp;
#220   int stat = NC_check_id(ncid, &ncp);
#223   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UBYTE);
#229   NCncp;
#230   int stat = NC_check_id(ncid, &ncp);
#233   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_USHORT);
#239   NCncp;
#240   int stat = NC_check_id(ncid, &ncp);
#243   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UINT);
#249   NCncp;
#250   int stat = NC_check_id(ncid, &ncp);
#253   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_INT64);
#259   NC *ncp;
#260   int stat = NC_check_id(ncid, &ncp);
#263   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UINT64);
#343    NC *ncp;
#344    int stat = NC_check_id(ncid, &ncp);
#347    return ncp->dispatch->get_att(ncid,varid,name,(void*)valueNC_STRING);
dattinq.c#75   NCncp;
#76   int stat = NC_check_id(ncid, &ncp);
#78   return ncp->dispatch->inq_att(ncidvaridnamextypeplenp);
#103   NCncp;
#104   int stat = NC_check_id(ncid, &ncp);
#106   return ncp->dispatch->inq_attid(ncidvaridnameidp);
#131   NCncp;
#132   int stat = NC_check_id(ncid, &ncp);
#134   return ncp->dispatch->inq_attname(ncidvaridattnumname);
#151   NCncp;
#152   int stat = NC_check_id(ncid, &ncp);
#155   return ncp->dispatch->inq(ncidNULLNULLnattspNULL);
#176   NCncp;
#177   int stat = NC_check_id(ncid, &ncp);
#179   return ncp->dispatch->inq_att(ncidvaridnamextypepNULL);
#202   NCncp;
#203   int stat = NC_check_id(ncid, &ncp);
#205   return ncp->dispatch->inq_att(ncidvaridnameNULLlenp);
dattput.c#53    NCncp;
#54    int stat = NC_check_id(ncid, &ncp);
#56    return ncp->dispatch->put_att(ncidvaridnameNC_STRING,
#141   NCncp;
#142   int stat = NC_check_id(ncid, &ncp);
#144   return ncp->dispatch->put_att(ncidvaridnameNC_CHARlen,
#232   NCncp;
#233   int stat = NC_check_id(ncid, &ncp);
#235   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#243   NC *ncp;
#244   int stat = NC_check_id(ncid, &ncp);
#246   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#254   NCncp;
#255   int stat = NC_check_id(ncid, &ncp);
#257   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#265   NCncp;
#266   int stat = NC_check_id(ncid, &ncp);
#268   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#276   NCncp;
#277   int stat = NC_check_id(ncid, &ncp);
#279   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#287   NCncp;
#288   int stat = NC_check_id(ncid, &ncp);
#290   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#298   NCncp;
#299   int stat = NC_check_id(ncid, &ncp);
#301   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#309   NCncp;
#310   int stat = NC_check_id(ncid, &ncp);
#312   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#320   NCncp;
#321   int stat = NC_check_id(ncid, &ncp);
#323   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#331   NCncp;
#332   int stat = NC_check_id(ncid, &ncp);
#334   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#342   NCncp;
#343   int stat = NC_check_id(ncid, &ncp);
#345   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#354   NCncp;
#355   int stat = NC_check_id(ncid, &ncp);
#357   return ncp->dispatch->put_att(ncidvaridnamextypelen,
#366   NCncp;
#367   int stat = NC_check_id(ncid, &ncp);
#369   return ncp->dispatch->put_att(ncidvaridnamextypelen,
dcompound.c#66   NCncp;
#67   int stat = NC_check_id(ncid,&ncp);
#69   return ncp->dispatch->def_compound(ncid,size,name,typeidp);
#102   NC *ncp;
#103   int stat = NC_check_id(ncid, &ncp);
#105   return ncp->dispatch->insert_compound(ncidxtypename,
#145   NCncp;
#146   int stat = NC_check_id(ncid,&ncp);
#148   return ncp->dispatch->insert_array_compound(ncid,xtype,name,offset,field_typeid,ndims,dim_sizes);
#292   NCncp;
#293   int stat = NC_check_id(ncid,&ncp);
#295   return ncp->dispatch->inq_compound_field(ncidxtypefieldid,
#324   NCncp;
#325   int stat = NC_check_id(ncid,&ncp);
#327   return ncp->dispatch->inq_compound_field(ncidxtypefieldid,
#356   NCncp;
#357   int stat = NC_check_id(ncid,&ncp);
#359   return ncp->dispatch->inq_compound_field(ncid,xtype,fieldid,NULL,offsetp,NULL,NULL,NULL);
#386   NCncp;
#387   int stat = NC_check_id(ncid,&ncp);
#389   return ncp->dispatch->inq_compound_field(ncid,xtype,fieldid,NULL,NULL,field_typeidp,NULL,NULL);
#416   NCncp;
#417   int stat = NC_check_id(ncid,&ncp);
#419   return ncp->dispatch->inq_compound_field(ncid,xtype,fieldid,NULL,NULL,NULL,ndimsp,NULL);
#446   NC *ncp;
#447   int stat = NC_check_id(ncid, &ncp);
#449   return ncp->dispatch->inq_compound_field(ncidxtypefieldid,
#478   NCncp;
#479   int stat = NC_check_id(ncid,&ncp);
#481   return ncp->dispatch->inq_compound_fieldindex(ncid,xtype,name,fieldidp);
ddim.c#126    NCncp;
#127    int stat = NC_check_id(ncid, &ncp);
#130    return ncp->dispatch->def_dim(ncidnamelenidp);
#156    NCncp;
#157    int stat = NC_check_id(ncid, &ncp);
#160    return ncp->dispatch->inq_dimid(ncid,name,idp);
#220    NCncp;
#221    int stat = NC_check_id(ncid, &ncp);
#224    return ncp->dispatch->inq_dim(ncid,dimid,name,lenp);
#282    NCncp;
#283    int stat = NC_check_id(ncid, &ncp);
#286    return ncp->dispatch->rename_dim(ncid,dimid,name);
#313    NCncp;
#314    int stat = NC_check_id(ncid, &ncp);
#318    return ncp->dispatch->inq(ncid,ndimsp,NULL,NULL,NULL);
#344    NCncp;
#345    int stat = NC_check_id(ncid, &ncp);
#348    return ncp->dispatch->inq_unlimdim(ncid,unlimdimidp);
#403    NCncp;
#404    int stat = NC_check_id(ncid, &ncp);
#408    return ncp->dispatch->inq_dim(ncid,dimid,name,NULL);
#460    NCncp;
#461    int stat = NC_check_id(ncid, &ncp);
#465    return ncp->dispatch->inq_dim(ncid,dimid,NULL,lenp);
denum.c#45    NCncp;
#46    int stat = NC_check_id(ncid,&ncp);
#48    return ncp->dispatch->def_enum(ncid,base_typeid,name,typeidp);
#74    NC *ncp;
#75    int stat = NC_check_id(ncid, &ncp);
#77    return ncp->dispatch->insert_enum(ncidxtypename,
#143    NC *ncp;
#144    int stat = NC_check_id(ncid, &ncp);
#146    return ncp->dispatch->inq_enum_member(ncidxtypeidxnamevalue);
#171    NCncp;
#172    int stat = NC_check_id(ncid,&ncp);
#174    return ncp->dispatch->inq_enum_ident(ncid,xtype,value,identifier);
dfile.c#815   NCncp;
#817   if ((stat = NC_check_id(ncid, &ncp)))
#819   if(ncp->path == NULL) {
#823       if (pathlen) *pathlen = strlen(ncp->path);
#824       if (pathstrcpy(pathncp->path);
#880   NCncp;
#881   int stat = NC_check_id(ncid, &ncp);
#883   return ncp->dispatch->redef(ncid);
#945   NC *ncp;
#946   status = NC_check_id(ncid, &ncp);
#948   return ncp->dispatch->_enddef(ncid,0,1,0,1);
#1036   NCncp;
#1037   int stat = NC_check_id(ncid, &ncp);
#1039   return ncp->dispatch->_enddef(ncid,h_minfree,v_align,v_minfree,r_align);
#1112   NCncp;
#1113   int stat = NC_check_id(ncid, &ncp);
#1115   return ncp->dispatch->sync(ncid);
#1164   NCncp;
#1165   int stat = NC_check_id(ncid, &ncp);
#1171   ncp->refcount = 0;
#1174   stat = ncp->dispatch->abort(ncid);
#1175   del_from_NCList(ncp);
#1176   free_NC(ncp);
#1223   NCncp;
#1224   int stat = NC_check_id(ncid, &ncp);
#1228   ncp->refcount--;
#1229   if(ncp->refcount <= 0)
#1233    stat = ncp->dispatch->close(ncid);
#1235       del_from_NCList(ncp);
#1236       free_NC(ncp);
#1342   NCncp;
#1343   int stat = NC_check_id(ncid, &ncp);
#1345   return ncp->dispatch->set_fill(ncid,fillmode,old_modep);
#1362   NCncp;
#1363   int stat = NC_check_id(ncid, &ncp);
#1365   return ncp->dispatch->inq_base_pe(ncid,pe);
#1382   NCncp;
#1383   int stat = NC_check_id(ncid, &ncp);
#1385   return ncp->dispatch->set_base_pe(ncid,pe);
#1409   NCncp;
#1410   int stat = NC_check_id(ncid, &ncp);
#1412   return ncp->dispatch->inq_format(ncid,formatp);
#1444   NCncp;
#1445   int stat = NC_check_id(ncid, &ncp);
#1447   return ncp->dispatch->inq_format_extended(ncid,formatp,modep);
#1497   NCncp;
#1498   int stat = NC_check_id(ncid, &ncp);
#1500   return ncp->dispatch->inq(ncid,ndimsp,nvarsp,nattsp,unlimdimidp);
#1506   NCncp;
#1507   int stat = NC_check_id(ncid, &ncp);
#1509   return ncp->dispatch->inq(ncidNULLnvarspNULLNULL);
#1580   NCncp;
#1586   stat = NC_check_id(ncid, &ncp);
#1597      return ncp->dispatch->inq_type(ncid,xtype,name,size);
#1654   NCncp = NULL;
#1673   ncp = find_in_NCList_by_name(path);
#1674   if(ncp != NULL)
#1761   stat = new_NC(dispatcher,path,cmode,&ncp);
#1765   add_to_NCList(ncp);
#1769   ncp->refcount++;
#1774    useparallelparametersdispatcherncp))) {
#1775 del_from_NCList(ncp); /* oh well */
#1776 free_NC(ncp);
#1778       if(ncidp)*ncidp = ncp->ext_ncid;
#1805   NCncp = NULL;
#1822   ncp = find_in_NCList_by_name(path);
#1823   if(ncp != NULL) {
#1824 ncp->refcount++;
#1825 if(ncidp) *ncidp = ncp->ext_ncid;
#1919   stat = new_NC(dispatcher,path,cmode,&ncp);
#1923   add_to_NCList(ncp);
#1927   ncp->refcount++;
#1932    useparallelparametersdispatcherncp);
#1934     if(ncidp) *ncidp = ncp->ext_ncid;
#1936 del_from_NCList(ncp);
#1937 free_NC(ncp);
dgroup.c#58    NCncp;
#59    int stat = NC_check_id(ncid,&ncp);
#61    return ncp->dispatch->inq_ncid(ncid,name,grp_ncid);
#75    NCncp;
#76    int stat = NC_check_id(ncid,&ncp);
#78    return ncp->dispatch->inq_grps(ncid,numgrps,ncids);
#90    NCncp;
#91    int stat = NC_check_id(ncid,&ncp);
#93    return ncp->dispatch->inq_grpname(ncid,name);
#108    NCncp;
#109    int stat = NC_check_id(ncid,&ncp);
#111    return ncp->dispatch->inq_grpname_full(ncid,lenp,full_name);
#138    NCncp;
#139    int stat = NC_check_id(ncid,&ncp);
#141    return ncp->dispatch->inq_grp_parent(ncid,parent_ncid);
#171    NCncp;
#172    int stat = NC_check_id(ncid,&ncp);
#174    return ncp->dispatch->inq_grp_full_ncid(ncid,full_name,grp_ncid);
#189    NCncp;
#190    int stat = NC_check_id(ncid,&ncp);
#192    return ncp->dispatch->inq_varids(ncid,nvars,varids);
#207    NCncp;
#208    int stat = NC_check_id(ncid,&ncp);
#210    return ncp->dispatch->inq_dimids(ncid,ndims,dimids,include_parents);
#225    NCncp;
#226    int stat = NC_check_id(ncid,&ncp);
#228    return ncp->dispatch->inq_typeids(ncid,ntypes,typeids);
#270    NCncp;
#271    int stat = NC_check_id(parent_ncid,&ncp);
#273    return ncp->dispatch->def_grp(parent_ncid,name,new_ncid);
#286    NCncp;
#287    int stat = NC_check_id(grpid,&ncp);
#289    return ncp->dispatch->rename_grp(grpid,name);
#301    NCncp;
#302    int stat = NC_check_id(ncid,&ncp);
#304    return ncp->dispatch->show_metadata(ncid);
dim.c#322 NC3_INFOncp;
#329 ncp = NC3_DATA(nc);
#331 if(!NC_indef(ncp))
#338 if(ncp->flags & NC_64BIT_DATA) {/*CDF-5*/
#341 } else if(ncp->flags & NC_64BIT_OFFSET) {/* CDF2 format and LFS */
#351 dimid = find_NC_Udim(&ncp->dims, &dimp);
#359 if(ncp->dims.nelems >= NC_MAX_DIMS)
#362 dimid = NC_finddim(&ncp->dimsname, &dimp);
#369 status = incr_NC_dimarray(&ncp->dimsdimp);
#377 *dimidp = (int)ncp->dims.nelems -1;
#387 NC3_INFOncp;
#393 ncp = NC3_DATA(nc);
#395 dimid = NC_finddim(&ncp->dimsnameNULL);
#410 NC3_INFOncp;
#416 ncp = NC3_DATA(nc);
#418 dimp = elem_NC_dimarray(&ncp->dims, (size_t)dimid);
#431 *sizep = NC_get_numrecs(ncp);
#443 NC3_INFOncp;
#451 ncp = NC3_DATA(nc);
#453 if(NC_readonly(ncp))
#460 existid = NC_finddim(&ncp->dimsunewname, &dimp);
#464 dimp = elem_NC_dimarray(&ncp->dims, (size_t)dimid);
#472 if(NC_indef(ncp))
#480 NC_hashmapRemoveDim(&ncp->dimsold->cp);
#484 NC_hashmapAddDim(&ncp->dimsdimidnewStr->cp);
#494 NC_hashmapRemoveDim(&ncp->dimsold->cp);
#501 NC_hashmapAddDim(&ncp->dimsdimiddimp->name->cp);
#503 set_NC_hdirty(ncp);
#505 if(NC_doHsync(ncp))
#507 status = NC_sync(ncp);
dinternal.c#25   NCncp;
#26   int stat = NC_check_id(ncid,&ncp);
#28   return ncp->dispatch->inq_var_all(
#42   NCncp;
#43   int stat = NC_check_id(ncid,&ncp);
#45   return ncp->dispatch->get_att(ncid,varid,name,value,t);
dopaque.c#35    NCncp;
#36    int stat = NC_check_id(ncid,&ncp);
#38    return ncp->dispatch->def_opaque(ncid,size,name,xtypep);
dparallel.c#100    NCncp;
#104    if ((stat = NC_check_id(ncid, &ncp)))
#110    return ncp->dispatch->var_par_access(ncid,varid,par_access);
dtype.c#94    NCncp;
#95    int stat = NC_check_id(ncid,&ncp);
#97    return ncp->dispatch->inq_typeid(ncid,name,typeidp);
#138    NC *ncp;
#139    int stat = NC_check_id(ncid,&ncp);
#141    return ncp->dispatch->inq_user_type(ncidxtypenamesize,
dvar.c#210   NCncp;
#213   if ((stat = NC_check_id(ncid, &ncp)))
#216   return ncp->dispatch->def_var(ncidnamextypendims,
#283   NCncp;
#284   int stat = NC_check_id(ncid, &ncp);
#287   return ncp->dispatch->rename_var(ncidvaridname);
#550    NCncp;
#551    int stat = NC_check_id(ncid, &ncp);
#553    return ncp->dispatch->set_var_chunk_cache(ncidvaridsize,
#588    NCncp;
#589    int stat = NC_check_id(ncid, &ncp);
#591    return ncp->dispatch->get_var_chunk_cache(ncidvaridsizep,
#620    NCncp;
#621    int stat = NC_check_id(ncid,&ncp);
#623    return ncp->dispatch->def_var_deflate(ncid,varid,shuffle,deflate,deflate_level);
#629    NCncp;
#630    int stat = NC_check_id(ncid,&ncp);
#632    return ncp->dispatch->def_var_fletcher32(ncid,varid,fletcher32);
#705    NCncp;
#706    int stat = NC_check_id(ncid, &ncp);
#708    return ncp->dispatch->def_var_chunking(ncidvaridstorage,
#715    NCncp;
#716    int stat = NC_check_id(ncid,&ncp);
#718    return ncp->dispatch->def_var_fill(ncid,varid,no_fill,fill_value);
#724    NCncp;
#725    int stat = NC_check_id(ncid,&ncp);
#727    return ncp->dispatch->def_var_endian(ncid,varid,endian);
dvarget.c#85   NCncp;
#86   int stat = NC_check_id(ncid, &ncp);
#99      stat = ncp->dispatch->get_vara(ncid,varid,start,shape,value,memtype);
#101      stat =  ncp->dispatch->get_vara(ncid,varid,start,edges,value,memtype);
#130   NCncp;
#131   int stat = NC_check_id(ncid, &ncp);
#134   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
#143   NCncp;
#154   status = NC_check_id (ncid, &ncp);
#279   NCncp;
#283   status = NC_check_id (ncid, &ncp);
#518   NCncp;
#519   int stat = NC_check_id(ncid, &ncp);
#525   return ncp->dispatch->get_vars(ncid,varid,start,edges,stride,value,memtype);
#537   NCncp;
#538   int stat = NC_check_id(ncid, &ncp);
#544   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,map,value,memtype);
#630   NCncp = NULL;
#632   int stat = NC_check_id(ncid, &ncp);
#643   NCncp;
#644   int stat = NC_check_id(ncid, &ncp);
#654   NCncp;
#655   int stat = NC_check_id(ncid, &ncp);
#665   NCncp;
#666   int stat = NC_check_id(ncid, &ncp);
#676   NCncp;
#677   int stat = NC_check_id(ncid, &ncp);
#687   NCncp;
#688   int stat = NC_check_id(ncid, &ncp);
#697   NCncp;
#698   int stat = NC_check_id(ncid, &ncp);
#707   NCncp;
#708   int stat = NC_check_id(ncid, &ncp);
#718   NCncp;
#719   int stat = NC_check_id(ncid, &ncp);
#728   NCncp;
#729   int stat = NC_check_id(ncid, &ncp);
#738   NCncp;
#739   int stat = NC_check_id(ncid, &ncp);
#748   NCncp;
#749   int stat = NC_check_id(ncid, &ncp);
#758   NCncp;
#759   int stat = NC_check_id(ncid, &ncp);
#768   NCncp;
#769   int stat = NC_check_id(ncid, &ncp);
#779   NCncp;
#780   int stat = NC_check_id(ncid, &ncp);
#831   NCncp;
#832   int stat = NC_check_id(ncid, &ncp);
#840   NCncp;
#841   int stat = NC_check_id(ncid, &ncp);
#849   NCncp;
#850   int stat = NC_check_id(ncid, &ncp);
#858   NCncp;
#859   int stat = NC_check_id(ncid, &ncp);
#867   NCncp;
#868   int stat = NC_check_id(ncid, &ncp);
#877   NCncp;
#878   int stat = NC_check_id(ncid, &ncp);
#887   NCncp;
#888   int stat = NC_check_id(ncid, &ncp);
#897   NCncp;
#898   int stat = NC_check_id(ncid, &ncp);
#907   NCncp;
#908   int stat = NC_check_id(ncid, &ncp);
#917   NCncp;
#918   int stat = NC_check_id(ncid, &ncp);
#927   NCncp;
#928   int stat = NC_check_id(ncid, &ncp);
#937   NCncp;
#938   int stat = NC_check_id(ncid, &ncp);
#947   NCncp;
#948   int stat = NC_check_id(ncid, &ncp);
#957   NCncp;
#958   int stat = NC_check_id(ncid, &ncp);
#1017   NC *ncp;
#1018   int stat = NC_check_id(ncid, &ncp);
#1026   NC *ncp;
#1027   int stat = NC_check_id(ncid, &ncp);
#1035   NC *ncp;
#1036   int stat = NC_check_id(ncid, &ncp);
#1044   NCncp;
#1045   int stat = NC_check_id(ncid, &ncp);
#1053   NCncp;
#1054   int stat = NC_check_id(ncid, &ncp);
#1062   NCncp;
#1063   int stat = NC_check_id(ncid, &ncp);
#1071   NCncp;
#1072   int stat = NC_check_id(ncid, &ncp);
#1080   NCncp;
#1081   int stat = NC_check_id(ncid, &ncp);
#1089   NCncp;
#1090   int stat = NC_check_id(ncid, &ncp);
#1098   NCncp;
#1099   int stat = NC_check_id(ncid, &ncp);
#1107   NCncp;
#1108   int stat = NC_check_id(ncid, &ncp);
#1116   NCncp;
#1117   int stat = NC_check_id(ncid, &ncp);
#1125   NCncp;
#1126   int stat = NC_check_id(ncid, &ncp);
#1135   NCncp;
#1136   int stat = NC_check_id(ncid, &ncp);
#1188   NCncp;
#1191   if ((stat = NC_check_id(ncid, &ncp)))
#1193   return ncp->dispatch->get_vars(ncidvaridstartpcountpstridep,
#1202   NCncp;
#1203   int stat = NC_check_id(ncid, &ncp);
#1214   NCncp;
#1215   int stat = NC_check_id(ncid, &ncp);
#1226   NCncp;
#1227   int stat = NC_check_id(ncid, &ncp);
#1238   NCncp;
#1239   int stat = NC_check_id(ncid, &ncp);
#1250   NCncp;
#1251   int stat = NC_check_id(ncid, &ncp);
#1262   NCncp;
#1263   int stat = NC_check_id(ncid, &ncp);
#1274   NCncp;
#1275   int stat = NC_check_id(ncid, &ncp);
#1286   NCncp;
#1287   int stat = NC_check_id(ncid, &ncp);
#1298   NCncp;
#1299   int stat = NC_check_id(ncid, &ncp);
#1310   NCncp;
#1311   int stat = NC_check_id(ncid, &ncp);
#1322   NCncp;
#1323   int stat = NC_check_id(ncid, &ncp);
#1334   NCncp;
#1335   int stat = NC_check_id(ncid, &ncp);
#1346   NCncp;
#1347   int stat = NC_check_id(ncid, &ncp);
#1360   NCncp;
#1361   int stat = NC_check_id(ncid, &ncp);
#1429   NCncp;
#1432   if ((stat = NC_check_id(ncid, &ncp)))
#1434   return ncp->dispatch->get_varm(ncidvaridstartpcountp,
#1444   NC *ncp;
#1445   int stat = NC_check_id(ncid, &ncp);
#1457   NC *ncp;
#1458   int stat = NC_check_id(ncid, &ncp);
#1468   NC *ncp;
#1469   int stat = NC_check_id(ncid, &ncp);
#1480   NC *ncp;
#1481   int stat = NC_check_id(ncid, &ncp);
#1492   NC *ncp;
#1493   int stat = NC_check_id(ncid, &ncp);
#1504   NC *ncp;
#1505   int stat = NC_check_id(ncid, &ncp);
#1516   NC *ncp;
#1517   int stat = NC_check_id(ncid, &ncp);
#1528   NC *ncp;
#1529   int stat = NC_check_id(ncid, &ncp);
#1541   NC *ncp;
#1542   int stat = NC_check_id(ncid, &ncp);
#1554   NC *ncp;
#1555   int stat = NC_check_id(ncid, &ncp);
#1566   NC *ncp;
#1567   int stat = NC_check_id(ncid, &ncp);
#1579   NC *ncp;
#1580   int stat = NC_check_id(ncid, &ncp);
#1591   NC *ncp;
#1592   int stat = NC_check_id(ncid, &ncp);
#1604   NC *ncp;
#1605   int stat = NC_check_id(ncid, &ncp);
dvarinq.c#54   NCncp;
#55   int stat = NC_check_id(ncid, &ncp);
#57   return ncp->dispatch->inq_varid(ncidnamevaridp);
#119   NCncp;
#120   int stat = NC_check_id(ncid, &ncp);
#123   return ncp->dispatch->inq_var_all(ncidvaridnamextypepndimsp,
#277   NCncp;
#278   int stat = NC_check_id(ncid,&ncp);
#281   return ncp->dispatch->inq_var_all(
#332   NCncp;
#333   int stat = NC_check_id(ncid,&ncp);
#336   return ncp->dispatch->inq_var_all(
#380   NCncp;
#381   int stat = NC_check_id(ncid,&ncp);
#384   return ncp->dispatch->inq_var_all(
#468   NC *ncp;
#469   int stat = NC_check_id(ncid, &ncp);
#472   return ncp->dispatch->inq_var_all(ncidvaridNULLNULLNULLNULL,
#503   NCncp;
#504   int stat = NC_check_id(ncid,&ncp);
#507   return ncp->dispatch->inq_var_all(
#552   NCncp;
#553   int stat = NC_check_id(ncid,&ncp);
#556   return ncp->dispatch->inq_var_all(
#602    NCncp;
#603    int stat = NC_check_id(ncid,&ncp);
#606    return ncp->dispatch->inq_unlimdims(ncidnunlimdimsp,
#650   NCncp;
#651   int stat = NC_check_id(ncid,&ncp);
#653   return ncp->dispatch->inq_var_all(
dvarput.c#67   NCncp;
#68   int stat = NC_check_id(ncid, &ncp);
#77      return ncp->dispatch->put_vara(ncidvaridstartshapevaluememtype);
#79      return ncp->dispatch->put_vara(ncidvaridstartedgesvaluememtype);
#116   NCncp;
#117   int stat = NC_check_id(ncid, &ncp);
#120   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
#129   NCncp;
#142   status = NC_check_id (ncid, &ncp);
#285   NCncp;
#289   status = NC_check_id (ncid, &ncp);
#499   NCncp;
#500   int stat = NC_check_id(ncid, &ncp);
#506   return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
#517   NCncp;
#518   int stat = NC_check_id(ncid, &ncp);
#524   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
#576   NCncp;
#577   int stat = NC_check_id(ncid, &ncp);
#597   NCncp;
#598   int stat = NC_check_id(ncid, &ncp);
#608   NCncp;
#609   int stat = NC_check_id(ncid, &ncp);
#619   NCncp;
#620   int stat = NC_check_id(ncid, &ncp);
#630   NCncp;
#631   int stat = NC_check_id(ncid, &ncp);
#641   NCncp;
#642   int stat = NC_check_id(ncid, &ncp);
#652   NCncp;
#653   int stat = NC_check_id(ncid, &ncp);
#663   NCncp;
#664   int stat = NC_check_id(ncid, &ncp);
#674   NCncp;
#675   int stat = NC_check_id(ncid, &ncp);
#685   NCncp;
#686   int stat = NC_check_id(ncid, &ncp);
#696   NCncp;
#697   int stat = NC_check_id(ncid, &ncp);
#707   NCncp;
#708   int stat = NC_check_id(ncid, &ncp);
#718   NCncp;
#719   int stat = NC_check_id(ncid, &ncp);
#730   NCncp;
#731   int stat = NC_check_id(ncid, &ncp);
#771   NCncp;
#772   int stat = NC_check_id(ncid, &ncp);
#780   NCncp;
#781   int stat = NC_check_id(ncid, &ncp);
#789   NCncp;
#790   int stat = NC_check_id(ncid, &ncp);
#798   NCncp;
#799   int stat = NC_check_id(ncid, &ncp);
#807   NCncp;
#808   int stat = NC_check_id(ncid, &ncp);
#816   NCncp;
#817   int stat = NC_check_id(ncid, &ncp);
#825   NCncp;
#826   int stat = NC_check_id(ncid, &ncp);
#834   NCncp;
#835   int stat = NC_check_id(ncid, &ncp);
#843   NCncp;
#844   int stat = NC_check_id(ncid, &ncp);
#852   NCncp;
#853   int stat = NC_check_id(ncid, &ncp);
#861   NCncp;
#862   int stat = NC_check_id(ncid, &ncp);
#870   NCncp;
#871   int stat = NC_check_id(ncid, &ncp);
#879   NCncp;
#880   int stat = NC_check_id(ncid, &ncp);
#889   NCncp;
#890   int stat = NC_check_id(ncid, &ncp);
#952   NCncp;
#953   int stat = NC_check_id(ncid, &ncp);
#961   NCncp;
#962   int stat = NC_check_id(ncid, &ncp);
#970   NCncp;
#971   int stat = NC_check_id(ncid, &ncp);
#979   NCncp;
#980   int stat = NC_check_id(ncid, &ncp);
#988   NCncp;
#989   int stat = NC_check_id(ncid, &ncp);
#997   NCncp;
#998   int stat = NC_check_id(ncid, &ncp);
#1006   NCncp;
#1007   int stat = NC_check_id(ncid, &ncp);
#1015   NCncp;
#1016   int stat = NC_check_id(ncid, &ncp);
#1024   NCncp;
#1025   int stat = NC_check_id(ncid, &ncp);
#1033   NCncp;
#1034   int stat = NC_check_id(ncid, &ncp);
#1042   NCncp;
#1043   int stat = NC_check_id(ncid, &ncp);
#1051   NCncp;
#1052   int stat = NC_check_id(ncid, &ncp);
#1060   NCncp;
#1061   int stat = NC_check_id(ncid, &ncp);
#1070   NCncp;
#1071   int stat = NC_check_id(ncid, &ncp);
#1113   NC *ncp;
#1116   if ((stat = NC_check_id(ncid, &ncp)))
#1118   return ncp->dispatch->put_vars(ncidvaridstartpcountp,
#1127   NC *ncp;
#1128   int stat = NC_check_id(ncid, &ncp);
#1139   NC *ncp;
#1140   int stat = NC_check_id(ncid, &ncp);
#1152   NC *ncp;
#1153   int stat = NC_check_id(ncid, &ncp);
#1165   NC *ncp;
#1166   int stat = NC_check_id(ncid, &ncp);
#1178   NC *ncp;
#1179   int stat = NC_check_id(ncid, &ncp);
#1191   NC *ncp;
#1192   int stat = NC_check_id(ncid, &ncp);
#1204   NC *ncp;
#1205   int stat = NC_check_id(ncid, &ncp);
#1217   NC *ncp;
#1218   int stat = NC_check_id(ncid, &ncp);
#1230   NC *ncp;
#1231   int stat = NC_check_id(ncid, &ncp);
#1243   NC *ncp;
#1244   int stat = NC_check_id(ncid, &ncp);
#1256   NC *ncp;
#1257   int stat = NC_check_id(ncid, &ncp);
#1269   NC *ncp;
#1270   int stat = NC_check_id(ncid, &ncp);
#1282   NC *ncp;
#1283   int stat = NC_check_id(ncid, &ncp);
#1296   NC *ncp;
#1297   int stat = NC_check_id(ncid, &ncp);
#1353   NC *ncp;
#1356   if ((stat = NC_check_id(ncid, &ncp)))
#1358   return ncp->dispatch->put_varm(ncidvaridstartpcountp,
#1367   NC *ncp;
#1368   int stat = NC_check_id(ncid, &ncp);
#1380   NC *ncp;
#1381   int stat = NC_check_id(ncid, &ncp);
#1393   NC *ncp;
#1394   int stat = NC_check_id(ncid, &ncp);
#1406   NC *ncp;
#1407   int stat = NC_check_id(ncid, &ncp);
#1419   NC *ncp;
#1420   int stat = NC_check_id(ncid, &ncp);
#1432   NC *ncp;
#1433   int stat = NC_check_id(ncid, &ncp);
#1445   NC *ncp;
#1446   int stat = NC_check_id(ncid, &ncp);
#1458   NC *ncp;
#1459   int stat = NC_check_id(ncid, &ncp);
#1471   NC *ncp;
#1472   int stat = NC_check_id(ncid, &ncp);
#1484   NC *ncp;
#1485   int stat = NC_check_id(ncid, &ncp);
#1497   NC *ncp;
#1498   int stat = NC_check_id(ncid, &ncp);
#1510   NC *ncp;
#1511   int stat = NC_check_id(ncid, &ncp);
#1523   NC *ncp;
#1524   int stat = NC_check_id(ncid, &ncp);
#1537   NC *ncp;
#1538   int stat = NC_check_id(ncid, &ncp);
dvlen.c#92    NCncp;
#93    int stat = NC_check_id(ncid,&ncp);
#95    return ncp->dispatch->def_vlen(ncid,name,base_typeid,xtypep);
#150    NCncp;
#151    int stat = NC_check_id(ncid,&ncp);
#153    return ncp->dispatch->put_vlen_element(ncid,typeid1,vlen_element,len,data);
#179    NC *ncp;
#180    int stat = NC_check_id(ncid,&ncp);
#182    return ncp->dispatch->get_vlen_element(ncidtypeid1vlen_element,
nc.c#40free_NC(NC *ncp)
#42    if(ncp == NULL)
#44    if(ncp->path)
#45 free(ncp->path);
#48    shfree(ncp);
#50    free(ncp);
#57    NC *ncp = (NC*)calloc(1,sizeof(NC));
#58    if(ncp == NULL) return NC_ENOMEM;
#59    ncp->dispatch = dispatcher;
#60    ncp->path = nulldup(path);
#61    ncp->mode = mode;
#62    if(ncp->path == NULL) { /* fail */
#63        free_NC(ncp);
#67      *ncpp = ncp;
#69      free_NC(ncp);
nc3dispatch.h#57           struct NC_Dispatch*, NCncp);
#64         NC_Dispatch*, NCncp);
nc3internal.c#53 NC3_INFO *ncp;
#54 ncp = (NC3_INFO*)calloc(1,sizeof(NC3_INFO));
#55 if(ncp == NULL) return ncp;
#56        ncp->chunk = chunkp != NULL ? *chunkp : NC_SIZEHINT_DEFAULT;
#58 return ncp;
#64 NC3_INFO *ncp;
#65 ncp = (NC3_INFO*)calloc(1,sizeof(NC3_INFO));
#66 if(ncp == NULL) return ncp;
#68 if(dup_NC_dimarrayV(&ncp->dims, &ref->dims) != NC_NOERR)
#70 if(dup_NC_attrarrayV(&ncp->attrs, &ref->attrs) != NC_NOERR)
#72 if(dup_NC_vararrayV(&ncp->vars, &ref->vars) != NC_NOERR)
#75 ncp->xsz = ref->xsz;
#76 ncp->begin_var = ref->begin_var;
#77 ncp->begin_rec = ref->begin_rec;
#78 ncp->recsize = ref->recsize;
#79 NC_set_numrecs(ncpNC_get_numrecs(ref));
#80 return ncp;
#82 free_NC3INFO(ncp);
#148NC_begins(NC3_INFOncp,
#161 v_align = ncp->chunk;
#163 r_align = ncp->chunk;
#165 if (fIsSet(ncp->flagsNC_64BIT_OFFSET) || fIsSet(ncp->flagsNC_64BIT_DATA)) {
#171 ncp->xsz = ncx_len_NC(ncp,sizeof_off_t);
#173 if(ncp->vars.nelems == 0)
#178 if (ncp->begin_var < ncp->xsz + h_minfree ||
#179     ncp->begin_var != D_RNDUP(ncp->begin_varv_align) )
#181   index = (off_tncp->xsz;
#182   ncp->begin_var = D_RNDUP(indexv_align);
#183   if(ncp->begin_var < index + h_minfree)
#185     ncp->begin_var = D_RNDUP(index + (off_t)h_minfreev_align);
#189 if (ncp->old != NULL) {
#191            if (ncp->begin_var < ncp->old->begin_var)
#192                ncp->begin_var = ncp->old->begin_var;
#195 index = ncp->begin_var;
#199 vpp = ncp->vars.value;
#200 for(ii = 0; ii < ncp->vars.nelems ; ii++, vpp++)
#218 if (ncp->old != NULL) {
#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;
#240 if (ncp->old != NULL) {
#242     if (ncp->begin_rec < ncp->old->begin_rec)
#243         ncp->begin_rec = ncp->old->begin_rec;
#249 if (ncp->begin_rec < index + v_minfree ||
#250     ncp->begin_rec != D_RNDUP(ncp->begin_recr_align) )
#252   ncp->begin_rec = D_RNDUP(indexr_align);
#253   if(ncp->begin_rec < index + v_minfree)
#255     ncp->begin_rec = D_RNDUP(index + (off_t)v_minfreer_align);
#260     ncp->begin_var = first_var->begin;
#262     ncp->begin_var = ncp->begin_rec;
#264 index = ncp->begin_rec;
#266 ncp->recsize = 0;
#270 vpp = (NC_var **)ncp->vars.value;
#271 for(ii = 0; ii < ncp->vars.nelemsii++, vpp++)
#288                if (ncp->old != NULL) {
#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;
#304 if( ncp->recsize > X_UINT_MAX - (*vpp)->len )
#310     ncp->recsize += (*vpp)->len;
#318     if(ncp->recsize == last->len) { /* exactly one record variable, pack value */
#319 ncp->recsize = *last->dsizes * last->xsz;
#321 ncp->recsize += *last->dsizes * last->xsz;
#324 if(NC_IsNew(ncp))
#325 NC_set_numrecs(ncp, 0);
#335read_numrecs(NC3_INFO *ncp)
#340 size_t  old_nrecs = NC_get_numrecs(ncp);
#343 assert(!NC_indef(ncp));
#345 if (fIsSet(ncp->flagsNC_64BIT_DATA))
#348 status = ncio_get(ncp->nciop,
#353 if (fIsSet(ncp->flagsNC_64BIT_DATA)) {
#360 (void) ncio_rel(ncp->nciopNC_NUMRECS_OFFSET, 0);
#364 NC_set_numrecs(ncpnew_nrecs);
#365 fClr(ncp->flagsNC_NDIRTY);
#377write_numrecs(NC3_INFO *ncp)
#383 assert(!NC_readonly(ncp));
#384 assert(!NC_indef(ncp));
#386 if (fIsSet(ncp->flagsNC_64BIT_DATA))
#389 status = ncio_get(ncp->nciop,
#395 const size_t nrecs = NC_get_numrecs(ncp);
#396 if (fIsSet(ncp->flagsNC_64BIT_DATA))
#402 (void) ncio_rel(ncp->nciopNC_NUMRECS_OFFSETRGN_MODIFIED);
#405 fClr(ncp->flagsNC_NDIRTY);
#416read_NC(NC3_INFO *ncp)
#420 free_NC_dimarrayV(&ncp->dims);
#421 free_NC_attrarrayV(&ncp->attrs);
#422 free_NC_vararrayV(&ncp->vars);
#424 status = nc_get_NC(ncp);
#427 fClr(ncp->flagsNC_NDIRTY | NC_HDIRTY);
#437write_NC(NC3_INFO *ncp)
#441 assert(!NC_readonly(ncp));
#443 status = ncx_put_NC(ncpNULL, 0, 0);
#446 fClr(ncp->flagsNC_NDIRTY | NC_HDIRTY);
#456NC_sync(NC3_INFO *ncp)
#458 assert(!NC_readonly(ncp));
#460 if(NC_hdirty(ncp))
#462 return write_NC(ncp);
#466 if(NC_ndirty(ncp))
#468 return write_numrecs(ncp);
#480fillerup(NC3_INFO *ncp)
#486 assert(!NC_readonly(ncp));
#487 assert(NC_dofill(ncp));
#490 varpp = ncp->vars.value;
#491 for(ii = 0; ii < ncp->vars.nelemsii++, varpp++)
#499 status = fill_NC_var(ncp, *varpp, (*varpp)->len, 0);
#684NC_check_vlens(NC3_INFO *ncp)
#696    if(ncp->vars.nelems == 0)
#699    if (fIsSet(ncp->flags,NC_64BIT_DATA)) {
#703    if (fIsSet(ncp->flags,NC_64BIT_OFFSET) && sizeof(off_t) > 4) {
#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++) {
#771NC_endef(NC3_INFO *ncp,
#777 assert(!NC_readonly(ncp));
#778 assert(NC_indef(ncp));
#780 status = NC_check_vlens(ncp);
#783 status = NC_begins(ncph_minfreev_alignv_minfreer_align);
#787 if(ncp->old != NULL)
#790 assert(!NC_IsNew(ncp));
#791 assert(fIsSet(ncp->flagsNC_INDEF));
#792 assert(ncp->begin_rec >= ncp->old->begin_rec);
#793 assert(ncp->begin_var >= ncp->old->begin_var);
#795 if(ncp->vars.nelems != 0)
#797 if(ncp->begin_rec > ncp->old->begin_rec)
#799 status = move_recs_r(ncpncp->old);
#802 if(ncp->begin_var > ncp->old->begin_var)
#804 status = move_vars_r(ncpncp->old);
#814 if(ncp->begin_var > ncp->old->begin_var)
#816 status = move_vars_r(ncpncp->old);
#823         if(ncp->recsize > ncp->old->recsize)
#825         status = move_recs_r(ncpncp->old);
#833 status = write_NC(ncp);
#837 if(NC_dofill(ncp))
#839 if(NC_IsNew(ncp))
#841 status = fillerup(ncp);
#846 else if(ncp->old == NULL ? 0
#847                                         : (ncp->vars.nelems > ncp->old->vars.nelems))
#849            status = fill_added(ncpncp->old);
#852            status = fill_added_recs(ncpncp->old);
#858 if(ncp->old != NULL)
#860 free_NC3INFO(ncp->old);
#861 ncp->old = NULL;
#864 fClr(ncp->flagsNC_CREAT | NC_INDEF);
#866 return ncio_sync(ncp->nciop);
#871NC_init_pe(NC *ncp, int basepe) {
#876 ncp->lock[LOCKNUMREC_VALUE] = 0;
#877 ncp->lock[LOCKNUMREC_LOCK] = 0;
#878 ncp->lock[LOCKNUMREC_SERVING] = 0;
#879 ncp->lock[LOCKNUMREC_BASEPE] =  basepe;
#889NC_calcsize(const NC3_INFO *ncpoff_t *calcsizep)
#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
#898     *calcsizep = ncp->xsz; /* size of header */
#924     *calcsizep = ncp->begin_rec + ncp->numrecs * ncp->recsize;
#939 ncp = (NC *) shmalloc(sizeof(NC));
#941 ncp = (NC *) malloc(sizeof(NC));
#943 if(ncp == NULL)
#945 (void) memset(ncp, 0, sizeof(NC));
#947 ncp->xsz = MIN_NC_XSZ;
#948 assert(ncp->xsz == ncx_len_NC(ncp,0));
#950        if(ncpp) *ncpp = ncp;
#1625   NC *ncp;
#1626   int stat = NC_check_id(ncid, &ncp);
nc3internal.h#235NC_lookupvar(NC3_INFOncp, int varidNC_var **varp);
#324#define NC_readonly(ncp) \
#325 (!fIsSet((ncp)->nciop->ioflagsNC_WRITE))
#327#define NC_set_readonly(ncp) \
#328 fClr((ncp)->flagsNC_WRITE)
#330#define NC_IsNew(ncp) \
#331 fIsSet((ncp)->flagsNC_CREAT)
#333#define NC_indef(ncp) \
#334 (NC_IsNew(ncp) || fIsSet((ncp)->flagsNC_INDEF))
#336#define set_NC_ndirty(ncp) \
#337 fSet((ncp)->flagsNC_NDIRTY)
#339#define NC_ndirty(ncp) \
#340 fIsSet((ncp)->flagsNC_NDIRTY)
#342#define set_NC_hdirty(ncp) \
#343 fSet((ncp)->flagsNC_HDIRTY)
#345#define NC_hdirty(ncp) \
#346 fIsSet((ncp)->flagsNC_HDIRTY)
#348#define NC_dofill(ncp) \
#349 (!fIsSet((ncp)->flagsNC_NOFILL))
#351#define NC_doHsync(ncp) \
#352 fIsSet((ncp)->flagsNC_HSYNC)
#354#define NC_doNsync(ncp) \
#355 fIsSet((ncp)->flagsNC_NSYNC)
#381read_numrecs(NC3_INFOncp);
#384write_numrecs(NC3_INFOncp);
#387NC_sync(NC3_INFOncp);
#390NC_calcsize(const NC3_INFOncpoff_t *filesizep);
#396ncx_len_NC(const NC3_INFOncp, size_t sizeof_off_t);
#399ncx_put_NC(const NC3_INFOncp, void **xppoff_t offset, size_t extent);
#402nc_get_NC(NC3_INFOncp);
#408fill_NC_var(NC3_INFOncp, const NC_var *varp, size_t varsize, size_t recno);
ncd2dispatch.c#68           NC_Dispatch*,NCncp);
#251           NC_DispatchdispatchNCncp)
ncd2dispatch.h#50         struct NC_DispatchdispatchNCncp);
ncdispatch.h#196   struct NC_DispatchtableNCncp);
#200     struct NC_DispatchtableNCncp);
nclistmgr.c#37add_to_NCList(NCncp)
#48    if(ncp->refcount > 0)
#57    nc_filelist[new_id] = ncp;
#60    ncp->ext_ncid = new_id;
#65del_from_NCList(NCncp)
#67   unsigned int ncid = ((unsigned int)ncp->ext_ncid) >> ID_SHIFT;
#69   if(nc_filelist[ncid] != ncp) return;
#72   if(ncp->refcount > 0)
#116iterate_NCList(int indexNC** ncp)
#121    if(ncp) *ncp = nc_filelist[index];
putget.c#31readNCv(const NC3_INFOncp, const NC_varvarp, const size_t* start,
#34writeNCv(NC3_INFOncp, const NC_varvarp, const size_t* start,
#341fill_NC_var(NC3_INFOncp, const NC_var *varp, size_t varsize, size_t recno)
#446 offset += (off_t)ncp->recsize * recno;
#452 const size_t chunksz = MIN(remainingncp->chunk);
#455 status = ncio_get(ncp->nciopoffsetchunksz,
#483 status = ncio_rel(ncp->nciopoffsetRGN_MODIFIED);
#506NCfillrecord(NC3_INFOncp, const NC_var *const *varpp, size_t recno)
#509 for(; ii < ncp->vars.nelemsii++, varpp++)
#516 const int status = fill_NC_var(ncp, *varpp, (*varpp)->lenrecno);
#531NCfillspecialrecord(NC3_INFOncp, const NC_var *varp, size_t recno)
#535    status = fill_NC_var(ncpvarpncp->recsizerecno);
#552NCtouchlast(NC3_INFOncp, const NC_var *const *varpp, size_t recno)
#559 for(; ii < ncp->vars.nelemsii++, varpp++)
#572 + (off_t)(recno-1) * (off_t)ncp->recsize
#577 status = ncio_get(ncp->nciopoffsetvarp->xsz,
#582 status = ncio_rel(ncp->nciopoffsetRGN_MODIFIED);
#594NCvnrecs(NC3_INFOncp, size_t numrecs)
#602 myticket = shmem_short_finc((shmem_t *) ncp->lock + LOCKNUMREC_LOCK,
#603 ncp->lock[LOCKNUMREC_BASEPE]);
#610 (shmem_t *) ncp->lock + LOCKNUMREC_SERVING, 1,
#611 ncp->lock[LOCKNUMREC_BASEPE]);
#621 (shmem_t *) ncp->lock + LOCKNUMREC_LOCK,
#622 ncp->lock[LOCKNUMREC_BASEPE]);
#632 if(numrecs > NC_get_numrecs(ncp))
#637 status = NCtouchlast(ncp,
#638 (const NC_var *const*)ncp->vars.value,
#644 set_NC_ndirty(ncp);
#646 if(!NC_dofill(ncp))
#649 NC_set_numrecs(ncpnumrecs);
#658     NC_var **vpp = (NC_var **)ncp->vars.value;
#659     NC_var *const *const end = &vpp[ncp->vars.nelems];
#674 while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs)
#676 status = NCfillrecord(ncp,
#677 (const NC_var *const*)ncp->vars.value,
#683 NC_increase_numrecs(ncpcur_nrecs +1);
#689 while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs)
#691 status = NCfillspecialrecord(ncp,
#698 NC_increase_numrecs(ncpcur_nrecs +1);
#706 if(NC_doNsync(ncp))
#708 status = write_numrecs(ncp);
#715 (void) shmem_short_finc((shmem_t *) ncp->lock + LOCKNUMREC_SERVING,
#716 ncp->lock[LOCKNUMREC_BASEPE]);
#726NCcoordck(NC3_INFOncp, const NC_var *varp, const size_t *coord)
#738 if(NC_readonly(ncp) && *coord >= NC_get_numrecs(ncp))
#740 if(!NC_doNsync(ncp))
#745 const int status = read_numrecs(ncp);
#748 if(*coord >= NC_get_numrecs(ncp))
#788NCedgeck(const NC3_INFOncp, const NC_var *varp,
#821NC_varoffset(const NC3_INFOncp, const NC_var *varp, const size_t *coord)
#830  (off_t)(*coord) * (off_t)ncp->recsize;
#851 lcoord += (off_t)(*coord) * ncp->recsize;
#861putNCvx_char_char(NC3_INFOncp, const NC_var *varp,
#864 off_t offset = NC_varoffset(ncpvarpstart);
#876 size_t extent = MIN(remainingncp->chunk);
#879 int lstatus = ncio_get(ncp->nciopoffsetextent,
#891 (void) ncio_rel(ncp->nciopoffset,
#907putNCvx_schar_schar(NC3_INFOncp, const NC_var *varp,
#910 off_t offset = NC_varoffset(ncpvarpstart);
#922 size_t extent = MIN(remainingncp->chunk);
#925 int lstatus = ncio_get(ncp->nciopoffsetextent,
#937 (void) ncio_rel(ncp->nciopoffset,
#952putNCvx_schar_uchar(NC3_INFOncp, const NC_var *varp,
#955 off_t offset = NC_varoffset(ncpvarpstart);
#967 size_t extent = MIN(remainingncp->chunk);
#970 int lstatus = ncio_get(ncp->nciopoffsetextent,
#982 (void) ncio_rel(ncp->nciopoffset,
#997putNCvx_schar_short(NC3_INFOncp, const NC_var *varp,
#1000 off_t offset = NC_varoffset(ncpvarpstart);
#1012 size_t extent = MIN(remainingncp->chunk);
#1015 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1027 (void) ncio_rel(ncp->nciopoffset,
#1042putNCvx_schar_int(NC3_INFOncp, const NC_var *varp,
#1045 off_t offset = NC_varoffset(ncpvarpstart);
#1057 size_t extent = MIN(remainingncp->chunk);
#1060 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1072 (void) ncio_rel(ncp->nciopoffset,
#1087putNCvx_schar_float(NC3_INFOncp, const NC_var *varp,
#1090 off_t offset = NC_varoffset(ncpvarpstart);
#1102 size_t extent = MIN(remainingncp->chunk);
#1105 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1117 (void) ncio_rel(ncp->nciopoffset,
#1132putNCvx_schar_double(NC3_INFOncp, const NC_var *varp,
#1135 off_t offset = NC_varoffset(ncpvarpstart);
#1147 size_t extent = MIN(remainingncp->chunk);
#1150 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1162 (void) ncio_rel(ncp->nciopoffset,
#1177putNCvx_schar_longlong(NC3_INFOncp, const NC_var *varp,
#1180 off_t offset = NC_varoffset(ncpvarpstart);
#1192 size_t extent = MIN(remainingncp->chunk);
#1195 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1207 (void) ncio_rel(ncp->nciopoffset,
#1222putNCvx_schar_ushort(NC3_INFOncp, const NC_var *varp,
#1225 off_t offset = NC_varoffset(ncpvarpstart);
#1237 size_t extent = MIN(remainingncp->chunk);
#1240 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1252 (void) ncio_rel(ncp->nciopoffset,
#1267putNCvx_schar_uint(NC3_INFOncp, const NC_var *varp,
#1270 off_t offset = NC_varoffset(ncpvarpstart);
#1282 size_t extent = MIN(remainingncp->chunk);
#1285 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1297 (void) ncio_rel(ncp->nciopoffset,
#1312putNCvx_schar_ulonglong(NC3_INFOncp, const NC_var *varp,
#1315 off_t offset = NC_varoffset(ncpvarpstart);
#1327 size_t extent = MIN(remainingncp->chunk);
#1330 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1342 (void) ncio_rel(ncp->nciopoffset,
#1358putNCvx_short_schar(NC3_INFOncp, const NC_var *varp,
#1361 off_t offset = NC_varoffset(ncpvarpstart);
#1373 size_t extent = MIN(remainingncp->chunk);
#1376 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1388 (void) ncio_rel(ncp->nciopoffset,
#1403putNCvx_short_uchar(NC3_INFOncp, const NC_var *varp,
#1406 off_t offset = NC_varoffset(ncpvarpstart);
#1418 size_t extent = MIN(remainingncp->chunk);
#1421 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1433 (void) ncio_rel(ncp->nciopoffset,
#1448putNCvx_short_short(NC3_INFOncp, const NC_var *varp,
#1451 off_t offset = NC_varoffset(ncpvarpstart);
#1463 size_t extent = MIN(remainingncp->chunk);
#1466 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1478 (void) ncio_rel(ncp->nciopoffset,
#1493putNCvx_short_int(NC3_INFOncp, const NC_var *varp,
#1496 off_t offset = NC_varoffset(ncpvarpstart);
#1508 size_t extent = MIN(remainingncp->chunk);
#1511 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1523 (void) ncio_rel(ncp->nciopoffset,
#1538putNCvx_short_float(NC3_INFOncp, const NC_var *varp,
#1541 off_t offset = NC_varoffset(ncpvarpstart);
#1553 size_t extent = MIN(remainingncp->chunk);
#1556 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1568 (void) ncio_rel(ncp->nciopoffset,
#1583putNCvx_short_double(NC3_INFOncp, const NC_var *varp,
#1586 off_t offset = NC_varoffset(ncpvarpstart);
#1598 size_t extent = MIN(remainingncp->chunk);
#1601 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1613 (void) ncio_rel(ncp->nciopoffset,
#1628putNCvx_short_longlong(NC3_INFOncp, const NC_var *varp,
#1631 off_t offset = NC_varoffset(ncpvarpstart);
#1643 size_t extent = MIN(remainingncp->chunk);
#1646 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1658 (void) ncio_rel(ncp->nciopoffset,
#1673putNCvx_short_ushort(NC3_INFOncp, const NC_var *varp,
#1676 off_t offset = NC_varoffset(ncpvarpstart);
#1688 size_t extent = MIN(remainingncp->chunk);
#1691 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1703 (void) ncio_rel(ncp->nciopoffset,
#1718putNCvx_short_uint(NC3_INFOncp, const NC_var *varp,
#1721 off_t offset = NC_varoffset(ncpvarpstart);
#1733 size_t extent = MIN(remainingncp->chunk);
#1736 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1748 (void) ncio_rel(ncp->nciopoffset,
#1763putNCvx_short_ulonglong(NC3_INFOncp, const NC_var *varp,
#1766 off_t offset = NC_varoffset(ncpvarpstart);
#1778 size_t extent = MIN(remainingncp->chunk);
#1781 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1793 (void) ncio_rel(ncp->nciopoffset,
#1809putNCvx_int_schar(NC3_INFOncp, const NC_var *varp,
#1812 off_t offset = NC_varoffset(ncpvarpstart);
#1824 size_t extent = MIN(remainingncp->chunk);
#1827 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1839 (void) ncio_rel(ncp->nciopoffset,
#1854putNCvx_int_uchar(NC3_INFOncp, const NC_var *varp,
#1857 off_t offset = NC_varoffset(ncpvarpstart);
#1869 size_t extent = MIN(remainingncp->chunk);
#1872 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1884 (void) ncio_rel(ncp->nciopoffset,
#1899putNCvx_int_short(NC3_INFOncp, const NC_var *varp,
#1902 off_t offset = NC_varoffset(ncpvarpstart);
#1914 size_t extent = MIN(remainingncp->chunk);
#1917 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1929 (void) ncio_rel(ncp->nciopoffset,
#1944putNCvx_int_int(NC3_INFOncp, const NC_var *varp,
#1947 off_t offset = NC_varoffset(ncpvarpstart);
#1959 size_t extent = MIN(remainingncp->chunk);
#1962 int lstatus = ncio_get(ncp->nciopoffsetextent,
#1974 (void) ncio_rel(ncp->nciopoffset,
#1989putNCvx_int_float(NC3_INFOncp, const NC_var *varp,
#1992 off_t offset = NC_varoffset(ncpvarpstart);
#2004 size_t extent = MIN(remainingncp->chunk);
#2007 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2019 (void) ncio_rel(ncp->nciopoffset,
#2034putNCvx_int_double(NC3_INFOncp, const NC_var *varp,
#2037 off_t offset = NC_varoffset(ncpvarpstart);
#2049 size_t extent = MIN(remainingncp->chunk);
#2052 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2064 (void) ncio_rel(ncp->nciopoffset,
#2079putNCvx_int_longlong(NC3_INFOncp, const NC_var *varp,
#2082 off_t offset = NC_varoffset(ncpvarpstart);
#2094 size_t extent = MIN(remainingncp->chunk);
#2097 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2109 (void) ncio_rel(ncp->nciopoffset,
#2124putNCvx_int_ushort(NC3_INFOncp, const NC_var *varp,
#2127 off_t offset = NC_varoffset(ncpvarpstart);
#2139 size_t extent = MIN(remainingncp->chunk);
#2142 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2154 (void) ncio_rel(ncp->nciopoffset,
#2169putNCvx_int_uint(NC3_INFOncp, const NC_var *varp,
#2172 off_t offset = NC_varoffset(ncpvarpstart);
#2184 size_t extent = MIN(remainingncp->chunk);
#2187 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2199 (void) ncio_rel(ncp->nciopoffset,
#2214putNCvx_int_ulonglong(NC3_INFOncp, const NC_var *varp,
#2217 off_t offset = NC_varoffset(ncpvarpstart);
#2229 size_t extent = MIN(remainingncp->chunk);
#2232 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2244 (void) ncio_rel(ncp->nciopoffset,
#2260putNCvx_float_schar(NC3_INFOncp, const NC_var *varp,
#2263 off_t offset = NC_varoffset(ncpvarpstart);
#2275 size_t extent = MIN(remainingncp->chunk);
#2278 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2290 (void) ncio_rel(ncp->nciopoffset,
#2305putNCvx_float_uchar(NC3_INFOncp, const NC_var *varp,
#2308 off_t offset = NC_varoffset(ncpvarpstart);
#2320 size_t extent = MIN(remainingncp->chunk);
#2323 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2335 (void) ncio_rel(ncp->nciopoffset,
#2350putNCvx_float_short(NC3_INFOncp, const NC_var *varp,
#2353 off_t offset = NC_varoffset(ncpvarpstart);
#2365 size_t extent = MIN(remainingncp->chunk);
#2368 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2380 (void) ncio_rel(ncp->nciopoffset,
#2395putNCvx_float_int(NC3_INFOncp, const NC_var *varp,
#2398 off_t offset = NC_varoffset(ncpvarpstart);
#2410 size_t extent = MIN(remainingncp->chunk);
#2413 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2425 (void) ncio_rel(ncp->nciopoffset,
#2440putNCvx_float_float(NC3_INFOncp, const NC_var *varp,
#2443 off_t offset = NC_varoffset(ncpvarpstart);
#2455 size_t extent = MIN(remainingncp->chunk);
#2458 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2470 (void) ncio_rel(ncp->nciopoffset,
#2485putNCvx_float_double(NC3_INFOncp, const NC_var *varp,
#2488 off_t offset = NC_varoffset(ncpvarpstart);
#2500 size_t extent = MIN(remainingncp->chunk);
#2503 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2515 (void) ncio_rel(ncp->nciopoffset,
#2530putNCvx_float_longlong(NC3_INFOncp, const NC_var *varp,
#2533 off_t offset = NC_varoffset(ncpvarpstart);
#2545 size_t extent = MIN(remainingncp->chunk);
#2548 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2560 (void) ncio_rel(ncp->nciopoffset,
#2575putNCvx_float_ushort(NC3_INFOncp, const NC_var *varp,
#2578 off_t offset = NC_varoffset(ncpvarpstart);
#2590 size_t extent = MIN(remainingncp->chunk);
#2593 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2605 (void) ncio_rel(ncp->nciopoffset,
#2620putNCvx_float_uint(NC3_INFOncp, const NC_var *varp,
#2623 off_t offset = NC_varoffset(ncpvarpstart);
#2635 size_t extent = MIN(remainingncp->chunk);
#2638 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2650 (void) ncio_rel(ncp->nciopoffset,
#2665putNCvx_float_ulonglong(NC3_INFOncp, const NC_var *varp,
#2668 off_t offset = NC_varoffset(ncpvarpstart);
#2680 size_t extent = MIN(remainingncp->chunk);
#2683 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2695 (void) ncio_rel(ncp->nciopoffset,
#2711putNCvx_double_schar(NC3_INFOncp, const NC_var *varp,
#2714 off_t offset = NC_varoffset(ncpvarpstart);
#2726 size_t extent = MIN(remainingncp->chunk);
#2729 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2741 (void) ncio_rel(ncp->nciopoffset,
#2756putNCvx_double_uchar(NC3_INFOncp, const NC_var *varp,
#2759 off_t offset = NC_varoffset(ncpvarpstart);
#2771 size_t extent = MIN(remainingncp->chunk);
#2774 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2786 (void) ncio_rel(ncp->nciopoffset,
#2801putNCvx_double_short(NC3_INFOncp, const NC_var *varp,
#2804 off_t offset = NC_varoffset(ncpvarpstart);
#2816 size_t extent = MIN(remainingncp->chunk);
#2819 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2831 (void) ncio_rel(ncp->nciopoffset,
#2846putNCvx_double_int(NC3_INFOncp, const NC_var *varp,
#2849 off_t offset = NC_varoffset(ncpvarpstart);
#2861 size_t extent = MIN(remainingncp->chunk);
#2864 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2876 (void) ncio_rel(ncp->nciopoffset,
#2891putNCvx_double_float(NC3_INFOncp, const NC_var *varp,
#2894 off_t offset = NC_varoffset(ncpvarpstart);
#2906 size_t extent = MIN(remainingncp->chunk);
#2909 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2921 (void) ncio_rel(ncp->nciopoffset,
#2936putNCvx_double_double(NC3_INFOncp, const NC_var *varp,
#2939 off_t offset = NC_varoffset(ncpvarpstart);
#2951 size_t extent = MIN(remainingncp->chunk);
#2954 int lstatus = ncio_get(ncp->nciopoffsetextent,
#2966 (void) ncio_rel(ncp->nciopoffset,
#2981putNCvx_double_longlong(NC3_INFOncp, const NC_var *varp,
#2984 off_t offset = NC_varoffset(ncpvarpstart);
#2996 size_t extent = MIN(remainingncp->chunk);
#2999 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3011 (void) ncio_rel(ncp->nciopoffset,
#3026putNCvx_double_ushort(NC3_INFOncp, const NC_var *varp,
#3029 off_t offset = NC_varoffset(ncpvarpstart);
#3041 size_t extent = MIN(remainingncp->chunk);
#3044 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3056 (void) ncio_rel(ncp->nciopoffset,
#3071putNCvx_double_uint(NC3_INFOncp, const NC_var *varp,
#3074 off_t offset = NC_varoffset(ncpvarpstart);
#3086 size_t extent = MIN(remainingncp->chunk);
#3089 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3101 (void) ncio_rel(ncp->nciopoffset,
#3116putNCvx_double_ulonglong(NC3_INFOncp, const NC_var *varp,
#3119 off_t offset = NC_varoffset(ncpvarpstart);
#3131 size_t extent = MIN(remainingncp->chunk);
#3134 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3146 (void) ncio_rel(ncp->nciopoffset,
#3162putNCvx_uchar_schar(NC3_INFOncp, const NC_var *varp,
#3165 off_t offset = NC_varoffset(ncpvarpstart);
#3177 size_t extent = MIN(remainingncp->chunk);
#3180 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3192 (void) ncio_rel(ncp->nciopoffset,
#3207putNCvx_uchar_uchar(NC3_INFOncp, const NC_var *varp,
#3210 off_t offset = NC_varoffset(ncpvarpstart);
#3222 size_t extent = MIN(remainingncp->chunk);
#3225 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3237 (void) ncio_rel(ncp->nciopoffset,
#3252putNCvx_uchar_short(NC3_INFOncp, const NC_var *varp,
#3255 off_t offset = NC_varoffset(ncpvarpstart);
#3267 size_t extent = MIN(remainingncp->chunk);
#3270 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3282 (void) ncio_rel(ncp->nciopoffset,
#3297putNCvx_uchar_int(NC3_INFOncp, const NC_var *varp,
#3300 off_t offset = NC_varoffset(ncpvarpstart);
#3312 size_t extent = MIN(remainingncp->chunk);
#3315 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3327 (void) ncio_rel(ncp->nciopoffset,
#3342putNCvx_uchar_float(NC3_INFOncp, const NC_var *varp,
#3345 off_t offset = NC_varoffset(ncpvarpstart);
#3357 size_t extent = MIN(remainingncp->chunk);
#3360 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3372 (void) ncio_rel(ncp->nciopoffset,
#3387putNCvx_uchar_double(NC3_INFOncp, const NC_var *varp,
#3390 off_t offset = NC_varoffset(ncpvarpstart);
#3402 size_t extent = MIN(remainingncp->chunk);
#3405 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3417 (void) ncio_rel(ncp->nciopoffset,
#3432putNCvx_uchar_longlong(NC3_INFOncp, const NC_var *varp,
#3435 off_t offset = NC_varoffset(ncpvarpstart);
#3447 size_t extent = MIN(remainingncp->chunk);
#3450 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3462 (void) ncio_rel(ncp->nciopoffset,
#3477putNCvx_uchar_ushort(NC3_INFOncp, const NC_var *varp,
#3480 off_t offset = NC_varoffset(ncpvarpstart);
#3492 size_t extent = MIN(remainingncp->chunk);
#3495 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3507 (void) ncio_rel(ncp->nciopoffset,
#3522putNCvx_uchar_uint(NC3_INFOncp, const NC_var *varp,
#3525 off_t offset = NC_varoffset(ncpvarpstart);
#3537 size_t extent = MIN(remainingncp->chunk);
#3540 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3552 (void) ncio_rel(ncp->nciopoffset,
#3567putNCvx_uchar_ulonglong(NC3_INFOncp, const NC_var *varp,
#3570 off_t offset = NC_varoffset(ncpvarpstart);
#3582 size_t extent = MIN(remainingncp->chunk);
#3585 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3597 (void) ncio_rel(ncp->nciopoffset,
#3613putNCvx_ushort_schar(NC3_INFOncp, const NC_var *varp,
#3616 off_t offset = NC_varoffset(ncpvarpstart);
#3628 size_t extent = MIN(remainingncp->chunk);
#3631 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3643 (void) ncio_rel(ncp->nciopoffset,
#3658putNCvx_ushort_uchar(NC3_INFOncp, const NC_var *varp,
#3661 off_t offset = NC_varoffset(ncpvarpstart);
#3673 size_t extent = MIN(remainingncp->chunk);
#3676 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3688 (void) ncio_rel(ncp->nciopoffset,
#3703putNCvx_ushort_short(NC3_INFOncp, const NC_var *varp,
#3706 off_t offset = NC_varoffset(ncpvarpstart);
#3718 size_t extent = MIN(remainingncp->chunk);
#3721 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3733 (void) ncio_rel(ncp->nciopoffset,
#3748putNCvx_ushort_int(NC3_INFOncp, const NC_var *varp,
#3751 off_t offset = NC_varoffset(ncpvarpstart);
#3763 size_t extent = MIN(remainingncp->chunk);
#3766 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3778 (void) ncio_rel(ncp->nciopoffset,
#3793putNCvx_ushort_float(NC3_INFOncp, const NC_var *varp,
#3796 off_t offset = NC_varoffset(ncpvarpstart);
#3808 size_t extent = MIN(remainingncp->chunk);
#3811 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3823 (void) ncio_rel(ncp->nciopoffset,
#3838putNCvx_ushort_double(NC3_INFOncp, const NC_var *varp,
#3841 off_t offset = NC_varoffset(ncpvarpstart);
#3853 size_t extent = MIN(remainingncp->chunk);
#3856 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3868 (void) ncio_rel(ncp->nciopoffset,
#3883putNCvx_ushort_longlong(NC3_INFOncp, const NC_var *varp,
#3886 off_t offset = NC_varoffset(ncpvarpstart);
#3898 size_t extent = MIN(remainingncp->chunk);
#3901 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3913 (void) ncio_rel(ncp->nciopoffset,
#3928putNCvx_ushort_ushort(NC3_INFOncp, const NC_var *varp,
#3931 off_t offset = NC_varoffset(ncpvarpstart);
#3943 size_t extent = MIN(remainingncp->chunk);
#3946 int lstatus = ncio_get(ncp->nciopoffsetextent,
#3958 (void) ncio_rel(ncp->nciopoffset,
#3973putNCvx_ushort_uint(NC3_INFOncp, const NC_var *varp,
#3976 off_t offset = NC_varoffset(ncpvarpstart);
#3988 size_t extent = MIN(remainingncp->chunk);
#3991 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4003 (void) ncio_rel(ncp->nciopoffset,
#4018putNCvx_ushort_ulonglong(NC3_INFOncp, const NC_var *varp,
#4021 off_t offset = NC_varoffset(ncpvarpstart);
#4033 size_t extent = MIN(remainingncp->chunk);
#4036 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4048 (void) ncio_rel(ncp->nciopoffset,
#4064putNCvx_uint_schar(NC3_INFOncp, const NC_var *varp,
#4067 off_t offset = NC_varoffset(ncpvarpstart);
#4079 size_t extent = MIN(remainingncp->chunk);
#4082 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4094 (void) ncio_rel(ncp->nciopoffset,
#4109putNCvx_uint_uchar(NC3_INFOncp, const NC_var *varp,
#4112 off_t offset = NC_varoffset(ncpvarpstart);
#4124 size_t extent = MIN(remainingncp->chunk);
#4127 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4139 (void) ncio_rel(ncp->nciopoffset,
#4154putNCvx_uint_short(NC3_INFOncp, const NC_var *varp,
#4157 off_t offset = NC_varoffset(ncpvarpstart);
#4169 size_t extent = MIN(remainingncp->chunk);
#4172 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4184 (void) ncio_rel(ncp->nciopoffset,
#4199putNCvx_uint_int(NC3_INFOncp, const NC_var *varp,
#4202 off_t offset = NC_varoffset(ncpvarpstart);
#4214 size_t extent = MIN(remainingncp->chunk);
#4217 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4229 (void) ncio_rel(ncp->nciopoffset,
#4244putNCvx_uint_float(NC3_INFOncp, const NC_var *varp,
#4247 off_t offset = NC_varoffset(ncpvarpstart);
#4259 size_t extent = MIN(remainingncp->chunk);
#4262 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4274 (void) ncio_rel(ncp->nciopoffset,
#4289putNCvx_uint_double(NC3_INFOncp, const NC_var *varp,
#4292 off_t offset = NC_varoffset(ncpvarpstart);
#4304 size_t extent = MIN(remainingncp->chunk);
#4307 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4319 (void) ncio_rel(ncp->nciopoffset,
#4334putNCvx_uint_longlong(NC3_INFOncp, const NC_var *varp,
#4337 off_t offset = NC_varoffset(ncpvarpstart);
#4349 size_t extent = MIN(remainingncp->chunk);
#4352 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4364 (void) ncio_rel(ncp->nciopoffset,
#4379putNCvx_uint_ushort(NC3_INFOncp, const NC_var *varp,
#4382 off_t offset = NC_varoffset(ncpvarpstart);
#4394 size_t extent = MIN(remainingncp->chunk);
#4397 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4409 (void) ncio_rel(ncp->nciopoffset,
#4424putNCvx_uint_uint(NC3_INFOncp, const NC_var *varp,
#4427 off_t offset = NC_varoffset(ncpvarpstart);
#4439 size_t extent = MIN(remainingncp->chunk);
#4442 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4454 (void) ncio_rel(ncp->nciopoffset,
#4469putNCvx_uint_ulonglong(NC3_INFOncp, const NC_var *varp,
#4472 off_t offset = NC_varoffset(ncpvarpstart);
#4484 size_t extent = MIN(remainingncp->chunk);
#4487 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4499 (void) ncio_rel(ncp->nciopoffset,
#4515putNCvx_longlong_schar(NC3_INFOncp, const NC_var *varp,
#4518 off_t offset = NC_varoffset(ncpvarpstart);
#4530 size_t extent = MIN(remainingncp->chunk);
#4533 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4545 (void) ncio_rel(ncp->nciopoffset,
#4560putNCvx_longlong_uchar(NC3_INFOncp, const NC_var *varp,
#4563 off_t offset = NC_varoffset(ncpvarpstart);
#4575 size_t extent = MIN(remainingncp->chunk);
#4578 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4590 (void) ncio_rel(ncp->nciopoffset,
#4605putNCvx_longlong_short(NC3_INFOncp, const NC_var *varp,
#4608 off_t offset = NC_varoffset(ncpvarpstart);
#4620 size_t extent = MIN(remainingncp->chunk);
#4623 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4635 (void) ncio_rel(ncp->nciopoffset,
#4650putNCvx_longlong_int(NC3_INFOncp, const NC_var *varp,
#4653 off_t offset = NC_varoffset(ncpvarpstart);
#4665 size_t extent = MIN(remainingncp->chunk);
#4668 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4680 (void) ncio_rel(ncp->nciopoffset,
#4695putNCvx_longlong_float(NC3_INFOncp, const NC_var *varp,
#4698 off_t offset = NC_varoffset(ncpvarpstart);
#4710 size_t extent = MIN(remainingncp->chunk);
#4713 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4725 (void) ncio_rel(ncp->nciopoffset,
#4740putNCvx_longlong_double(NC3_INFOncp, const NC_var *varp,
#4743 off_t offset = NC_varoffset(ncpvarpstart);
#4755 size_t extent = MIN(remainingncp->chunk);
#4758 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4770 (void) ncio_rel(ncp->nciopoffset,
#4785putNCvx_longlong_longlong(NC3_INFOncp, const NC_var *varp,
#4788 off_t offset = NC_varoffset(ncpvarpstart);
#4800 size_t extent = MIN(remainingncp->chunk);
#4803 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4815 (void) ncio_rel(ncp->nciopoffset,
#4830putNCvx_longlong_ushort(NC3_INFOncp, const NC_var *varp,
#4833 off_t offset = NC_varoffset(ncpvarpstart);
#4845 size_t extent = MIN(remainingncp->chunk);
#4848 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4860 (void) ncio_rel(ncp->nciopoffset,
#4875putNCvx_longlong_uint(NC3_INFOncp, const NC_var *varp,
#4878 off_t offset = NC_varoffset(ncpvarpstart);
#4890 size_t extent = MIN(remainingncp->chunk);
#4893 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4905 (void) ncio_rel(ncp->nciopoffset,
#4920putNCvx_longlong_ulonglong(NC3_INFOncp, const NC_var *varp,
#4923 off_t offset = NC_varoffset(ncpvarpstart);
#4935 size_t extent = MIN(remainingncp->chunk);
#4938 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4950 (void) ncio_rel(ncp->nciopoffset,
#4966putNCvx_ulonglong_schar(NC3_INFOncp, const NC_var *varp,
#4969 off_t offset = NC_varoffset(ncpvarpstart);
#4981 size_t extent = MIN(remainingncp->chunk);
#4984 int lstatus = ncio_get(ncp->nciopoffsetextent,
#4996 (void) ncio_rel(ncp->nciopoffset,
#5011putNCvx_ulonglong_uchar(NC3_INFOncp, const NC_var *varp,
#5014 off_t offset = NC_varoffset(ncpvarpstart);
#5026 size_t extent = MIN(remainingncp->chunk);
#5029 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5041 (void) ncio_rel(ncp->nciopoffset,
#5056putNCvx_ulonglong_short(NC3_INFOncp, const NC_var *varp,
#5059 off_t offset = NC_varoffset(ncpvarpstart);
#5071 size_t extent = MIN(remainingncp->chunk);
#5074 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5086 (void) ncio_rel(ncp->nciopoffset,
#5101putNCvx_ulonglong_int(NC3_INFOncp, const NC_var *varp,
#5104 off_t offset = NC_varoffset(ncpvarpstart);
#5116 size_t extent = MIN(remainingncp->chunk);
#5119 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5131 (void) ncio_rel(ncp->nciopoffset,
#5146putNCvx_ulonglong_float(NC3_INFOncp, const NC_var *varp,
#5149 off_t offset = NC_varoffset(ncpvarpstart);
#5161 size_t extent = MIN(remainingncp->chunk);
#5164 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5176 (void) ncio_rel(ncp->nciopoffset,
#5191putNCvx_ulonglong_double(NC3_INFOncp, const NC_var *varp,
#5194 off_t offset = NC_varoffset(ncpvarpstart);
#5206 size_t extent = MIN(remainingncp->chunk);
#5209 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5221 (void) ncio_rel(ncp->nciopoffset,
#5236putNCvx_ulonglong_longlong(NC3_INFOncp, const NC_var *varp,
#5239 off_t offset = NC_varoffset(ncpvarpstart);
#5251 size_t extent = MIN(remainingncp->chunk);
#5254 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5266 (void) ncio_rel(ncp->nciopoffset,
#5281putNCvx_ulonglong_ushort(NC3_INFOncp, const NC_var *varp,
#5284 off_t offset = NC_varoffset(ncpvarpstart);
#5296 size_t extent = MIN(remainingncp->chunk);
#5299 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5311 (void) ncio_rel(ncp->nciopoffset,
#5326putNCvx_ulonglong_uint(NC3_INFOncp, const NC_var *varp,
#5329 off_t offset = NC_varoffset(ncpvarpstart);
#5341 size_t extent = MIN(remainingncp->chunk);
#5344 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5356 (void) ncio_rel(ncp->nciopoffset,
#5371putNCvx_ulonglong_ulonglong(NC3_INFOncp, const NC_var *varp,
#5374 off_t offset = NC_varoffset(ncpvarpstart);
#5386 size_t extent = MIN(remainingncp->chunk);
#5389 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5401 (void) ncio_rel(ncp->nciopoffset,
#5418getNCvx_char_char(const NC3_INFOncp, const NC_var *varp,
#5421 off_t offset = NC_varoffset(ncpvarpstart);
#5433 size_t extent = MIN(remainingncp->chunk);
#5436 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5445 (void) ncio_rel(ncp->nciopoffset, 0);
#5459getNCvx_schar_schar(const NC3_INFOncp, const NC_var *varp,
#5462 off_t offset = NC_varoffset(ncpvarpstart);
#5474 size_t extent = MIN(remainingncp->chunk);
#5477 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5486 (void) ncio_rel(ncp->nciopoffset, 0);
#5499getNCvx_schar_short(const NC3_INFOncp, const NC_var *varp,
#5502 off_t offset = NC_varoffset(ncpvarpstart);
#5514 size_t extent = MIN(remainingncp->chunk);
#5517 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5526 (void) ncio_rel(ncp->nciopoffset, 0);
#5539getNCvx_schar_int(const NC3_INFOncp, const NC_var *varp,
#5542 off_t offset = NC_varoffset(ncpvarpstart);
#5554 size_t extent = MIN(remainingncp->chunk);
#5557 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5566 (void) ncio_rel(ncp->nciopoffset, 0);
#5579getNCvx_schar_float(const NC3_INFOncp, const NC_var *varp,
#5582 off_t offset = NC_varoffset(ncpvarpstart);
#5594 size_t extent = MIN(remainingncp->chunk);
#5597 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5606 (void) ncio_rel(ncp->nciopoffset, 0);
#5619getNCvx_schar_double(const NC3_INFOncp, const NC_var *varp,
#5622 off_t offset = NC_varoffset(ncpvarpstart);
#5634 size_t extent = MIN(remainingncp->chunk);
#5637 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5646 (void) ncio_rel(ncp->nciopoffset, 0);
#5659getNCvx_schar_longlong(const NC3_INFOncp, const NC_var *varp,
#5662 off_t offset = NC_varoffset(ncpvarpstart);
#5674 size_t extent = MIN(remainingncp->chunk);
#5677 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5686 (void) ncio_rel(ncp->nciopoffset, 0);
#5699getNCvx_schar_uint(const NC3_INFOncp, const NC_var *varp,
#5702 off_t offset = NC_varoffset(ncpvarpstart);
#5714 size_t extent = MIN(remainingncp->chunk);
#5717 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5726 (void) ncio_rel(ncp->nciopoffset, 0);
#5739getNCvx_schar_ulonglong(const NC3_INFOncp, const NC_var *varp,
#5742 off_t offset = NC_varoffset(ncpvarpstart);
#5754 size_t extent = MIN(remainingncp->chunk);
#5757 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5766 (void) ncio_rel(ncp->nciopoffset, 0);
#5779getNCvx_schar_uchar(const NC3_INFOncp, const NC_var *varp,
#5782 off_t offset = NC_varoffset(ncpvarpstart);
#5794 size_t extent = MIN(remainingncp->chunk);
#5797 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5806 (void) ncio_rel(ncp->nciopoffset, 0);
#5819getNCvx_schar_ushort(const NC3_INFOncp, const NC_var *varp,
#5822 off_t offset = NC_varoffset(ncpvarpstart);
#5834 size_t extent = MIN(remainingncp->chunk);
#5837 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5846 (void) ncio_rel(ncp->nciopoffset, 0);
#5860getNCvx_short_schar(const NC3_INFOncp, const NC_var *varp,
#5863 off_t offset = NC_varoffset(ncpvarpstart);
#5875 size_t extent = MIN(remainingncp->chunk);
#5878 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5887 (void) ncio_rel(ncp->nciopoffset, 0);
#5900getNCvx_short_uchar(const NC3_INFOncp, const NC_var *varp,
#5903 off_t offset = NC_varoffset(ncpvarpstart);
#5915 size_t extent = MIN(remainingncp->chunk);
#5918 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5927 (void) ncio_rel(ncp->nciopoffset, 0);
#5940getNCvx_short_short(const NC3_INFOncp, const NC_var *varp,
#5943 off_t offset = NC_varoffset(ncpvarpstart);
#5955 size_t extent = MIN(remainingncp->chunk);
#5958 int lstatus = ncio_get(ncp->nciopoffsetextent,
#5967 (void) ncio_rel(ncp->nciopoffset, 0);
#5980getNCvx_short_int(const NC3_INFOncp, const NC_var *varp,
#5983 off_t offset = NC_varoffset(ncpvarpstart);
#5995 size_t extent = MIN(remainingncp->chunk);
#5998 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6007 (void) ncio_rel(ncp->nciopoffset, 0);
#6020getNCvx_short_float(const NC3_INFOncp, const NC_var *varp,
#6023 off_t offset = NC_varoffset(ncpvarpstart);
#6035 size_t extent = MIN(remainingncp->chunk);
#6038 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6047 (void) ncio_rel(ncp->nciopoffset, 0);
#6060getNCvx_short_double(const NC3_INFOncp, const NC_var *varp,
#6063 off_t offset = NC_varoffset(ncpvarpstart);
#6075 size_t extent = MIN(remainingncp->chunk);
#6078 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6087 (void) ncio_rel(ncp->nciopoffset, 0);
#6100getNCvx_short_longlong(const NC3_INFOncp, const NC_var *varp,
#6103 off_t offset = NC_varoffset(ncpvarpstart);
#6115 size_t extent = MIN(remainingncp->chunk);
#6118 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6127 (void) ncio_rel(ncp->nciopoffset, 0);
#6140getNCvx_short_uint(const NC3_INFOncp, const NC_var *varp,
#6143 off_t offset = NC_varoffset(ncpvarpstart);
#6155 size_t extent = MIN(remainingncp->chunk);
#6158 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6167 (void) ncio_rel(ncp->nciopoffset, 0);
#6180getNCvx_short_ulonglong(const NC3_INFOncp, const NC_var *varp,
#6183 off_t offset = NC_varoffset(ncpvarpstart);
#6195 size_t extent = MIN(remainingncp->chunk);
#6198 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6207 (void) ncio_rel(ncp->nciopoffset, 0);
#6220getNCvx_short_ushort(const NC3_INFOncp, const NC_var *varp,
#6223 off_t offset = NC_varoffset(ncpvarpstart);
#6235 size_t extent = MIN(remainingncp->chunk);
#6238 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6247 (void) ncio_rel(ncp->nciopoffset, 0);
#6261getNCvx_int_schar(const NC3_INFOncp, const NC_var *varp,
#6264 off_t offset = NC_varoffset(ncpvarpstart);
#6276 size_t extent = MIN(remainingncp->chunk);
#6279 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6288 (void) ncio_rel(ncp->nciopoffset, 0);
#6301getNCvx_int_uchar(const NC3_INFOncp, const NC_var *varp,
#6304 off_t offset = NC_varoffset(ncpvarpstart);
#6316 size_t extent = MIN(remainingncp->chunk);
#6319 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6328 (void) ncio_rel(ncp->nciopoffset, 0);
#6341getNCvx_int_short(const NC3_INFOncp, const NC_var *varp,
#6344 off_t offset = NC_varoffset(ncpvarpstart);
#6356 size_t extent = MIN(remainingncp->chunk);
#6359 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6368 (void) ncio_rel(ncp->nciopoffset, 0);
#6381getNCvx_int_int(const NC3_INFOncp, const NC_var *varp,
#6384 off_t offset = NC_varoffset(ncpvarpstart);
#6396 size_t extent = MIN(remainingncp->chunk);
#6399 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6408 (void) ncio_rel(ncp->nciopoffset, 0);
#6421getNCvx_int_float(const NC3_INFOncp, const NC_var *varp,
#6424 off_t offset = NC_varoffset(ncpvarpstart);
#6436 size_t extent = MIN(remainingncp->chunk);
#6439 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6448 (void) ncio_rel(ncp->nciopoffset, 0);
#6461getNCvx_int_double(const NC3_INFOncp, const NC_var *varp,
#6464 off_t offset = NC_varoffset(ncpvarpstart);
#6476 size_t extent = MIN(remainingncp->chunk);
#6479 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6488 (void) ncio_rel(ncp->nciopoffset, 0);
#6501getNCvx_int_longlong(const NC3_INFOncp, const NC_var *varp,
#6504 off_t offset = NC_varoffset(ncpvarpstart);
#6516 size_t extent = MIN(remainingncp->chunk);
#6519 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6528 (void) ncio_rel(ncp->nciopoffset, 0);
#6541getNCvx_int_uint(const NC3_INFOncp, const NC_var *varp,
#6544 off_t offset = NC_varoffset(ncpvarpstart);
#6556 size_t extent = MIN(remainingncp->chunk);
#6559 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6568 (void) ncio_rel(ncp->nciopoffset, 0);
#6581getNCvx_int_ulonglong(const NC3_INFOncp, const NC_var *varp,
#6584 off_t offset = NC_varoffset(ncpvarpstart);
#6596 size_t extent = MIN(remainingncp->chunk);
#6599 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6608 (void) ncio_rel(ncp->nciopoffset, 0);
#6621getNCvx_int_ushort(const NC3_INFOncp, const NC_var *varp,
#6624 off_t offset = NC_varoffset(ncpvarpstart);
#6636 size_t extent = MIN(remainingncp->chunk);
#6639 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6648 (void) ncio_rel(ncp->nciopoffset, 0);
#6662getNCvx_float_schar(const NC3_INFOncp, const NC_var *varp,
#6665 off_t offset = NC_varoffset(ncpvarpstart);
#6677 size_t extent = MIN(remainingncp->chunk);
#6680 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6689 (void) ncio_rel(ncp->nciopoffset, 0);
#6702getNCvx_float_uchar(const NC3_INFOncp, const NC_var *varp,
#6705 off_t offset = NC_varoffset(ncpvarpstart);
#6717 size_t extent = MIN(remainingncp->chunk);
#6720 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6729 (void) ncio_rel(ncp->nciopoffset, 0);
#6742getNCvx_float_short(const NC3_INFOncp, const NC_var *varp,
#6745 off_t offset = NC_varoffset(ncpvarpstart);
#6757 size_t extent = MIN(remainingncp->chunk);
#6760 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6769 (void) ncio_rel(ncp->nciopoffset, 0);
#6782getNCvx_float_int(const NC3_INFOncp, const NC_var *varp,
#6785 off_t offset = NC_varoffset(ncpvarpstart);
#6797 size_t extent = MIN(remainingncp->chunk);
#6800 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6809 (void) ncio_rel(ncp->nciopoffset, 0);
#6822getNCvx_float_float(const NC3_INFOncp, const NC_var *varp,
#6825 off_t offset = NC_varoffset(ncpvarpstart);
#6837 size_t extent = MIN(remainingncp->chunk);
#6840 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6849 (void) ncio_rel(ncp->nciopoffset, 0);
#6862getNCvx_float_double(const NC3_INFOncp, const NC_var *varp,
#6865 off_t offset = NC_varoffset(ncpvarpstart);
#6877 size_t extent = MIN(remainingncp->chunk);
#6880 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6889 (void) ncio_rel(ncp->nciopoffset, 0);
#6902getNCvx_float_longlong(const NC3_INFOncp, const NC_var *varp,
#6905 off_t offset = NC_varoffset(ncpvarpstart);
#6917 size_t extent = MIN(remainingncp->chunk);
#6920 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6929 (void) ncio_rel(ncp->nciopoffset, 0);
#6942getNCvx_float_uint(const NC3_INFOncp, const NC_var *varp,
#6945 off_t offset = NC_varoffset(ncpvarpstart);
#6957 size_t extent = MIN(remainingncp->chunk);
#6960 int lstatus = ncio_get(ncp->nciopoffsetextent,
#6969 (void) ncio_rel(ncp->nciopoffset, 0);
#6982getNCvx_float_ulonglong(const NC3_INFOncp, const NC_var *varp,
#6985 off_t offset = NC_varoffset(ncpvarpstart);
#6997 size_t extent = MIN(remainingncp->chunk);
#7000 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7009 (void) ncio_rel(ncp->nciopoffset, 0);
#7022getNCvx_float_ushort(const NC3_INFOncp, const NC_var *varp,
#7025 off_t offset = NC_varoffset(ncpvarpstart);
#7037 size_t extent = MIN(remainingncp->chunk);
#7040 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7049 (void) ncio_rel(ncp->nciopoffset, 0);
#7063getNCvx_double_schar(const NC3_INFOncp, const NC_var *varp,
#7066 off_t offset = NC_varoffset(ncpvarpstart);
#7078 size_t extent = MIN(remainingncp->chunk);
#7081 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7090 (void) ncio_rel(ncp->nciopoffset, 0);
#7103getNCvx_double_uchar(const NC3_INFOncp, const NC_var *varp,
#7106 off_t offset = NC_varoffset(ncpvarpstart);
#7118 size_t extent = MIN(remainingncp->chunk);
#7121 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7130 (void) ncio_rel(ncp->nciopoffset, 0);
#7143getNCvx_double_short(const NC3_INFOncp, const NC_var *varp,
#7146 off_t offset = NC_varoffset(ncpvarpstart);
#7158 size_t extent = MIN(remainingncp->chunk);
#7161 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7170 (void) ncio_rel(ncp->nciopoffset, 0);
#7183getNCvx_double_int(const NC3_INFOncp, const NC_var *varp,
#7186 off_t offset = NC_varoffset(ncpvarpstart);
#7198 size_t extent = MIN(remainingncp->chunk);
#7201 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7210 (void) ncio_rel(ncp->nciopoffset, 0);
#7223getNCvx_double_float(const NC3_INFOncp, const NC_var *varp,
#7226 off_t offset = NC_varoffset(ncpvarpstart);
#7238 size_t extent = MIN(remainingncp->chunk);
#7241 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7250 (void) ncio_rel(ncp->nciopoffset, 0);
#7263getNCvx_double_double(const NC3_INFOncp, const NC_var *varp,
#7266 off_t offset = NC_varoffset(ncpvarpstart);
#7278 size_t extent = MIN(remainingncp->chunk);
#7281 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7290 (void) ncio_rel(ncp->nciopoffset, 0);
#7303getNCvx_double_longlong(const NC3_INFOncp, const NC_var *varp,
#7306 off_t offset = NC_varoffset(ncpvarpstart);
#7318 size_t extent = MIN(remainingncp->chunk);
#7321 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7330 (void) ncio_rel(ncp->nciopoffset, 0);
#7343getNCvx_double_uint(const NC3_INFOncp, const NC_var *varp,
#7346 off_t offset = NC_varoffset(ncpvarpstart);
#7358 size_t extent = MIN(remainingncp->chunk);
#7361 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7370 (void) ncio_rel(ncp->nciopoffset, 0);
#7383getNCvx_double_ulonglong(const NC3_INFOncp, const NC_var *varp,
#7386 off_t offset = NC_varoffset(ncpvarpstart);
#7398 size_t extent = MIN(remainingncp->chunk);
#7401 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7410 (void) ncio_rel(ncp->nciopoffset, 0);
#7423getNCvx_double_ushort(const NC3_INFOncp, const NC_var *varp,
#7426 off_t offset = NC_varoffset(ncpvarpstart);
#7438 size_t extent = MIN(remainingncp->chunk);
#7441 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7450 (void) ncio_rel(ncp->nciopoffset, 0);
#7464getNCvx_uchar_schar(const NC3_INFOncp, const NC_var *varp,
#7467 off_t offset = NC_varoffset(ncpvarpstart);
#7479 size_t extent = MIN(remainingncp->chunk);
#7482 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7491 (void) ncio_rel(ncp->nciopoffset, 0);
#7504getNCvx_uchar_uchar(const NC3_INFOncp, const NC_var *varp,
#7507 off_t offset = NC_varoffset(ncpvarpstart);
#7519 size_t extent = MIN(remainingncp->chunk);
#7522 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7531 (void) ncio_rel(ncp->nciopoffset, 0);
#7544getNCvx_uchar_short(const NC3_INFOncp, const NC_var *varp,
#7547 off_t offset = NC_varoffset(ncpvarpstart);
#7559 size_t extent = MIN(remainingncp->chunk);
#7562 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7571 (void) ncio_rel(ncp->nciopoffset, 0);
#7584getNCvx_uchar_int(const NC3_INFOncp, const NC_var *varp,
#7587 off_t offset = NC_varoffset(ncpvarpstart);
#7599 size_t extent = MIN(remainingncp->chunk);
#7602 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7611 (void) ncio_rel(ncp->nciopoffset, 0);
#7624getNCvx_uchar_float(const NC3_INFOncp, const NC_var *varp,
#7627 off_t offset = NC_varoffset(ncpvarpstart);
#7639 size_t extent = MIN(remainingncp->chunk);
#7642 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7651 (void) ncio_rel(ncp->nciopoffset, 0);
#7664getNCvx_uchar_double(const NC3_INFOncp, const NC_var *varp,
#7667 off_t offset = NC_varoffset(ncpvarpstart);
#7679 size_t extent = MIN(remainingncp->chunk);
#7682 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7691 (void) ncio_rel(ncp->nciopoffset, 0);
#7704getNCvx_uchar_longlong(const NC3_INFOncp, const NC_var *varp,
#7707 off_t offset = NC_varoffset(ncpvarpstart);
#7719 size_t extent = MIN(remainingncp->chunk);
#7722 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7731 (void) ncio_rel(ncp->nciopoffset, 0);
#7744getNCvx_uchar_uint(const NC3_INFOncp, const NC_var *varp,
#7747 off_t offset = NC_varoffset(ncpvarpstart);
#7759 size_t extent = MIN(remainingncp->chunk);
#7762 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7771 (void) ncio_rel(ncp->nciopoffset, 0);
#7784getNCvx_uchar_ulonglong(const NC3_INFOncp, const NC_var *varp,
#7787 off_t offset = NC_varoffset(ncpvarpstart);
#7799 size_t extent = MIN(remainingncp->chunk);
#7802 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7811 (void) ncio_rel(ncp->nciopoffset, 0);
#7824getNCvx_uchar_ushort(const NC3_INFOncp, const NC_var *varp,
#7827 off_t offset = NC_varoffset(ncpvarpstart);
#7839 size_t extent = MIN(remainingncp->chunk);
#7842 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7851 (void) ncio_rel(ncp->nciopoffset, 0);
#7865getNCvx_ushort_schar(const NC3_INFOncp, const NC_var *varp,
#7868 off_t offset = NC_varoffset(ncpvarpstart);
#7880 size_t extent = MIN(remainingncp->chunk);
#7883 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7892 (void) ncio_rel(ncp->nciopoffset, 0);
#7905getNCvx_ushort_uchar(const NC3_INFOncp, const NC_var *varp,
#7908 off_t offset = NC_varoffset(ncpvarpstart);
#7920 size_t extent = MIN(remainingncp->chunk);
#7923 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7932 (void) ncio_rel(ncp->nciopoffset, 0);
#7945getNCvx_ushort_short(const NC3_INFOncp, const NC_var *varp,
#7948 off_t offset = NC_varoffset(ncpvarpstart);
#7960 size_t extent = MIN(remainingncp->chunk);
#7963 int lstatus = ncio_get(ncp->nciopoffsetextent,
#7972 (void) ncio_rel(ncp->nciopoffset, 0);
#7985getNCvx_ushort_int(const NC3_INFOncp, const NC_var *varp,
#7988 off_t offset = NC_varoffset(ncpvarpstart);
#8000 size_t extent = MIN(remainingncp->chunk);
#8003 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8012 (void) ncio_rel(ncp->nciopoffset, 0);
#8025getNCvx_ushort_float(const NC3_INFOncp, const NC_var *varp,
#8028 off_t offset = NC_varoffset(ncpvarpstart);
#8040 size_t extent = MIN(remainingncp->chunk);
#8043 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8052 (void) ncio_rel(ncp->nciopoffset, 0);
#8065getNCvx_ushort_double(const NC3_INFOncp, const NC_var *varp,
#8068 off_t offset = NC_varoffset(ncpvarpstart);
#8080 size_t extent = MIN(remainingncp->chunk);
#8083 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8092 (void) ncio_rel(ncp->nciopoffset, 0);
#8105getNCvx_ushort_longlong(const NC3_INFOncp, const NC_var *varp,
#8108 off_t offset = NC_varoffset(ncpvarpstart);
#8120 size_t extent = MIN(remainingncp->chunk);
#8123 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8132 (void) ncio_rel(ncp->nciopoffset, 0);
#8145getNCvx_ushort_uint(const NC3_INFOncp, const NC_var *varp,
#8148 off_t offset = NC_varoffset(ncpvarpstart);
#8160 size_t extent = MIN(remainingncp->chunk);
#8163 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8172 (void) ncio_rel(ncp->nciopoffset, 0);
#8185getNCvx_ushort_ulonglong(const NC3_INFOncp, const NC_var *varp,
#8188 off_t offset = NC_varoffset(ncpvarpstart);
#8200 size_t extent = MIN(remainingncp->chunk);
#8203 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8212 (void) ncio_rel(ncp->nciopoffset, 0);
#8225getNCvx_ushort_ushort(const NC3_INFOncp, const NC_var *varp,
#8228 off_t offset = NC_varoffset(ncpvarpstart);
#8240 size_t extent = MIN(remainingncp->chunk);
#8243 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8252 (void) ncio_rel(ncp->nciopoffset, 0);
#8266getNCvx_uint_schar(const NC3_INFOncp, const NC_var *varp,
#8269 off_t offset = NC_varoffset(ncpvarpstart);
#8281 size_t extent = MIN(remainingncp->chunk);
#8284 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8293 (void) ncio_rel(ncp->nciopoffset, 0);
#8306getNCvx_uint_uchar(const NC3_INFOncp, const NC_var *varp,
#8309 off_t offset = NC_varoffset(ncpvarpstart);
#8321 size_t extent = MIN(remainingncp->chunk);
#8324 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8333 (void) ncio_rel(ncp->nciopoffset, 0);
#8346getNCvx_uint_short(const NC3_INFOncp, const NC_var *varp,
#8349 off_t offset = NC_varoffset(ncpvarpstart);
#8361 size_t extent = MIN(remainingncp->chunk);
#8364 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8373 (void) ncio_rel(ncp->nciopoffset, 0);
#8386getNCvx_uint_int(const NC3_INFOncp, const NC_var *varp,
#8389 off_t offset = NC_varoffset(ncpvarpstart);
#8401 size_t extent = MIN(remainingncp->chunk);
#8404 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8413 (void) ncio_rel(ncp->nciopoffset, 0);
#8426getNCvx_uint_float(const NC3_INFOncp, const NC_var *varp,
#8429 off_t offset = NC_varoffset(ncpvarpstart);
#8441 size_t extent = MIN(remainingncp->chunk);
#8444 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8453 (void) ncio_rel(ncp->nciopoffset, 0);
#8466getNCvx_uint_double(const NC3_INFOncp, const NC_var *varp,
#8469 off_t offset = NC_varoffset(ncpvarpstart);
#8481 size_t extent = MIN(remainingncp->chunk);
#8484 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8493 (void) ncio_rel(ncp->nciopoffset, 0);
#8506getNCvx_uint_longlong(const NC3_INFOncp, const NC_var *varp,
#8509 off_t offset = NC_varoffset(ncpvarpstart);
#8521 size_t extent = MIN(remainingncp->chunk);
#8524 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8533 (void) ncio_rel(ncp->nciopoffset, 0);
#8546getNCvx_uint_uint(const NC3_INFOncp, const NC_var *varp,
#8549 off_t offset = NC_varoffset(ncpvarpstart);
#8561 size_t extent = MIN(remainingncp->chunk);
#8564 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8573 (void) ncio_rel(ncp->nciopoffset, 0);
#8586getNCvx_uint_ulonglong(const NC3_INFOncp, const NC_var *varp,
#8589 off_t offset = NC_varoffset(ncpvarpstart);
#8601 size_t extent = MIN(remainingncp->chunk);
#8604 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8613 (void) ncio_rel(ncp->nciopoffset, 0);
#8626getNCvx_uint_ushort(const NC3_INFOncp, const NC_var *varp,
#8629 off_t offset = NC_varoffset(ncpvarpstart);
#8641 size_t extent = MIN(remainingncp->chunk);
#8644 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8653 (void) ncio_rel(ncp->nciopoffset, 0);
#8667getNCvx_longlong_schar(const NC3_INFOncp, const NC_var *varp,
#8670 off_t offset = NC_varoffset(ncpvarpstart);
#8682 size_t extent = MIN(remainingncp->chunk);
#8685 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8694 (void) ncio_rel(ncp->nciopoffset, 0);
#8707getNCvx_longlong_uchar(const NC3_INFOncp, const NC_var *varp,
#8710 off_t offset = NC_varoffset(ncpvarpstart);
#8722 size_t extent = MIN(remainingncp->chunk);
#8725 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8734 (void) ncio_rel(ncp->nciopoffset, 0);
#8747getNCvx_longlong_short(const NC3_INFOncp, const NC_var *varp,
#8750 off_t offset = NC_varoffset(ncpvarpstart);
#8762 size_t extent = MIN(remainingncp->chunk);
#8765 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8774 (void) ncio_rel(ncp->nciopoffset, 0);
#8787getNCvx_longlong_int(const NC3_INFOncp, const NC_var *varp,
#8790 off_t offset = NC_varoffset(ncpvarpstart);
#8802 size_t extent = MIN(remainingncp->chunk);
#8805 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8814 (void) ncio_rel(ncp->nciopoffset, 0);
#8827getNCvx_longlong_float(const NC3_INFOncp, const NC_var *varp,
#8830 off_t offset = NC_varoffset(ncpvarpstart);
#8842 size_t extent = MIN(remainingncp->chunk);
#8845 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8854 (void) ncio_rel(ncp->nciopoffset, 0);
#8867getNCvx_longlong_double(const NC3_INFOncp, const NC_var *varp,
#8870 off_t offset = NC_varoffset(ncpvarpstart);
#8882 size_t extent = MIN(remainingncp->chunk);
#8885 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8894 (void) ncio_rel(ncp->nciopoffset, 0);
#8907getNCvx_longlong_longlong(const NC3_INFOncp, const NC_var *varp,
#8910 off_t offset = NC_varoffset(ncpvarpstart);
#8922 size_t extent = MIN(remainingncp->chunk);
#8925 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8934 (void) ncio_rel(ncp->nciopoffset, 0);
#8947getNCvx_longlong_uint(const NC3_INFOncp, const NC_var *varp,
#8950 off_t offset = NC_varoffset(ncpvarpstart);
#8962 size_t extent = MIN(remainingncp->chunk);
#8965 int lstatus = ncio_get(ncp->nciopoffsetextent,
#8974 (void) ncio_rel(ncp->nciopoffset, 0);
#8987getNCvx_longlong_ulonglong(const NC3_INFOncp, const NC_var *varp,
#8990 off_t offset = NC_varoffset(ncpvarpstart);
#9002 size_t extent = MIN(remainingncp->chunk);
#9005 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9014 (void) ncio_rel(ncp->nciopoffset, 0);
#9027getNCvx_longlong_ushort(const NC3_INFOncp, const NC_var *varp,
#9030 off_t offset = NC_varoffset(ncpvarpstart);
#9042 size_t extent = MIN(remainingncp->chunk);
#9045 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9054 (void) ncio_rel(ncp->nciopoffset, 0);
#9068getNCvx_ulonglong_schar(const NC3_INFOncp, const NC_var *varp,
#9071 off_t offset = NC_varoffset(ncpvarpstart);
#9083 size_t extent = MIN(remainingncp->chunk);
#9086 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9095 (void) ncio_rel(ncp->nciopoffset, 0);
#9108getNCvx_ulonglong_uchar(const NC3_INFOncp, const NC_var *varp,
#9111 off_t offset = NC_varoffset(ncpvarpstart);
#9123 size_t extent = MIN(remainingncp->chunk);
#9126 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9135 (void) ncio_rel(ncp->nciopoffset, 0);
#9148getNCvx_ulonglong_short(const NC3_INFOncp, const NC_var *varp,
#9151 off_t offset = NC_varoffset(ncpvarpstart);
#9163 size_t extent = MIN(remainingncp->chunk);
#9166 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9175 (void) ncio_rel(ncp->nciopoffset, 0);
#9188getNCvx_ulonglong_int(const NC3_INFOncp, const NC_var *varp,
#9191 off_t offset = NC_varoffset(ncpvarpstart);
#9203 size_t extent = MIN(remainingncp->chunk);
#9206 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9215 (void) ncio_rel(ncp->nciopoffset, 0);
#9228getNCvx_ulonglong_float(const NC3_INFOncp, const NC_var *varp,
#9231 off_t offset = NC_varoffset(ncpvarpstart);
#9243 size_t extent = MIN(remainingncp->chunk);
#9246 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9255 (void) ncio_rel(ncp->nciopoffset, 0);
#9268getNCvx_ulonglong_double(const NC3_INFOncp, const NC_var *varp,
#9271 off_t offset = NC_varoffset(ncpvarpstart);
#9283 size_t extent = MIN(remainingncp->chunk);
#9286 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9295 (void) ncio_rel(ncp->nciopoffset, 0);
#9308getNCvx_ulonglong_longlong(const NC3_INFOncp, const NC_var *varp,
#9311 off_t offset = NC_varoffset(ncpvarpstart);
#9323 size_t extent = MIN(remainingncp->chunk);
#9326 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9335 (void) ncio_rel(ncp->nciopoffset, 0);
#9348getNCvx_ulonglong_uint(const NC3_INFOncp, const NC_var *varp,
#9351 off_t offset = NC_varoffset(ncpvarpstart);
#9363 size_t extent = MIN(remainingncp->chunk);
#9366 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9375 (void) ncio_rel(ncp->nciopoffset, 0);
#9388getNCvx_ulonglong_ulonglong(const NC3_INFOncp, const NC_var *varp,
#9391 off_t offset = NC_varoffset(ncpvarpstart);
#9403 size_t extent = MIN(remainingncp->chunk);
#9406 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9415 (void) ncio_rel(ncp->nciopoffset, 0);
#9428getNCvx_ulonglong_ushort(const NC3_INFOncp, const NC_var *varp,
#9431 off_t offset = NC_varoffset(ncpvarpstart);
#9443 size_t extent = MIN(remainingncp->chunk);
#9446 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9455 (void) ncio_rel(ncp->nciopoffset, 0);
#9470getNCvx_schar_uchar(const NC3_INFOncp, const NC_var *varp,
#9473 off_t offset = NC_varoffset(ncpvarpstart);
#9485 size_t extent = MIN(remainingncp->chunk);
#9488 int lstatus = ncio_get(ncp->nciopoffsetextent,
#9497 (void) ncio_rel(ncp->nciopoffset, 0);
#9521NCiocount(const NC3_INFO* const ncp, const NC_var *const varp,
#9531 if(varp->ndims == 1 && ncp->recsize <= varp->len)
#9659readNCv(const NC3_INFOncp, const NC_varvarp, const size_t* start,
#9668       return getNCvx_char_char(ncp,varp,start,nelems,(char*)value);
#9670    return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#9674        return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#9677        return getNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9680        return getNCvx_schar_short(ncp,varp,start,nelems,(short*)value);
#9683        return getNCvx_schar_int(ncp,varp,start,nelems,(int*)value);
#9686        return getNCvx_schar_float(ncp,varp,start,nelems,(float*)value);
#9689        return getNCvx_schar_double(ncp,varp,start,nelems,(double *)value);
#9692        return getNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);
#9695        return getNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9698        return getNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9701        return getNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9704        return getNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);
#9707        return getNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9710        return getNCvx_short_short(ncp,varp,start,nelems,(short*)value);
#9713        return getNCvx_short_int(ncp,varp,start,nelems,(int*)value);
#9716        return getNCvx_short_float(ncp,varp,start,nelems,(float*)value);
#9719        return getNCvx_short_double(ncp,varp,start,nelems,(double*)value);
#9722        return getNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);
#9725        return getNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9728        return getNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9731        return getNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9735        return getNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);
#9738        return getNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9741        return getNCvx_int_short(ncp,varp,start,nelems,(short*)value);
#9744        return getNCvx_int_int(ncp,varp,start,nelems,(int*)value);
#9747        return getNCvx_int_float(ncp,varp,start,nelems,(float*)value);
#9750        return getNCvx_int_double(ncp,varp,start,nelems,(double*)value);
#9753        return getNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);
#9756        return getNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9759        return getNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9762        return getNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9766        return getNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);
#9769        return getNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9772        return getNCvx_float_short(ncp,varp,start,nelems,(short*)value);
#9775        return getNCvx_float_int(ncp,varp,start,nelems,(int*)value);
#9778        return getNCvx_float_float(ncp,varp,start,nelems,(float*)value);
#9781        return getNCvx_float_double(ncp,varp,start,nelems,(double*)value);
#9784        return getNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);
#9787        return getNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9790        return getNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9793        return getNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9797        return getNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);
#9800        return getNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9803        return getNCvx_double_short(ncp,varp,start,nelems,(short*)value);
#9806        return getNCvx_double_int(ncp,varp,start,nelems,(int*)value);
#9809        return getNCvx_double_float(ncp,varp,start,nelems,(float*)value);
#9812        return getNCvx_double_double(ncp,varp,start,nelems,(double*)value);
#9815        return getNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);
#9818        return getNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9821        return getNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9824        return getNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9828        return getNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9831        return getNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);
#9834        return getNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);
#9837        return getNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);
#9840        return getNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);
#9843        return getNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);
#9846        return getNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);
#9849        return getNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9852        return getNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9855        return getNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9859        return getNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);
#9862        return getNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9865        return getNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);
#9868        return getNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);
#9871        return getNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);
#9874        return getNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);
#9877        return getNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);
#9880        return getNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9883        return getNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9886        return getNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9890        return getNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);
#9893        return getNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9896        return getNCvx_uint_short(ncp,varp,start,nelems,(short*)value);
#9899        return getNCvx_uint_int(ncp,varp,start,nelems,(int*)value);
#9902        return getNCvx_uint_float(ncp,varp,start,nelems,(float*)value);
#9905        return getNCvx_uint_double(ncp,varp,start,nelems,(double*)value);
#9908        return getNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);
#9911        return getNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9914        return getNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9917        return getNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9921        return getNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);
#9924        return getNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9927        return getNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);
#9930        return getNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);
#9933        return getNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);
#9936        return getNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);
#9939        return getNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);
#9942        return getNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9945        return getNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9948        return getNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9952        return getNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);
#9955        return getNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9958        return getNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);
#9961        return getNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);
#9964        return getNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);
#9967        return getNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);
#9970        return getNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);
#9973        return getNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9976        return getNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9979        return getNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9991writeNCv(NC3_INFOncp, const NC_varvarp, const size_t* start,
#9999        return putNCvx_char_char(ncp,varp,start,nelems,(char*)value);
#10002        return putNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#10005        return putNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10008        return putNCvx_schar_short(ncp,varp,start,nelems,(short*)value);
#10011        return putNCvx_schar_int(ncp,varp,start,nelems,(int*)value);
#10014        return putNCvx_schar_float(ncp,varp,start,nelems,(float*)value);
#10017        return putNCvx_schar_double(ncp,varp,start,nelems,(double *)value);
#10020        return putNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);
#10023        return putNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10026        return putNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10029        return putNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10032        return putNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);
#10035        return putNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10038        return putNCvx_short_short(ncp,varp,start,nelems,(short*)value);
#10041        return putNCvx_short_int(ncp,varp,start,nelems,(int*)value);
#10044        return putNCvx_short_float(ncp,varp,start,nelems,(float*)value);
#10047        return putNCvx_short_double(ncp,varp,start,nelems,(double*)value);
#10050        return putNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);
#10053        return putNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10056        return putNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10059        return putNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10062        return putNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);
#10065        return putNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10068        return putNCvx_int_short(ncp,varp,start,nelems,(short*)value);
#10071        return putNCvx_int_int(ncp,varp,start,nelems,(int*)value);
#10074        return putNCvx_int_float(ncp,varp,start,nelems,(float*)value);
#10077        return putNCvx_int_double(ncp,varp,start,nelems,(double*)value);
#10080        return putNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);
#10083        return putNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10086        return putNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10089        return putNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10092        return putNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);
#10095        return putNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10098        return putNCvx_float_short(ncp,varp,start,nelems,(short*)value);
#10101        return putNCvx_float_int(ncp,varp,start,nelems,(int*)value);
#10104        return putNCvx_float_float(ncp,varp,start,nelems,(float*)value);
#10107        return putNCvx_float_double(ncp,varp,start,nelems,(double*)value);
#10110        return putNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);
#10113        return putNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10116        return putNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10119        return putNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10122        return putNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);
#10125        return putNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10128        return putNCvx_double_short(ncp,varp,start,nelems,(short*)value);
#10131        return putNCvx_double_int(ncp,varp,start,nelems,(int*)value);
#10134        return putNCvx_double_float(ncp,varp,start,nelems,(float*)value);
#10137        return putNCvx_double_double(ncp,varp,start,nelems,(double*)value);
#10140        return putNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);
#10143        return putNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10146        return putNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10149        return putNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10152        return putNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10155        return putNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);
#10158        return putNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);
#10161        return putNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);
#10164        return putNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);
#10167        return putNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);
#10170        return putNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);
#10173        return putNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10176        return putNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10179        return putNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10182        return putNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);
#10185        return putNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10188        return putNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);
#10191        return putNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);
#10194        return putNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);
#10197        return putNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);
#10200        return putNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);
#10203        return putNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10206        return putNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10209        return putNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10212        return putNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);
#10215        return putNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10218        return putNCvx_uint_short(ncp,varp,start,nelems,(short*)value);
#10221        return putNCvx_uint_int(ncp,varp,start,nelems,(int*)value);
#10224        return putNCvx_uint_float(ncp,varp,start,nelems,(float*)value);
#10227        return putNCvx_uint_double(ncp,varp,start,nelems,(double*)value);
#10230        return putNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);
#10233        return putNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10236        return putNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10239        return putNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10242        return putNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);
#10245        return putNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10248        return putNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);
#10251        return putNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);
#10254        return putNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);
#10257        return putNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);
#10260        return putNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);
#10263        return putNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10266        return putNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10269        return putNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10272        return putNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);
#10275        return putNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10278        return putNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);
#10281        return putNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);
#10284        return putNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);
#10287        return putNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);
#10290        return putNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);
#10293        return putNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10296        return putNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10299        return putNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
v1hpg.c#1195NC_computeshapes(NC3_INFOncp)
#1197 NC_var **vpp = (NC_var **)ncp->vars.value;
#1198 NC_var *const *const end = &vpp[ncp->vars.nelems];
#1203 ncp->begin_var = (off_tncp->xsz;
#1204 ncp->begin_rec = (off_tncp->xsz;
#1205 ncp->recsize = 0;
#1207 if(ncp->vars.nelems == 0)
#1212 status = NC_var_shape(*vpp, &ncp->dims);
#1221                           fIsSet(ncp->flagsNC_64BIT_OFFSET)) /* Flag for large last record */
#1222                            ncp->recsize += (*vpp)->dsizes[0] * (*vpp)->xsz;
#1224     ncp->recsize += (*vpp)->len;
#1234 ncp->begin_rec = (*vpp)->begin + (off_t)(*vpp)->len;
#1240 if(ncp->begin_rec > first_rec->begin)
#1242 ncp->begin_rec = first_rec->begin;
#1246 if(ncp->recsize == first_rec->len)
#1247 ncp->recsize = *first_rec->dsizes * first_rec->xsz;
#1252 ncp->begin_var = first_var->begin;
#1256 ncp->begin_var = ncp->begin_rec;
#1259 if(ncp->begin_var <= 0 ||
#1260    ncp->xsz > (size_t)ncp->begin_var ||
#1261    ncp->begin_rec <= 0 ||
#1262    ncp->begin_var > ncp->begin_rec)
#1270ncx_len_NC(const NC3_INFOncp, size_t sizeof_off_t)
#1275 assert(ncp != NULL);
#1276 if (fIsSet(ncp->flagsNC_64BIT_DATA)) /* CDF-5 */
#1278     else if (fIsSet(ncp->flagsNC_64BIT_OFFSET)) /* CDF-2 */
#1282 xlen += ncx_len_NC_dimarray(&ncp->dimsversion);
#1283 xlen += ncx_len_NC_attrarray(&ncp->attrsversion);
#1284 xlen += ncx_len_NC_vararray(&ncp->varssizeof_off_tversion);
#1292ncx_put_NC(const NC3_INFOncp, void **xppoff_t offset, size_t extent)
#1297 assert(ncp != NULL);
#1301 ps.nciop = ncp->nciop;
#1304 if (ncp->flags & NC_64BIT_DATA)
#1306 else if (ncp->flags & NC_64BIT_OFFSET)
#1316 extent = ncp->xsz;
#1320 extent = ncp->chunk;
#1326 else if(extent > ncp->chunk)
#1327     extent = ncp->chunk;
#1357 const size_t nrecs = NC_get_numrecs(ncp);
#1368 status = v1h_put_NC_dimarray(&ps, &ncp->dims);
#1372 status = v1h_put_NC_attrarray(&ps, &ncp->attrs);
#1376 status = v1h_put_NC_vararray(&ps, &ncp->vars);
#1389nc_get_NC(NC3_INFOncp)
#1394 assert(ncp != NULL);
#1398 gs.nciop = ncp->nciop;
#1411 size_t extent = ncp->xsz;
#1413 if(extent <= ((fIsSet(ncp->flagsNC_64BIT_DATA))?MIN_NC5_XSZ:MIN_NC3_XSZ))
#1415         status = ncio_filesize(ncp->nciop, &filesize);
#1424 extent = ncp->chunk;
#1432 else if(extent > ncp->chunk)
#1433     extent = ncp->chunk;
#1470   fSet(ncp->flagsNC_64BIT_OFFSET);
#1479   fSet(ncp->flagsNC_64BIT_DATA);
#1497 NC_set_numrecs(ncpnrecs);
#1505 status = v1h_get_NC_dimarray(&gs, &ncp->dims);
#1509 status = v1h_get_NC_attrarray(&gs, &ncp->attrs);
#1513 status = v1h_get_NC_vararray(&gs, &ncp->vars);
#1517 ncp->xsz = ncx_len_NC(ncp, (gs.version == 1) ? 4 : 8);
#1519 status = NC_computeshapes(ncp);
var.c#546int NC_lookupvar(NC3_INFOncp, int varidNC_var **varp)
#555    *varp = elem_NC_vararray(&ncp->vars, (size_t)varid);
#575 NC3_INFOncp;
#582 ncp = NC3_DATA(nc);
#584 if(!NC_indef(ncp))
#603 if(ncp->vars.nelems >= NC_MAX_VARS)
#608 varid = NC_findvar(&ncp->varsname, &varp);
#618 status = NC_var_shape(varp, &ncp->dims);
#625 status = incr_NC_vararray(&ncp->varsvarp);
#633 *varidp = (int)ncp->vars.nelems -1; /* varid */
#643 NC3_INFOncp;
#650 ncp = NC3_DATA(nc);
#652 varid = NC_findvar(&ncp->varsname, &varp);
#674 NC3_INFOncp;
#681 ncp = NC3_DATA(nc);
#683 varp = elem_NC_vararray(&ncp->vars, (size_t)varid);
#719 NC3_INFOncp;
#728 ncp = NC3_DATA(nc);
#730 if(NC_readonly(ncp))
#740 other = NC_findvar(&ncp->varsunewname, &varp);
#746 status = NC_lookupvar(ncpvarid, &varp);
#758 if(NC_indef(ncp))
#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);
#785 set_NC_hdirty(ncp);
#787 if(NC_doHsync(ncp))
#789 status = NC_sync(ncp);


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