00047              {
00048         NC_NAT =        0,      /* NAT = 'Not A Type' (c.f. NaN) */
00049         NC_BYTE =       1,      /* signed 1 byte integer */
00050         NC_CHAR =       2,      /* ISO/ASCII character */
00051         NC_SHORT =      3,      /* signed 2 byte integer */
00052         NC_INT =        4,      /* signed 4 byte integer */
00053         NC_FLOAT =      5,      /* single precision floating point number */
00054         NC_DOUBLE =     6       /* double precision floating point number */
00055 } nc_type;

00738 {
00739         return nc__create_mp(path, ioflags, initialsz, 0,
00740                 chunksizehintp, ncid_ptr);
00741 }

00746 {
00747         NC *ncp;
00748         int status;
00749         void *xp = NULL;
00750 
00751 #if ALWAYS_NC_SHARE /* DEBUG */
00752         fSet(ioflags, NC_SHARE);
00753 #endif
00754 
00755         ncp = new_NC(chunksizehintp);
00756         if(ncp == NULL)
00757                 return NC_ENOMEM;
00758 
00759 #if defined(LOCKNUMREC) /* && _CRAYMPP */
00760         if (status = NC_init_pe(ncp, basepe)) {
00761                 return status;
00762         }
00763 #else
00764         /*
00765          * !_CRAYMPP, only pe 0 is valid
00766          */
00767         if(basepe != 0)
00768                 return NC_EINVAL;
00769 #endif
00770         assert(ncp->xsz == ncx_len_NC(ncp));
00771         
00772         status = ncio_create(path, ioflags,
00773                 initialsz,
00774                 0, ncp->xsz, &ncp->chunk,
00775                 &ncp->nciop, &xp);
00776         if(status != NC_NOERR)
00777         {
00778                 /* translate error status */
00779                 if(status == EEXIST)
00780                         status = NC_EEXIST;
00781                 goto unwind_alloc;
00782         }
00783 
00784         assert(ncp->flags == 0);
00785         fSet(ncp->flags, NC_CREAT);
00786 
00787         if(fIsSet(ncp->nciop->ioflags, NC_SHARE))
00788         {
00789                 /*
00790                  * NC_SHARE implies sync up the number of records as well.
00791                  * (File format version one.)
00792                  * Note that other header changes are not shared
00793                  * automatically.  Some sort of IPC (external to this package)
00794                  * would be used to trigger a call to nc_sync().
00795                  */
00796                 fSet(ncp->flags, NC_NSYNC);
00797         }
00798 
00799         status = ncx_put_NC(ncp, &xp, 0, ncp->xsz);
00800         if(status != NC_NOERR)
00801                 goto unwind_ioc;
00802 
00803         add_to_NCList(ncp);
00804 
00805         if(chunksizehintp != NULL)
00806                 *chunksizehintp = ncp->chunk;
00807         *ncid_ptr = ncp->nciop->fd;
00808         return NC_NOERR;
00809 
00810 unwind_ioc:
00811         (void) ncio_close(ncp->nciop, 1); /* N.B.: unlink */
00812         ncp->nciop = NULL;
00813         /*FALLTHRU*/
00814 unwind_alloc:
00815         free_NC(ncp);
00816         return status;
00817 }

00911 {
00912         int status;
00913         NC *ncp;
00914 
00915         status = NC_check_id(ncid, &ncp); 
00916         if(status != NC_NOERR)
00917                 return status;
00918 
00919         if(!NC_indef(ncp))
00920                 return(NC_ENOTINDEFINE);
00921 
00922         return (NC_endef(ncp, h_minfree, v_align, v_minfree, r_align));
00923 }

00829 {
00830         return nc__open_mp(path, ioflags, 0,
00831                 chunksizehintp, ncid_ptr);
00832 }

00837 {
00838         NC *ncp;
00839         int status;
00840 
00841 #if ALWAYS_NC_SHARE /* DEBUG */
00842         fSet(ioflags, NC_SHARE);
00843 #endif
00844 
00845         ncp = new_NC(chunksizehintp);
00846         if(ncp == NULL)
00847                 return NC_ENOMEM;
00848 
00849 #if defined(LOCKNUMREC) /* && _CRAYMPP */
00850         if (status = NC_init_pe(ncp, basepe)) {
00851                 return status;
00852         }
00853 #else
00854         /*
00855          * !_CRAYMPP, only pe 0 is valid
00856          */
00857         if(basepe != 0)
00858                 return NC_EINVAL;
00859 #endif
00860         status = ncio_open(path, ioflags,
00861                 0, 0, &ncp->chunk,
00862                 &ncp->nciop, 0);
00863         if(status)
00864                 goto unwind_alloc;
00865 
00866         assert(ncp->flags == 0);
00867 
00868         if(fIsSet(ncp->nciop->ioflags, NC_SHARE))
00869         {
00870                 /*
00871                  * NC_SHARE implies sync up the number of records as well.
00872                  * (File format version one.)
00873                  * Note that other header changes are not shared
00874                  * automatically.  Some sort of IPC (external to this package)
00875                  * would be used to trigger a call to nc_sync().
00876                  */
00877                 fSet(ncp->flags, NC_NSYNC);
00878         }
00879 
00880         status = nc_get_NC(ncp);
00881         if(status != NC_NOERR)
00882                 goto unwind_ioc;
00883 
00884         add_to_NCList(ncp);
00885 
00886         if(chunksizehintp != NULL)
00887                 *chunksizehintp = ncp->chunk;
00888         *ncid_ptr = ncp->nciop->fd;
00889         return NC_NOERR;
00890 
00891 unwind_ioc:
00892         (void) ncio_close(ncp->nciop, 0);
00893         ncp->nciop = NULL;
00894         /*FALLTHRU*/
00895 unwind_alloc:
00896         free_NC(ncp);
00897         return status;
00898 }

01041 {
01042         int status;
01043         NC *ncp;
01044         int doUnlink = 0;
01045 
01046         status = NC_check_id(ncid, &ncp); 
01047         if(status != NC_NOERR)
01048                 return status;
01049 
01050         doUnlink = NC_IsNew(ncp);
01051 
01052         if(ncp->old != NULL)
01053         {
01054                 /* a plain redef, not a create */
01055                 assert(!NC_IsNew(ncp));
01056                 assert(fIsSet(ncp->flags, NC_INDEF));
01057                 free_NC(ncp->old);
01058                 ncp->old = NULL;
01059                 fClr(ncp->flags, NC_INDEF);
01060         }
01061         else if(!NC_readonly(ncp))
01062         {
01063                 status = NC_sync(ncp);
01064                 if(status != NC_NOERR)
01065                         return status;
01066         }
01067 
01068 
01069         (void) ncio_close(ncp->nciop, doUnlink);
01070         ncp->nciop = NULL;
01071 
01072         del_from_NCList(ncp);
01073 
01074         free_NC(ncp);
01075 
01076         return NC_NOERR;
01077 }

00104 {
00105         va_list args;
00106 
00107         if(NC_ISSYSERR(err))
00108                 ncerr = NC_SYSERR;
00109         else
00110                 ncerr = err;
00111 
00112         if( ncopts & NC_VERBOSE )
00113         {
00114                 (void) fprintf(stderr,"%s: ", routine_name);
00115                 va_start(args ,fmt);
00116                 (void) vfprintf(stderr,fmt,args);
00117                 va_end(args);
00118                 if(err != NC_NOERR)
00119                 {
00120                         (void) fprintf(stderr,": %s",
00121                                 nc_strerror(err));
00122                 }
00123                 (void) fputc('\n',stderr);
00124                 (void) fflush(stderr);  /* to ensure log files are current */
00125         }
00126 
00127         if( (ncopts & NC_FATAL) && err != NC_NOERR )
00128         {
00129                 exit(ncopts);
00130         }
00131 }

00945 {
00946         int status = NC_NOERR;
00947         NC *ncp; 
00948 
00949         status = NC_check_id(ncid, &ncp); 
00950         if(status != NC_NOERR)
00951                 return status;
00952 
00953         if(NC_indef(ncp))
00954         {
00955                 status = NC_endef(ncp, 0, 1, 0, 1); /* TODO: defaults */
00956                 if(status != NC_NOERR )
00957                 {
00958                         (void) nc_abort(ncid);
00959                         return status;
00960                 }
00961         }
00962         else if(!NC_readonly(ncp))
00963         {
00964                 status = NC_sync(ncp);
00965         }
00966 
00967         (void) ncio_close(ncp->nciop, 0);
00968         ncp->nciop = NULL;
00969 
00970         del_from_NCList(ncp);
00971 
00972         free_NC(ncp);
00973 
00974         return status;
00975 }

00556 {
00557         int status;
00558         NC_attr *iattrp;
00559         NC *ncp;
00560         NC_attrarray *ncap;
00561         NC_attr **attrpp;
00562         NC_attr *old = NULL;
00563         NC_attr *attrp;
00564 
00565         status = NC_lookupattr(ncid_in, varid_in, name, &iattrp);
00566         if(status != NC_NOERR)
00567                 return status;
00568 
00569         status = NC_check_id(ncid_out, &ncp);
00570         if(status != NC_NOERR)
00571                 return status;
00572 
00573         if(NC_readonly(ncp))
00574                 return NC_EPERM;
00575 
00576         ncap = NC_attrarray0(ncp, ovarid);
00577         if(ncap == NULL)
00578                 return NC_ENOTVAR;
00579 
00580         attrpp = NC_findattr(ncap, name);
00581         if(attrpp != NULL) /* name in use */
00582         {
00583                 if(!NC_indef(ncp) )
00584                 {
00585                         attrp = *attrpp; /* convenience */
00586         
00587                         if(iattrp->xsz > attrp->xsz)
00588                                 return NC_ENOTINDEFINE;
00589                         /* else, we can reuse existing without redef */
00590                         
00591                         attrp->xsz = iattrp->xsz;
00592                         attrp->type = iattrp->type;
00593                         attrp->nelems = iattrp->nelems;
00594 
00595                         (void) memcpy(attrp->xvalue, iattrp->xvalue,
00596                                 iattrp->xsz);
00597                         
00598                         set_NC_hdirty(ncp);
00599 
00600                         if(NC_doHsync(ncp))
00601                         {
00602                                 status = NC_sync(ncp);
00603                                 if(status != NC_NOERR)
00604                                         return status;
00605                         }
00606 
00607                         return NC_NOERR;
00608                 }
00609                 /* else, redefine using existing array slot */
00610                 old = *attrpp;
00611         } 
00612         else
00613         {
00614                 if(!NC_indef(ncp))
00615                         return NC_ENOTINDEFINE;
00616 
00617                 if(ncap->nelems >= NC_MAX_ATTRS)
00618                         return NC_EMAXATTS;
00619         }
00620 
00621         attrp = new_NC_attr(name, iattrp->type, iattrp->nelems);
00622         if(attrp == NULL)
00623                 return NC_ENOMEM;
00624 
00625         (void) memcpy(attrp->xvalue, iattrp->xvalue,
00626                 iattrp->xsz);
00627 
00628         if(attrpp != NULL)
00629         {
00630                 assert(old != NULL);
00631                 *attrpp = attrp;
00632                 free_NC_attr(old);
00633         }
00634         else
00635         {
00636                 status = incr_NC_attrarray(ncap, attrp);
00637                 if(status != NC_NOERR)
00638                 {
00639                         free_NC_attr(attrp);
00640                         return status;
00641                 }
00642         }
00643 
00644         return NC_NOERR;
00645 }

11666 {
11667         int status = NC_NOERR;
11668         NC *inncp, *outncp;
11669         NC_var *invp, *outvp;
11670 
11671         status = NC_check_id(ncid_in, &inncp); 
11672         if(status != NC_NOERR)
11673                 return status;
11674 
11675 
11676         if(NC_indef(inncp))
11677         {
11678                 return NC_EINDEFINE;
11679         }
11680 
11681         status = NC_check_id(ncid_out, &outncp); 
11682         if(status != NC_NOERR)
11683                 return status;
11684 
11685         if(NC_readonly(outncp))
11686         {
11687                 /* output file isn't writable */
11688                 return NC_EPERM;
11689         }
11690 
11691         if(NC_indef(outncp))
11692         {
11693                 return NC_EINDEFINE;
11694         }
11695 
11696         /* find the variable in the input cdf */
11697         invp = NC_lookupvar(inncp, varid);
11698         if(invp == NULL)
11699         {
11700                 return NC_ENOTVAR;
11701         }
11702 
11703         /* find the variable in the output cdf */
11704         if(NC_findvar(&outncp->vars, invp->name->cp, &outvp) == -1)
11705         {
11706                 return NC_ENOTVAR;
11707         }
11708 
11709         /* can we even attempt to copy without conversion? */
11710         if(outvp->type != invp->type)
11711         {
11712                 return NC_EINVAL;
11713         }
11714 
11715         if(        (invp->ndims == 0 && outvp->ndims != 0)
11716                 || (invp->ndims != 0 && outvp->ndims == 0)
11717                 || (IS_RECVAR(invp) && !IS_RECVAR(outvp))
11718                 || (!IS_RECVAR(invp) && IS_RECVAR(outvp))
11719                 || (invp->len != outvp->len)
11720         )
11721         {
11722                 return NC_EINVAL;
11723         }
11724 
11725         /*
11726          * Check coordinates
11727          */
11728         {
11729         ALLOC_ONSTACK(coord, size_t, invp->ndims);
11730         const size_t nrecs = NC_get_numrecs(inncp);
11731         (void) memcpy(coord, invp->shape, invp->ndims * sizeof(size_t));
11732         if(IS_RECVAR(invp))
11733                 *coord = nrecs;
11734         
11735         {
11736         size_t ii = 0;
11737         for(; ii < invp->ndims; ii++)
11738                 coord[ii] --;
11739         }
11740         /* at this point, coord is the largest valid coord of invp */
11741 
11742         if(NCcoordck(outncp, outvp, coord) != NC_NOERR)
11743         {
11744                 return NC_EINVAL;
11745         }
11746         /* else */
11747 
11748         (void) memset(coord, 0, invp->ndims * sizeof(size_t));
11749         
11750         if(!IS_RECVAR(invp))
11751         {
11752                 status = NCxvarcpy(inncp, invp, coord,
11753                                 outncp, outvp, coord,
11754                                 invp->len);
11755                 goto done;
11756         }
11757         /* else */
11758 
11759         status = NCvnrecs(outncp, nrecs);
11760         if(status != NC_NOERR)
11761                 goto done;
11762 
11763         for( /*NADA*/; *coord < nrecs; (*coord)++)
11764         {
11765                 status = NCxvarcpy(inncp, invp, coord,
11766                                 outncp, outvp, coord,
11767                                 invp->len);
11768                 if(status != NC_NOERR)
11769                         break;
11770         }
11771 done:
11772         FREE_ONSTACK(coord);
11773         }
11774         return status;
11775 }

00821 {
00822         return nc__create(path, ioflags, 0, NULL, ncid_ptr);
00823 }

00306 {
00307         int status;
00308         NC *ncp;
00309         int dimid;
00310         NC_dim *dimp;
00311 
00312         status = NC_check_id(ncid, &ncp); 
00313         if(status != NC_NOERR)
00314                 return status;
00315 
00316         if(!NC_indef(ncp))
00317                 return NC_ENOTINDEFINE;
00318 
00319         status = NC_check_name(name);
00320         if(status != NC_NOERR)
00321                 return status;
00322 
00323                 /* cast needed for braindead systems with signed size_t */
00324         if((unsigned long) size > X_INT_MAX) /* Backward compat */
00325                 return NC_EINVAL;
00326 
00327         if(size == NC_UNLIMITED)
00328         {
00329                 dimid = find_NC_Udim(&ncp->dims, &dimp);
00330                 if(dimid != -1)
00331                 {
00332                         assert(dimid != -1);
00333                         return NC_EUNLIMIT;
00334                 }
00335         }
00336 
00337         if(ncp->dims.nelems >= NC_MAX_DIMS)
00338                 return NC_EMAXDIMS;
00339 
00340         dimid = NC_finddim(&ncp->dims, name, &dimp);
00341         if(dimid != -1)
00342                 return NC_ENAMEINUSE;
00343         
00344         dimp = new_NC_dim(name, size);
00345         if(dimp == NULL)
00346                 return NC_ENOMEM;
00347         status = incr_NC_dimarray(&ncp->dims, dimp);
00348         if(status != NC_NOERR)
00349         {
00350                 free_NC_dim(dimp);
00351                 return status;
00352         }
00353 
00354         if(dimidp != NULL)
00355                 *dimidp = (int)ncp->dims.nelems -1;
00356         return NC_NOERR;
00357 }

00462 {
00463         int status;
00464         NC *ncp;
00465         int varid;
00466         NC_var *varp;
00467 
00468         status = NC_check_id(ncid, &ncp); 
00469         if(status != NC_NOERR)
00470                 return status;
00471 
00472         if(!NC_indef(ncp))
00473         {
00474                 return NC_ENOTINDEFINE;
00475         }
00476 
00477         status = NC_check_name(name);
00478         if(status != NC_NOERR)
00479                 return status;
00480 
00481         status = nc_cktype(type);
00482         if(status != NC_NOERR)
00483                 return status;
00484 
00485                 /* cast needed for braindead systems with signed size_t */
00486         if((unsigned long) ndims > X_INT_MAX) /* Backward compat */
00487         {
00488                 return NC_EINVAL;
00489         } 
00490 
00491         if(ncp->vars.nelems >= NC_MAX_VARS)
00492         {
00493                 return NC_EMAXVARS;
00494         }
00495 
00496         varid = NC_findvar(&ncp->vars, name, &varp);
00497         if(varid != -1)
00498         {
00499                 return NC_ENAMEINUSE;
00500         }
00501         
00502         varp = new_NC_var(name, type, ndims, dimids);
00503         if(varp == NULL)
00504                 return NC_ENOMEM;
00505 
00506         status = NC_var_shape(varp, &ncp->dims);
00507         if(status != NC_NOERR)
00508         {
00509                 free_NC_var(varp);
00510                 return status;
00511         }
00512 
00513         status = incr_NC_vararray(&ncp->vars, varp);
00514         if(status != NC_NOERR)
00515         {
00516                 free_NC_var(varp);
00517                 return status;
00518         }
00519 
00520         if(varidp != NULL)
00521                 *varidp = (int)ncp->vars.nelems -1; /* varid */
00522         return NC_NOERR;
00523 }

00650 {
00651         int status;
00652         NC *ncp;
00653         NC_attrarray *ncap;
00654         NC_attr **attrpp;
00655         NC_attr *old = NULL;
00656         int attrid;
00657         size_t slen;
00658 
00659         status = NC_check_id(ncid, &ncp);
00660         if(status != NC_NOERR)
00661                 return status;
00662 
00663         if(!NC_indef(ncp))
00664                 return NC_ENOTINDEFINE;
00665 
00666         ncap = NC_attrarray0(ncp, varid);
00667         if(ncap == NULL)
00668                 return NC_ENOTVAR;
00669 
00670                         /* sortof inline NC_findattr() */
00671         slen = strlen(name);
00672 
00673         attrpp = (NC_attr **) ncap->value;
00674         for(attrid = 0; (size_t) attrid < ncap->nelems; attrid++, attrpp++)
00675         {
00676                 if( slen == (*attrpp)->name->nchars &&
00677                         strncmp(name, (*attrpp)->name->cp, slen) == 0)
00678                 {
00679                         old = *attrpp;
00680                         break;
00681                 }
00682         }
00683         if( (size_t) attrid == ncap->nelems )
00684                 return NC_ENOTATT;
00685                         /* end inline NC_findattr() */
00686 
00687         /* shuffle down */
00688         for(attrid++; (size_t) attrid < ncap->nelems; attrid++)
00689         {
00690                 *attrpp = *(attrpp + 1);
00691                 attrpp++;
00692         }
00693         *attrpp = NULL;
00694         /* decrement count */
00695         ncap->nelems--;
00696 
00697         free_NC_attr(old);
00698 
00699         return NC_NOERR;
00700 }

00986 {
00987         NC *ncp;
00988         int status;
00989         size_t chunk = 512;
00990 
00991         ncp = new_NC(&chunk);
00992         if(ncp == NULL)
00993                 return NC_ENOMEM;
00994         
00995 #if defined(LOCKNUMREC) /* && _CRAYMPP */
00996         if (status = NC_init_pe(ncp, basepe)) {
00997                 return status;
00998         }
00999 #else
01000         /*
01001          * !_CRAYMPP, only pe 0 is valid
01002          */
01003         if(basepe != 0)
01004                 return NC_EINVAL;
01005 #endif
01006         status = ncio_open(path, NC_NOWRITE,
01007                 0, 0, &ncp->chunk,
01008                 &ncp->nciop, 0);
01009         if(status)
01010                 goto unwind_alloc;
01011 
01012         assert(ncp->flags == 0);
01013 
01014         status = nc_get_NC(ncp);
01015         if(status != NC_NOERR)
01016         {
01017                 /* Not a netcdf file, don't delete */
01018                 /* ??? is this the right semantic? what if it was just too big? */
01019                 (void) ncio_close(ncp->nciop, 0);
01020         }
01021         else
01022         {
01023                 /* ncio_close does the unlink */
01024                 status = ncio_close(ncp->nciop, 1); /* ncio_close does the unlink */
01025         }
01026 
01027         ncp->nciop = NULL;
01028 unwind_alloc:
01029         free_NC(ncp);
01030         return status;
01031 }

00927 {
00928         int status;
00929         NC *ncp;
00930 
00931         status = NC_check_id(ncid, &ncp); 
00932         if(status != NC_NOERR)
00933                 return status;
00934 
00935         if(!NC_indef(ncp))
00936                 return(NC_ENOTINDEFINE);
00937 
00938         /* return(NC_endef(ncp, 0, 4096, 0, 4096)); */
00939         return (NC_endef(ncp, 0, 1, 0, 1));
00940 }

02151 {
02152         int status;
02153         NC_attr *attrp;
02154 
02155         status = NC_lookupattr(ncid, varid, name, &attrp);
02156         if(status != NC_NOERR)
02157                 return status;
02158 
02159         if(attrp->nelems == 0)
02160                 return NC_NOERR;
02161 
02162         if(attrp->type == NC_CHAR)
02163                 return NC_ECHAR;
02164 
02165         {
02166         const void *xp = attrp->xvalue;
02167         return ncx_pad_getn_Idouble(&xp, attrp->nelems, tp, attrp->type);
02168         }
02169 }

02004 {
02005         int status;
02006         NC_attr *attrp;
02007 
02008         status = NC_lookupattr(ncid, varid, name, &attrp);
02009         if(status != NC_NOERR)
02010                 return status;
02011 
02012         if(attrp->nelems == 0)
02013                 return NC_NOERR;
02014 
02015         if(attrp->type == NC_CHAR)
02016                 return NC_ECHAR;
02017 
02018         {
02019         const void *xp = attrp->xvalue;
02020         return ncx_pad_getn_Ifloat(&xp, attrp->nelems, tp, attrp->type);
02021         }
02022 }

01710 {
01711         int status;
01712         NC_attr *attrp;
01713 
01714         status = NC_lookupattr(ncid, varid, name, &attrp);
01715         if(status != NC_NOERR)
01716                 return status;
01717 
01718         if(attrp->nelems == 0)
01719                 return NC_NOERR;
01720 
01721         if(attrp->type == NC_CHAR)
01722                 return NC_ECHAR;
01723 
01724         {
01725         const void *xp = attrp->xvalue;
01726         return ncx_pad_getn_Iint(&xp, attrp->nelems, tp, attrp->type);
01727         }
01728 }

01857 {
01858         int status;
01859         NC_attr *attrp;
01860 
01861         status = NC_lookupattr(ncid, varid, name, &attrp);
01862         if(status != NC_NOERR)
01863                 return status;
01864 
01865         if(attrp->nelems == 0)
01866                 return NC_NOERR;
01867 
01868         if(attrp->type == NC_CHAR)
01869                 return NC_ECHAR;
01870 
01871         {
01872         const void *xp = attrp->xvalue;
01873         return ncx_pad_getn_Ilong(&xp, attrp->nelems, tp, attrp->type);
01874         }
01875 }

01269 {
01270         int status;
01271         NC_attr *attrp;
01272 
01273         status = NC_lookupattr(ncid, varid, name, &attrp);
01274         if(status != NC_NOERR)
01275                 return status;
01276 
01277         if(attrp->nelems == 0)
01278                 return NC_NOERR;
01279 
01280         if(attrp->type == NC_CHAR)
01281                 return NC_ECHAR;
01282 
01283         {
01284         const void *xp = attrp->xvalue;
01285         return ncx_pad_getn_Ischar(&xp, attrp->nelems, tp, attrp->type);
01286         }
01287 }

01563 {
01564         int status;
01565         NC_attr *attrp;
01566 
01567         status = NC_lookupattr(ncid, varid, name, &attrp);
01568         if(status != NC_NOERR)
01569                 return status;
01570 
01571         if(attrp->nelems == 0)
01572                 return NC_NOERR;
01573 
01574         if(attrp->type == NC_CHAR)
01575                 return NC_ECHAR;
01576 
01577         {
01578         const void *xp = attrp->xvalue;
01579         return ncx_pad_getn_Ishort(&xp, attrp->nelems, tp, attrp->type);
01580         }
01581 }

01119 {
01120         int status;
01121         NC_attr *attrp;
01122 
01123         status = NC_lookupattr(ncid, varid, name, &attrp);
01124         if(status != NC_NOERR)
01125                 return status;
01126 
01127         if(attrp->nelems == 0)
01128                 return NC_NOERR;
01129 
01130         if(attrp->type != NC_CHAR)
01131                 return NC_ECHAR;
01132 
01133         /* else */
01134         {
01135                 const void *xp = attrp->xvalue;
01136                 return ncx_pad_getn_text(&xp, attrp->nelems, str);
01137         }
01138 }

01416 {
01417         int status;
01418         NC_attr *attrp;
01419 
01420         status = NC_lookupattr(ncid, varid, name, &attrp);
01421         if(status != NC_NOERR)
01422                 return status;
01423 
01424         if(attrp->nelems == 0)
01425                 return NC_NOERR;
01426 
01427         if(attrp->type == NC_CHAR)
01428                 return NC_ECHAR;
01429 
01430         {
01431         const void *xp = attrp->xvalue;
01432         return ncx_pad_getn_Iuchar(&xp, attrp->nelems, tp, attrp->type);
01433         }
01434 }

04891 {
04892         int status;
04893         NC *ncp;
04894         const NC_var *varp;
04895 
04896         status = NC_check_id(ncid, &ncp); 
04897         if(status != NC_NOERR)
04898                 return status;
04899 
04900         if(NC_indef(ncp))
04901                 return NC_EINDEFINE;
04902 
04903         varp = NC_lookupvar(ncp, varid);
04904         if(varp == NULL)
04905                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
04906 
04907         if(varp->type == NC_CHAR)
04908                 return NC_ECHAR;
04909 
04910         status = NCcoordck(ncp, varp, coord);
04911         if(status != NC_NOERR)
04912                 return status;
04913 
04914         return getNCv_double(ncp, varp, coord, 1, value);
04915 }

04863 {
04864         int status;
04865         NC *ncp;
04866         const NC_var *varp;
04867 
04868         status = NC_check_id(ncid, &ncp); 
04869         if(status != NC_NOERR)
04870                 return status;
04871 
04872         if(NC_indef(ncp))
04873                 return NC_EINDEFINE;
04874 
04875         varp = NC_lookupvar(ncp, varid);
04876         if(varp == NULL)
04877                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
04878 
04879         if(varp->type == NC_CHAR)
04880                 return NC_ECHAR;
04881 
04882         status = NCcoordck(ncp, varp, coord);
04883         if(status != NC_NOERR)
04884                 return status;
04885 
04886         return getNCv_float(ncp, varp, coord, 1, value);
04887 }

04807 {
04808         int status;
04809         NC *ncp;
04810         const NC_var *varp;
04811 
04812         status = NC_check_id(ncid, &ncp); 
04813         if(status != NC_NOERR)
04814                 return status;
04815 
04816         if(NC_indef(ncp))
04817                 return NC_EINDEFINE;
04818 
04819         varp = NC_lookupvar(ncp, varid);
04820         if(varp == NULL)
04821                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
04822 
04823         if(varp->type == NC_CHAR)
04824                 return NC_ECHAR;
04825 
04826         status = NCcoordck(ncp, varp, coord);
04827         if(status != NC_NOERR)
04828                 return status;
04829 
04830         return getNCv_int(ncp, varp, coord, 1, value);
04831 }

04835 {
04836         int status;
04837         NC *ncp;
04838         const NC_var *varp;
04839 
04840         status = NC_check_id(ncid, &ncp); 
04841         if(status != NC_NOERR)
04842                 return status;
04843 
04844         if(NC_indef(ncp))
04845                 return NC_EINDEFINE;
04846 
04847         varp = NC_lookupvar(ncp, varid);
04848         if(varp == NULL)
04849                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
04850 
04851         if(varp->type == NC_CHAR)
04852                 return NC_ECHAR;
04853 
04854         status = NCcoordck(ncp, varp, coord);
04855         if(status != NC_NOERR)
04856                 return status;
04857 
04858         return getNCv_long(ncp, varp, coord, 1, value);
04859 }

04779 {
04780         int status;
04781         NC *ncp;
04782         const NC_var *varp;
04783 
04784         status = NC_check_id(ncid, &ncp); 
04785         if(status != NC_NOERR)
04786                 return status;
04787 
04788         if(NC_indef(ncp))
04789                 return NC_EINDEFINE;
04790 
04791         varp = NC_lookupvar(ncp, varid);
04792         if(varp == NULL)
04793                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
04794 
04795         if(varp->type == NC_CHAR)
04796                 return NC_ECHAR;
04797 
04798         status = NCcoordck(ncp, varp, coord);
04799         if(status != NC_NOERR)
04800                 return status;
04801 
04802         return getNCv_short(ncp, varp, coord, 1, value);
04803 }

04694 {
04695         int status;
04696         NC *ncp;
04697         const NC_var *varp;
04698 
04699         status = NC_check_id(ncid, &ncp); 
04700         if(status != NC_NOERR)
04701                 return status;
04702 
04703         if(NC_indef(ncp))
04704                 return NC_EINDEFINE;
04705 
04706         varp = NC_lookupvar(ncp, varid);
04707         if(varp == NULL)
04708                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
04709 
04710         if(varp->type != NC_CHAR)
04711                 return NC_ECHAR;
04712 
04713         status = NCcoordck(ncp, varp, coord);
04714         if(status != NC_NOERR)
04715                 return status;
04716 
04717         return getNCv_text(ncp, varp, coord, 1, value);
04718 }

07882 {
07883         int status = NC_NOERR;
07884         NC *ncp;
07885         const NC_var *varp;
07886 
07887         status = NC_check_id(ncid, &ncp); 
07888         if(status != NC_NOERR)
07889                 return status;
07890 
07891         if(NC_indef(ncp))
07892                 return NC_EINDEFINE;
07893 
07894         varp = NC_lookupvar(ncp, varid);
07895         if(varp == NULL)
07896                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
07897 
07898         if(varp->ndims == 0) /* scalar variable */
07899         {
07900                 const size_t zed = 0;
07901                 return( getNCv_double(ncp, varp, &zed, 1, value) );
07902         }
07903 
07904         if(varp->type == NC_CHAR)
07905                 return NC_ECHAR;
07906 
07907 
07908         if(!IS_RECVAR(varp))
07909         {
07910                 return(getNCv_double(ncp, varp, coord_zero, *varp->dsizes, value));
07911         }
07912         /* else */
07913 
07914         if(varp->ndims == 1
07915                         && ncp->recsize <= varp->len)
07916         {
07917                 /* one dimensional && the only record variable  */
07918                 return(getNCv_double(ncp, varp, coord_zero, NC_get_numrecs(ncp),
07919                         value));
07920         }
07921         /* else */
07922 
07923         {
07924         ALLOC_ONSTACK(coord, size_t, varp->ndims);
07925         size_t elemsPerRec = 1;
07926         const size_t nrecs = NC_get_numrecs(ncp);
07927         (void) memset(coord, 0, varp->ndims * sizeof(size_t));
07928         /* TODO: fix dsizes to avoid this nonsense */
07929         if(varp->ndims > 1)
07930                 elemsPerRec = varp->dsizes[1];
07931         while(*coord < nrecs)
07932         {
07933                 const int lstatus = getNCv_double(ncp, varp, coord, elemsPerRec,
07934                                 value);
07935                 if(lstatus != NC_NOERR)
07936                 {
07937                         if(lstatus != NC_ERANGE)
07938                         {
07939                                 status = lstatus;
07940                                 /* fatal for the loop */
07941                                 break;
07942                         }
07943                         /* else NC_ERANGE, not fatal for the loop */
07944                         if(status == NC_NOERR)
07945                                 status = lstatus;
07946                 }
07947                 value += elemsPerRec;
07948                 (*coord)++;
07949         }
07950         FREE_ONSTACK(coord);
07951         } /* elemsPerRec */
07952 
07953         return status;
07954 }

07806 {
07807         int status = NC_NOERR;
07808         NC *ncp;
07809         const NC_var *varp;
07810 
07811         status = NC_check_id(ncid, &ncp); 
07812         if(status != NC_NOERR)
07813                 return status;
07814 
07815         if(NC_indef(ncp))
07816                 return NC_EINDEFINE;
07817 
07818         varp = NC_lookupvar(ncp, varid);
07819         if(varp == NULL)
07820                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
07821 
07822         if(varp->ndims == 0) /* scalar variable */
07823         {
07824                 const size_t zed = 0;
07825                 return( getNCv_float(ncp, varp, &zed, 1, value) );
07826         }
07827 
07828         if(varp->type == NC_CHAR)
07829                 return NC_ECHAR;
07830 
07831 
07832         if(!IS_RECVAR(varp))
07833         {
07834                 return(getNCv_float(ncp, varp, coord_zero, *varp->dsizes, value));
07835         }
07836         /* else */
07837 
07838         if(varp->ndims == 1
07839                         && ncp->recsize <= varp->len)
07840         {
07841                 /* one dimensional && the only record variable  */
07842                 return(getNCv_float(ncp, varp, coord_zero, NC_get_numrecs(ncp),
07843                         value));
07844         }
07845         /* else */
07846 
07847         {
07848         ALLOC_ONSTACK(coord, size_t, varp->ndims);
07849         size_t elemsPerRec = 1;
07850         const size_t nrecs = NC_get_numrecs(ncp);
07851         (void) memset(coord, 0, varp->ndims * sizeof(size_t));
07852         /* TODO: fix dsizes to avoid this nonsense */
07853         if(varp->ndims > 1)
07854                 elemsPerRec = varp->dsizes[1];
07855         while(*coord < nrecs)
07856         {
07857                 const int lstatus = getNCv_float(ncp, varp, coord, elemsPerRec,
07858                                 value);
07859                 if(lstatus != NC_NOERR)
07860                 {
07861                         if(lstatus != NC_ERANGE)
07862                         {
07863                                 status = lstatus;
07864                                 /* fatal for the loop */
07865                                 break;
07866                         }
07867                         /* else NC_ERANGE, not fatal for the loop */
07868                         if(status == NC_NOERR)
07869                                 status = lstatus;
07870                 }
07871                 value += elemsPerRec;
07872                 (*coord)++;
07873         }
07874         FREE_ONSTACK(coord);
07875         } /* elemsPerRec */
07876 
07877         return status;
07878 }

07654 {
07655         int status = NC_NOERR;
07656         NC *ncp;
07657         const NC_var *varp;
07658 
07659         status = NC_check_id(ncid, &ncp); 
07660         if(status != NC_NOERR)
07661                 return status;
07662 
07663         if(NC_indef(ncp))
07664                 return NC_EINDEFINE;
07665 
07666         varp = NC_lookupvar(ncp, varid);
07667         if(varp == NULL)
07668                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
07669 
07670         if(varp->ndims == 0) /* scalar variable */
07671         {
07672                 const size_t zed = 0;
07673                 return( getNCv_int(ncp, varp, &zed, 1, value) );
07674         }
07675 
07676         if(varp->type == NC_CHAR)
07677                 return NC_ECHAR;
07678 
07679 
07680         if(!IS_RECVAR(varp))
07681         {
07682                 return(getNCv_int(ncp, varp, coord_zero, *varp->dsizes, value));
07683         }
07684         /* else */
07685 
07686         if(varp->ndims == 1
07687                         && ncp->recsize <= varp->len)
07688         {
07689                 /* one dimensional && the only record variable  */
07690                 return(getNCv_int(ncp, varp, coord_zero, NC_get_numrecs(ncp),
07691                         value));
07692         }
07693         /* else */
07694 
07695         {
07696         ALLOC_ONSTACK(coord, size_t, varp->ndims);
07697         size_t elemsPerRec = 1;
07698         const size_t nrecs = NC_get_numrecs(ncp);
07699         (void) memset(coord, 0, varp->ndims * sizeof(size_t));
07700         /* TODO: fix dsizes to avoid this nonsense */
07701         if(varp->ndims > 1)
07702                 elemsPerRec = varp->dsizes[1];
07703         while(*coord < nrecs)
07704         {
07705                 const int lstatus = getNCv_int(ncp, varp, coord, elemsPerRec,
07706                                 value);
07707                 if(lstatus != NC_NOERR)
07708                 {
07709                         if(lstatus != NC_ERANGE)
07710                         {
07711                                 status = lstatus;
07712                                 /* fatal for the loop */
07713                                 break;
07714                         }
07715                         /* else NC_ERANGE, not fatal for the loop */
07716                         if(status == NC_NOERR)
07717                                 status = lstatus;
07718                 }
07719                 value += elemsPerRec;
07720                 (*coord)++;
07721         }
07722         FREE_ONSTACK(coord);
07723         } /* elemsPerRec */
07724 
07725         return status;
07726 }

07730 {
07731         int status = NC_NOERR;
07732         NC *ncp;
07733         const NC_var *varp;
07734 
07735         status = NC_check_id(ncid, &ncp); 
07736         if(status != NC_NOERR)
07737                 return status;
07738 
07739         if(NC_indef(ncp))
07740                 return NC_EINDEFINE;
07741 
07742         varp = NC_lookupvar(ncp, varid);
07743         if(varp == NULL)
07744                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
07745 
07746         if(varp->ndims == 0) /* scalar variable */
07747         {
07748                 const size_t zed = 0;
07749                 return( getNCv_long(ncp, varp, &zed, 1, value) );
07750         }
07751 
07752         if(varp->type == NC_CHAR)
07753                 return NC_ECHAR;
07754 
07755 
07756         if(!IS_RECVAR(varp))
07757         {
07758                 return(getNCv_long(ncp, varp, coord_zero, *varp->dsizes, value));
07759         }
07760         /* else */
07761 
07762         if(varp->ndims == 1
07763                         && ncp->recsize <= varp->len)
07764         {
07765                 /* one dimensional && the only record variable  */
07766                 return(getNCv_long(ncp, varp, coord_zero, NC_get_numrecs(ncp),
07767                         value));
07768         }
07769         /* else */
07770 
07771         {
07772         ALLOC_ONSTACK(coord, size_t, varp->ndims);
07773         size_t elemsPerRec = 1;
07774         const size_t nrecs = NC_get_numrecs(ncp);
07775         (void) memset(coord, 0, varp->ndims * sizeof(size_t));
07776         /* TODO: fix dsizes to avoid this nonsense */
07777         if(varp->ndims > 1)
07778                 elemsPerRec = varp->dsizes[1];
07779         while(*coord < nrecs)
07780         {
07781                 const int lstatus = getNCv_long(ncp, varp, coord, elemsPerRec,
07782                                 value);
07783                 if(lstatus != NC_NOERR)
07784                 {
07785                         if(lstatus != NC_ERANGE)
07786                         {
07787                                 status = lstatus;
07788                                 /* fatal for the loop */
07789                                 break;
07790                         }
07791                         /* else NC_ERANGE, not fatal for the loop */
07792                         if(status == NC_NOERR)
07793                                 status = lstatus;
07794                 }
07795                 value += elemsPerRec;
07796                 (*coord)++;
07797         }
07798         FREE_ONSTACK(coord);
07799         } /* elemsPerRec */
07800 
07801         return status;
07802 }

07578 {
07579         int status = NC_NOERR;
07580         NC *ncp;
07581         const NC_var *varp;
07582 
07583         status = NC_check_id(ncid, &ncp); 
07584         if(status != NC_NOERR)
07585                 return status;
07586 
07587         if(NC_indef(ncp))
07588                 return NC_EINDEFINE;
07589 
07590         varp = NC_lookupvar(ncp, varid);
07591         if(varp == NULL)
07592                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
07593 
07594         if(varp->ndims == 0) /* scalar variable */
07595         {
07596                 const size_t zed = 0;
07597                 return( getNCv_short(ncp, varp, &zed, 1, value) );
07598         }
07599 
07600         if(varp->type == NC_CHAR)
07601                 return NC_ECHAR;
07602 
07603 
07604         if(!IS_RECVAR(varp))
07605         {
07606                 return(getNCv_short(ncp, varp, coord_zero, *varp->dsizes, value));
07607         }
07608         /* else */
07609 
07610         if(varp->ndims == 1
07611                         && ncp->recsize <= varp->len)
07612         {
07613                 /* one dimensional && the only record variable  */
07614                 return(getNCv_short(ncp, varp, coord_zero, NC_get_numrecs(ncp),
07615                         value));
07616         }
07617         /* else */
07618 
07619         {
07620         ALLOC_ONSTACK(coord, size_t, varp->ndims);
07621         size_t elemsPerRec = 1;
07622         const size_t nrecs = NC_get_numrecs(ncp);
07623         (void) memset(coord, 0, varp->ndims * sizeof(size_t));
07624         /* TODO: fix dsizes to avoid this nonsense */
07625         if(varp->ndims > 1)
07626                 elemsPerRec = varp->dsizes[1];
07627         while(*coord < nrecs)
07628         {
07629                 const int lstatus = getNCv_short(ncp, varp, coord, elemsPerRec,
07630                                 value);
07631                 if(lstatus != NC_NOERR)
07632                 {
07633                         if(lstatus != NC_ERANGE)
07634                         {
07635                                 status = lstatus;
07636                                 /* fatal for the loop */
07637                                 break;
07638                         }
07639                         /* else NC_ERANGE, not fatal for the loop */
07640                         if(status == NC_NOERR)
07641                                 status = lstatus;
07642                 }
07643                 value += elemsPerRec;
07644                 (*coord)++;
07645         }
07646         FREE_ONSTACK(coord);
07647         } /* elemsPerRec */
07648 
07649         return status;
07650 }

07349 {
07350         int status = NC_NOERR;
07351         NC *ncp;
07352         const NC_var *varp;
07353 
07354         status = NC_check_id(ncid, &ncp); 
07355         if(status != NC_NOERR)
07356                 return status;
07357 
07358         if(NC_indef(ncp))
07359                 return NC_EINDEFINE;
07360 
07361         varp = NC_lookupvar(ncp, varid);
07362         if(varp == NULL)
07363                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
07364 
07365         if(varp->ndims == 0) /* scalar variable */
07366         {
07367                 const size_t zed = 0;
07368                 return( getNCv_text(ncp, varp, &zed, 1, value) );
07369         }
07370 
07371         if(varp->type != NC_CHAR)
07372                 return NC_ECHAR;
07373 
07374 
07375         if(!IS_RECVAR(varp))
07376         {
07377                 return(getNCv_text(ncp, varp, coord_zero, *varp->dsizes, value));
07378         }
07379         /* else */
07380 
07381         if(varp->ndims == 1
07382                         && ncp->recsize <= varp->len)
07383         {
07384                 /* one dimensional && the only record variable  */
07385                 return(getNCv_text(ncp, varp, coord_zero, NC_get_numrecs(ncp),
07386                         value));
07387         }
07388         /* else */
07389 
07390         {
07391         ALLOC_ONSTACK(coord, size_t, varp->ndims);
07392         size_t elemsPerRec = 1;
07393         const size_t nrecs = NC_get_numrecs(ncp);
07394         (void) memset(coord, 0, varp->ndims * sizeof(size_t));
07395         /* TODO: fix dsizes to avoid this nonsense */
07396         if(varp->ndims > 1)
07397                 elemsPerRec = varp->dsizes[1];
07398         while(*coord < nrecs)
07399         {
07400                 const int lstatus = getNCv_text(ncp, varp, coord, elemsPerRec,
07401                                 value);
07402                 if(lstatus != NC_NOERR)
07403                 {
07404                         if(lstatus != NC_ERANGE)
07405                         {
07406                                 status = lstatus;
07407                                 /* fatal for the loop */
07408                                 break;
07409                         }
07410                         /* else NC_ERANGE, not fatal for the loop */
07411                         if(status == NC_NOERR)
07412                                 status = lstatus;
07413                 }
07414                 value += elemsPerRec;
07415                 (*coord)++;
07416         }
07417         FREE_ONSTACK(coord);
07418         } /* elemsPerRec */
07419 
07420         return status;
07421 }

06562 {
06563         int status = NC_NOERR;
06564         NC *ncp;
06565         const NC_var *varp;
06566         int ii;
06567         size_t iocount;
06568 
06569         status = NC_check_id(ncid, &ncp); 
06570         if(status != NC_NOERR)
06571                 return status;
06572 
06573         if(NC_indef(ncp))
06574                 return NC_EINDEFINE;
06575 
06576         varp = NC_lookupvar(ncp, varid);
06577         if(varp == NULL)
06578                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
06579 
06580         if(varp->type == NC_CHAR)
06581                 return NC_ECHAR;
06582 
06583         status = NCcoordck(ncp, varp, start);
06584         if(status != NC_NOERR)
06585                 return status;
06586         status = NCedgeck(ncp, varp, start, edges);
06587         if(status != NC_NOERR)
06588                 return status;
06589 
06590         if(varp->ndims == 0) /* scalar variable */
06591         {
06592                 return( getNCv_double(ncp, varp, start, 1, value) );
06593         }
06594 
06595         if(IS_RECVAR(varp))
06596         {
06597                 if(*start + *edges > NC_get_numrecs(ncp))
06598                         return NC_EEDGE;
06599                 if(varp->ndims == 1 && ncp->recsize <= varp->len)
06600                 {
06601                         /* one dimensional && the only record variable  */
06602                         return( getNCv_double(ncp, varp, start, *edges, value) );
06603                 }
06604         }
06605 
06606         /*
06607          * find max contiguous
06608          *   and accumulate max count for a single io operation
06609          */
06610         ii = NCiocount(ncp, varp, edges, &iocount);
06611 
06612         if(ii == -1)
06613         {
06614                 return( getNCv_double(ncp, varp, start, iocount, value) );
06615         }
06616 
06617         assert(ii >= 0);
06618 
06619 
06620         { /* inline */
06621         ALLOC_ONSTACK(coord, size_t, varp->ndims);
06622         ALLOC_ONSTACK(upper, size_t, varp->ndims);
06623         const size_t index = ii;
06624 
06625         /* copy in starting indices */
06626         (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
06627 
06628         /* set up in maximum indices */
06629         set_upper(upper, start, edges, &upper[varp->ndims]);
06630 
06631         /* ripple counter */
06632         while(*coord < *upper)
06633         {
06634                 const int lstatus = getNCv_double(ncp, varp, coord, iocount,
06635                                 value);
06636                 if(lstatus != NC_NOERR)
06637                 {
06638                         if(lstatus != NC_ERANGE)
06639                         {
06640                                 status = lstatus;
06641                                 /* fatal for the loop */
06642                                 break;
06643                         }
06644                         /* else NC_ERANGE, not fatal for the loop */
06645                         if(status == NC_NOERR)
06646                                 status = lstatus;
06647                 }
06648                 value += iocount;
06649                 odo1(start, upper, coord, &upper[index], &coord[index]);
06650         }
06651 
06652         FREE_ONSTACK(upper);
06653         FREE_ONSTACK(coord);
06654         } /* end inline */
06655 
06656         return status;
06657 }

06462 {
06463         int status = NC_NOERR;
06464         NC *ncp;
06465         const NC_var *varp;
06466         int ii;
06467         size_t iocount;
06468 
06469         status = NC_check_id(ncid, &ncp); 
06470         if(status != NC_NOERR)
06471                 return status;
06472 
06473         if(NC_indef(ncp))
06474                 return NC_EINDEFINE;
06475 
06476         varp = NC_lookupvar(ncp, varid);
06477         if(varp == NULL)
06478                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
06479 
06480         if(varp->type == NC_CHAR)
06481                 return NC_ECHAR;
06482 
06483         status = NCcoordck(ncp, varp, start);
06484         if(status != NC_NOERR)
06485                 return status;
06486         status = NCedgeck(ncp, varp, start, edges);
06487         if(status != NC_NOERR)
06488                 return status;
06489 
06490         if(varp->ndims == 0) /* scalar variable */
06491         {
06492                 return( getNCv_float(ncp, varp, start, 1, value) );
06493         }
06494 
06495         if(IS_RECVAR(varp))
06496         {
06497                 if(*start + *edges > NC_get_numrecs(ncp))
06498                         return NC_EEDGE;
06499                 if(varp->ndims == 1 && ncp->recsize <= varp->len)
06500                 {
06501                         /* one dimensional && the only record variable  */
06502                         return( getNCv_float(ncp, varp, start, *edges, value) );
06503                 }
06504         }
06505 
06506         /*
06507          * find max contiguous
06508          *   and accumulate max count for a single io operation
06509          */
06510         ii = NCiocount(ncp, varp, edges, &iocount);
06511 
06512         if(ii == -1)
06513         {
06514                 return( getNCv_float(ncp, varp, start, iocount, value) );
06515         }
06516 
06517         assert(ii >= 0);
06518 
06519 
06520         { /* inline */
06521         ALLOC_ONSTACK(coord, size_t, varp->ndims);
06522         ALLOC_ONSTACK(upper, size_t, varp->ndims);
06523         const size_t index = ii;
06524 
06525         /* copy in starting indices */
06526         (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
06527 
06528         /* set up in maximum indices */
06529         set_upper(upper, start, edges, &upper[varp->ndims]);
06530 
06531         /* ripple counter */
06532         while(*coord < *upper)
06533         {
06534                 const int lstatus = getNCv_float(ncp, varp, coord, iocount,
06535                                 value);
06536                 if(lstatus != NC_NOERR)
06537                 {
06538                         if(lstatus != NC_ERANGE)
06539                         {
06540                                 status = lstatus;
06541                                 /* fatal for the loop */
06542                                 break;
06543                         }
06544                         /* else NC_ERANGE, not fatal for the loop */
06545                         if(status == NC_NOERR)
06546                                 status = lstatus;
06547                 }
06548                 value += iocount;
06549                 odo1(start, upper, coord, &upper[index], &coord[index]);
06550         }
06551 
06552         FREE_ONSTACK(upper);
06553         FREE_ONSTACK(coord);
06554         } /* end inline */
06555 
06556         return status;
06557 }

06262 {
06263         int status = NC_NOERR;
06264         NC *ncp;
06265         const NC_var *varp;
06266         int ii;
06267         size_t iocount;
06268 
06269         status = NC_check_id(ncid, &ncp); 
06270         if(status != NC_NOERR)
06271                 return status;
06272 
06273         if(NC_indef(ncp))
06274                 return NC_EINDEFINE;
06275 
06276         varp = NC_lookupvar(ncp, varid);
06277         if(varp == NULL)
06278                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
06279 
06280         if(varp->type == NC_CHAR)
06281                 return NC_ECHAR;
06282 
06283         status = NCcoordck(ncp, varp, start);
06284         if(status != NC_NOERR)
06285                 return status;
06286         status = NCedgeck(ncp, varp, start, edges);
06287         if(status != NC_NOERR)
06288                 return status;
06289 
06290         if(varp->ndims == 0) /* scalar variable */
06291         {
06292                 return( getNCv_int(ncp, varp, start, 1, value) );
06293         }
06294 
06295         if(IS_RECVAR(varp))
06296         {
06297                 if(*start + *edges > NC_get_numrecs(ncp))
06298                         return NC_EEDGE;
06299                 if(varp->ndims == 1 && ncp->recsize <= varp->len)
06300                 {
06301                         /* one dimensional && the only record variable  */
06302                         return( getNCv_int(ncp, varp, start, *edges, value) );
06303                 }
06304         }
06305 
06306         /*
06307          * find max contiguous
06308          *   and accumulate max count for a single io operation
06309          */
06310         ii = NCiocount(ncp, varp, edges, &iocount);
06311 
06312         if(ii == -1)
06313         {
06314                 return( getNCv_int(ncp, varp, start, iocount, value) );
06315         }
06316 
06317         assert(ii >= 0);
06318 
06319 
06320         { /* inline */
06321         ALLOC_ONSTACK(coord, size_t, varp->ndims);
06322         ALLOC_ONSTACK(upper, size_t, varp->ndims);
06323         const size_t index = ii;
06324 
06325         /* copy in starting indices */
06326         (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
06327 
06328         /* set up in maximum indices */
06329         set_upper(upper, start, edges, &upper[varp->ndims]);
06330 
06331         /* ripple counter */
06332         while(*coord < *upper)
06333         {
06334                 const int lstatus = getNCv_int(ncp, varp, coord, iocount,
06335                                 value);
06336                 if(lstatus != NC_NOERR)
06337                 {
06338                         if(lstatus != NC_ERANGE)
06339                         {
06340                                 status = lstatus;
06341                                 /* fatal for the loop */
06342                                 break;
06343                         }
06344                         /* else NC_ERANGE, not fatal for the loop */
06345                         if(status == NC_NOERR)
06346                                 status = lstatus;
06347                 }
06348                 value += iocount;
06349                 odo1(start, upper, coord, &upper[index], &coord[index]);
06350         }
06351 
06352         FREE_ONSTACK(upper);
06353         FREE_ONSTACK(coord);
06354         } /* end inline */
06355 
06356         return status;
06357 }

06362 {
06363         int status = NC_NOERR;
06364         NC *ncp;
06365         const NC_var *varp;
06366         int ii;
06367         size_t iocount;
06368 
06369         status = NC_check_id(ncid, &ncp); 
06370         if(status != NC_NOERR)
06371                 return status;
06372 
06373         if(NC_indef(ncp))
06374                 return NC_EINDEFINE;
06375 
06376         varp = NC_lookupvar(ncp, varid);
06377         if(varp == NULL)
06378                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
06379 
06380         if(varp->type == NC_CHAR)
06381                 return NC_ECHAR;
06382 
06383         status = NCcoordck(ncp, varp, start);
06384         if(status != NC_NOERR)
06385                 return status;
06386         status = NCedgeck(ncp, varp, start, edges);
06387         if(status != NC_NOERR)
06388                 return status;
06389 
06390         if(varp->ndims == 0) /* scalar variable */
06391         {
06392                 return( getNCv_long(ncp, varp, start, 1, value) );
06393         }
06394 
06395         if(IS_RECVAR(varp))
06396         {
06397                 if(*start + *edges > NC_get_numrecs(ncp))
06398                         return NC_EEDGE;
06399                 if(varp->ndims == 1 && ncp->recsize <= varp->len)
06400                 {
06401                         /* one dimensional && the only record variable  */
06402                         return( getNCv_long(ncp, varp, start, *edges, value) );
06403                 }
06404         }
06405 
06406         /*
06407          * find max contiguous
06408          *   and accumulate max count for a single io operation
06409          */
06410         ii = NCiocount(ncp, varp, edges, &iocount);
06411 
06412         if(ii == -1)
06413         {
06414                 return( getNCv_long(ncp, varp, start, iocount, value) );
06415         }
06416 
06417         assert(ii >= 0);
06418 
06419 
06420         { /* inline */
06421         ALLOC_ONSTACK(coord, size_t, varp->ndims);
06422         ALLOC_ONSTACK(upper, size_t, varp->ndims);
06423         const size_t index = ii;
06424 
06425         /* copy in starting indices */
06426         (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
06427 
06428         /* set up in maximum indices */
06429         set_upper(upper, start, edges, &upper[varp->ndims]);
06430 
06431         /* ripple counter */
06432         while(*coord < *upper)
06433         {
06434                 const int lstatus = getNCv_long(ncp, varp, coord, iocount,
06435                                 value);
06436                 if(lstatus != NC_NOERR)
06437                 {
06438                         if(lstatus != NC_ERANGE)
06439                         {
06440                                 status = lstatus;
06441                                 /* fatal for the loop */
06442                                 break;
06443                         }
06444                         /* else NC_ERANGE, not fatal for the loop */
06445                         if(status == NC_NOERR)
06446                                 status = lstatus;
06447                 }
06448                 value += iocount;
06449                 odo1(start, upper, coord, &upper[index], &coord[index]);
06450         }
06451 
06452         FREE_ONSTACK(upper);
06453         FREE_ONSTACK(coord);
06454         } /* end inline */
06455 
06456         return status;
06457 }

06162 {
06163         int status = NC_NOERR;
06164         NC *ncp;
06165         const NC_var *varp;
06166         int ii;
06167         size_t iocount;
06168 
06169         status = NC_check_id(ncid, &ncp); 
06170         if(status != NC_NOERR)
06171                 return status;
06172 
06173         if(NC_indef(ncp))
06174                 return NC_EINDEFINE;
06175 
06176         varp = NC_lookupvar(ncp, varid);
06177         if(varp == NULL)
06178                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
06179 
06180         if(varp->type == NC_CHAR)
06181                 return NC_ECHAR;
06182 
06183         status = NCcoordck(ncp, varp, start);
06184         if(status != NC_NOERR)
06185                 return status;
06186         status = NCedgeck(ncp, varp, start, edges);
06187         if(status != NC_NOERR)
06188                 return status;
06189 
06190         if(varp->ndims == 0) /* scalar variable */
06191         {
06192                 return( getNCv_short(ncp, varp, start, 1, value) );
06193         }
06194 
06195         if(IS_RECVAR(varp))
06196         {
06197                 if(*start + *edges > NC_get_numrecs(ncp))
06198                         return NC_EEDGE;
06199                 if(varp->ndims == 1 && ncp->recsize <= varp->len)
06200                 {
06201                         /* one dimensional && the only record variable  */
06202                         return( getNCv_short(ncp, varp, start, *edges, value) );
06203                 }
06204         }
06205 
06206         /*
06207          * find max contiguous
06208          *   and accumulate max count for a single io operation
06209          */
06210         ii = NCiocount(ncp, varp, edges, &iocount);
06211 
06212         if(ii == -1)
06213         {
06214                 return( getNCv_short(ncp, varp, start, iocount, value) );
06215         }
06216 
06217         assert(ii >= 0);
06218 
06219 
06220         { /* inline */
06221         ALLOC_ONSTACK(coord, size_t, varp->ndims);
06222         ALLOC_ONSTACK(upper, size_t, varp->ndims);
06223         const size_t index = ii;
06224 
06225         /* copy in starting indices */
06226         (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
06227 
06228         /* set up in maximum indices */
06229         set_upper(upper, start, edges, &upper[varp->ndims]);
06230 
06231         /* ripple counter */
06232         while(*coord < *upper)
06233         {
06234                 const int lstatus = getNCv_short(ncp, varp, coord, iocount,
06235                                 value);
06236                 if(lstatus != NC_NOERR)
06237                 {
06238                         if(lstatus != NC_ERANGE)
06239                         {
06240                                 status = lstatus;
06241                                 /* fatal for the loop */
06242                                 break;
06243                         }
06244                         /* else NC_ERANGE, not fatal for the loop */
06245                         if(status == NC_NOERR)
06246                                 status = lstatus;
06247                 }
06248                 value += iocount;
06249                 odo1(start, upper, coord, &upper[index], &coord[index]);
06250         }
06251 
06252         FREE_ONSTACK(upper);
06253         FREE_ONSTACK(coord);
06254         } /* end inline */
06255 
06256         return status;
06257 }

05861 {
05862         int status = NC_NOERR;
05863         NC *ncp;
05864         const NC_var *varp;
05865         int ii;
05866         size_t iocount;
05867 
05868         status = NC_check_id(ncid, &ncp); 
05869         if(status != NC_NOERR)
05870                 return status;
05871 
05872         if(NC_indef(ncp))
05873                 return NC_EINDEFINE;
05874 
05875         varp = NC_lookupvar(ncp, varid);
05876         if(varp == NULL)
05877                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
05878 
05879         if(varp->type != NC_CHAR)
05880                 return NC_ECHAR;
05881 
05882         status = NCcoordck(ncp, varp, start);
05883         if(status != NC_NOERR)
05884                 return status;
05885         status = NCedgeck(ncp, varp, start, edges);
05886         if(status != NC_NOERR)
05887                 return status;
05888 
05889         if(varp->ndims == 0) /* scalar variable */
05890         {
05891                 return( getNCv_text(ncp, varp, start, 1, value) );
05892         }
05893 
05894         if(IS_RECVAR(varp))
05895         {
05896                 if(*start + *edges > NC_get_numrecs(ncp))
05897                         return NC_EEDGE;
05898                 if(varp->ndims == 1 && ncp->recsize <= varp->len)
05899                 {
05900                         /* one dimensional && the only record variable  */
05901                         return( getNCv_text(ncp, varp, start, *edges, value) );
05902                 }
05903         }
05904 
05905         /*
05906          * find max contiguous
05907          *   and accumulate max count for a single io operation
05908          */
05909         ii = NCiocount(ncp, varp, edges, &iocount);
05910 
05911         if(ii == -1)
05912         {
05913                 return( getNCv_text(ncp, varp, start, iocount, value) );
05914         }
05915 
05916         assert(ii >= 0);
05917 
05918 
05919         { /* inline */
05920         ALLOC_ONSTACK(coord, size_t, varp->ndims);
05921         ALLOC_ONSTACK(upper, size_t, varp->ndims);
05922         const size_t index = ii;
05923 
05924         /* copy in starting indices */
05925         (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
05926 
05927         /* set up in maximum indices */
05928         set_upper(upper, start, edges, &upper[varp->ndims]);
05929 
05930         /* ripple counter */
05931         while(*coord < *upper)
05932         {
05933                 const int lstatus = getNCv_text(ncp, varp, coord, iocount,
05934                                 value);
05935                 if(lstatus != NC_NOERR)
05936                 {
05937                         if(lstatus != NC_ERANGE)
05938                         {
05939                                 status = lstatus;
05940                                 /* fatal for the loop */
05941                                 break;
05942                         }
05943                         /* else NC_ERANGE, not fatal for the loop */
05944                         if(status == NC_NOERR)
05945                                 status = lstatus;
05946                 }
05947                 value += iocount;
05948                 odo1(start, upper, coord, &upper[index], &coord[index]);
05949         }
05950 
05951         FREE_ONSTACK(upper);
05952         FREE_ONSTACK(coord);
05953         } /* end inline */
05954 
05955         return status;
05956 }

09523 {
09524         int status = ENOERR;
09525         NC *ncp;
09526         NC_var *varp;
09527         int maxidim;    /* maximum dimensional index */
09528 
09529         status = NC_check_id (ncid, &ncp);
09530         if (status != NC_NOERR)
09531                 return status;
09532 
09533         if (NC_indef (ncp))
09534         {
09535                 return NC_EINDEFINE;
09536         }
09537 
09538         varp = NC_lookupvar (ncp, varid);
09539         if (varp == NULL)
09540                 return NC_ENOTVAR;
09541 
09542         if(varp->type == NC_CHAR)
09543                 return NC_ECHAR;
09544 
09545         maxidim = (int) varp->ndims - 1;
09546 
09547         if (maxidim < 0)
09548         {
09549                 /*
09550                  * The variable is a scalar; consequently,
09551                  * there s only one thing to get and only one place to put it.
09552                  * (Why was I called?)
09553                  */
09554                 return getNCv_double (ncp, varp, start, 1, value);
09555         }
09556         
09557         /*
09558          * else
09559          * The variable is an array.
09560          */
09561         {
09562                 int idim;
09563                 size_t *mystart = NULL;
09564                 size_t *myedges;
09565                 size_t *iocount;        /* count vector */
09566                 size_t *stop;   /* stop indexes */
09567                 size_t *length; /* edge lengths in bytes */
09568                 ptrdiff_t *mystride;
09569                 ptrdiff_t *mymap;
09570 
09571                 /*
09572                  * Verify stride argument.
09573                  */
09574                 for (idim = 0; idim <= maxidim; ++idim)
09575                 {
09576                         if (stride != NULL
09577                                 && (stride[idim] == 0
09578                 /* cast needed for braindead systems with signed size_t */
09579                                 || (unsigned long) stride[idim] >= X_INT_MAX))
09580                         {
09581                                 return NC_ESTRIDE;
09582                         }
09583                 }
09584 
09585                 /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
09586                 mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t));
09587                 if(mystart == NULL)
09588                         return NC_ENOMEM;
09589                 myedges = mystart + varp->ndims;
09590                 iocount = myedges + varp->ndims;
09591                 stop = iocount + varp->ndims;
09592                 length = stop + varp->ndims;
09593                 mystride = (ptrdiff_t *)(length + varp->ndims);
09594                 mymap = mystride + varp->ndims;
09595 
09596                 /*
09597                  * Initialize I/O parameters.
09598                  */
09599                 for (idim = maxidim; idim >= 0; --idim)
09600                 {
09601                         mystart[idim] = start != NULL
09602                                 ? start[idim]
09603                                 : 0;
09604 
09605                         if (edges[idim] == 0)
09606                         {
09607                                 status = NC_NOERR;      /* read/write no data */
09608                                 goto done;
09609                         }
09610 
09611                         myedges[idim] = edges != NULL
09612                                 ? edges[idim]
09613                                 : idim == 0 && IS_RECVAR (varp)
09614                                 ? NC_get_numrecs(ncp) - mystart[idim]
09615                                 : varp->shape[idim] - mystart[idim];
09616                         mystride[idim] = stride != NULL
09617                                 ? stride[idim]
09618                                 : 1;
09619                         mymap[idim] = map != NULL
09620                                 ? map[idim]
09621                                 : idim == maxidim
09622                                 ? 1
09623                                 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
09624 
09625                         iocount[idim] = 1;
09626                         length[idim] = mymap[idim] * myedges[idim];
09627                         stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
09628                 }
09629 
09630                 /*
09631                  * Check start, edges
09632                  */
09633                 for (idim = maxidim; idim >= 0; --idim)
09634                 {
09635                         size_t dimlen = 
09636                                 idim == 0 && IS_RECVAR (varp)
09637                                         ? NC_get_numrecs(ncp)
09638                                           : varp->shape[idim];
09639                         if (mystart[idim] >= dimlen)
09640                         {
09641                                 status = NC_EINVALCOORDS;
09642                                 goto done;
09643                         }
09644 
09645                         if (mystart[idim] + myedges[idim] > dimlen)
09646                         {
09647                                 status = NC_EEDGE;
09648                                 goto done;
09649                         }
09650 
09651                 }
09652                 /*
09653                  * As an optimization, adjust I/O parameters when the fastest 
09654                  * dimension has unity stride both externally and internally.
09655                  * In this case, the user could have called a simpler routine
09656                  * (i.e. ncvarnc_get_vara_double()
09657                  */
09658                 if (mystride[maxidim] == 1
09659                         && mymap[maxidim] == 1)
09660                 {
09661                         iocount[maxidim] = myedges[maxidim];
09662                         mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
09663                         mymap[maxidim] = (ptrdiff_t) length[maxidim];
09664                 }
09665 
09666                 /*
09667                  * Perform I/O.  Exit when done.
09668                  */
09669                 for (;;)
09670                 {
09671                         /* TODO: */
09672                         int lstatus = nc_get_vara_double (ncid, varid, mystart, iocount,
09673                                                 value);
09674                         if (lstatus != NC_NOERR 
09675                                 && (status == NC_NOERR || lstatus != NC_ERANGE))
09676                                 status = lstatus;
09677 
09678                         /*
09679                          * The following code permutes through the variable s
09680                          * external start-index space and it s internal address
09681                          * space.  At the UPC, this algorithm is commonly
09682                          * called "odometer code".
09683                          */
09684                         idim = maxidim;
09685                 carry:
09686                         value += mymap[idim];
09687                         mystart[idim] += mystride[idim];
09688                         if (mystart[idim] == stop[idim])
09689                         {
09690                                 mystart[idim] = start[idim];
09691                                 value -= length[idim];
09692                                 if (--idim < 0)
09693                                         break; /* normal return */
09694                                 goto carry;
09695                         }
09696                 } /* I/O loop */
09697         done:
09698                 free(mystart);
09699         } /* variable is array */
09700         return status;
09701 
09702 }

09336 {
09337         int status = ENOERR;
09338         NC *ncp;
09339         NC_var *varp;
09340         int maxidim;    /* maximum dimensional index */
09341 
09342         status = NC_check_id (ncid, &ncp);
09343         if (status != NC_NOERR)
09344                 return status;
09345 
09346         if (NC_indef (ncp))
09347         {
09348                 return NC_EINDEFINE;
09349         }
09350 
09351         varp = NC_lookupvar (ncp, varid);
09352         if (varp == NULL)
09353                 return NC_ENOTVAR;
09354 
09355         if(varp->type == NC_CHAR)
09356                 return NC_ECHAR;
09357 
09358         maxidim = (int) varp->ndims - 1;
09359 
09360         if (maxidim < 0)
09361         {
09362                 /*
09363                  * The variable is a scalar; consequently,
09364                  * there s only one thing to get and only one place to put it.
09365                  * (Why was I called?)
09366                  */
09367                 return getNCv_float (ncp, varp, start, 1, value);
09368         }
09369         
09370         /*
09371          * else
09372          * The variable is an array.
09373          */
09374         {
09375                 int idim;
09376                 size_t *mystart = NULL;
09377                 size_t *myedges;
09378                 size_t *iocount;        /* count vector */
09379                 size_t *stop;   /* stop indexes */
09380                 size_t *length; /* edge lengths in bytes */
09381                 ptrdiff_t *mystride;
09382                 ptrdiff_t *mymap;
09383 
09384                 /*
09385                  * Verify stride argument.
09386                  */
09387                 for (idim = 0; idim <= maxidim; ++idim)
09388                 {
09389                         if (stride != NULL
09390                                 && (stride[idim] == 0
09391                 /* cast needed for braindead systems with signed size_t */
09392                                 || (unsigned long) stride[idim] >= X_INT_MAX))
09393                         {
09394                                 return NC_ESTRIDE;
09395                         }
09396                 }
09397 
09398                 /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
09399                 mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t));
09400                 if(mystart == NULL)
09401                         return NC_ENOMEM;
09402                 myedges = mystart + varp->ndims;
09403                 iocount = myedges + varp->ndims;
09404                 stop = iocount + varp->ndims;
09405                 length = stop + varp->ndims;
09406                 mystride = (ptrdiff_t *)(length + varp->ndims);
09407                 mymap = mystride + varp->ndims;
09408 
09409                 /*
09410                  * Initialize I/O parameters.
09411                  */
09412                 for (idim = maxidim; idim >= 0; --idim)
09413                 {
09414                         mystart[idim] = start != NULL
09415                                 ? start[idim]
09416                                 : 0;
09417 
09418                         if (edges[idim] == 0)
09419                         {
09420                                 status = NC_NOERR;      /* read/write no data */
09421                                 goto done;
09422                         }
09423 
09424                         myedges[idim] = edges != NULL
09425                                 ? edges[idim]
09426                                 : idim == 0 && IS_RECVAR (varp)
09427                                 ? NC_get_numrecs(ncp) - mystart[idim]
09428                                 : varp->shape[idim] - mystart[idim];
09429                         mystride[idim] = stride != NULL
09430                                 ? stride[idim]
09431                                 : 1;
09432                         mymap[idim] = map != NULL
09433                                 ? map[idim]
09434                                 : idim == maxidim
09435                                 ? 1
09436                                 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
09437 
09438                         iocount[idim] = 1;
09439                         length[idim] = mymap[idim] * myedges[idim];
09440                         stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
09441                 }
09442 
09443                 /*
09444                  * Check start, edges
09445                  */
09446                 for (idim = maxidim; idim >= 0; --idim)
09447                 {
09448                         size_t dimlen = 
09449                                 idim == 0 && IS_RECVAR (varp)
09450                                         ? NC_get_numrecs(ncp)
09451                                           : varp->shape[idim];
09452                         if (mystart[idim] >= dimlen)
09453                         {
09454                                 status = NC_EINVALCOORDS;
09455                                 goto done;
09456                         }
09457 
09458                         if (mystart[idim] + myedges[idim] > dimlen)
09459                         {
09460                                 status = NC_EEDGE;
09461                                 goto done;
09462                         }
09463 
09464                 }
09465                 /*
09466                  * As an optimization, adjust I/O parameters when the fastest 
09467                  * dimension has unity stride both externally and internally.
09468                  * In this case, the user could have called a simpler routine
09469                  * (i.e. ncvarnc_get_vara_float()
09470                  */
09471                 if (mystride[maxidim] == 1
09472                         && mymap[maxidim] == 1)
09473                 {
09474                         iocount[maxidim] = myedges[maxidim];
09475                         mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
09476                         mymap[maxidim] = (ptrdiff_t) length[maxidim];
09477                 }
09478 
09479                 /*
09480                  * Perform I/O.  Exit when done.
09481                  */
09482                 for (;;)
09483                 {
09484                         /* TODO: */
09485                         int lstatus = nc_get_vara_float (ncid, varid, mystart, iocount,
09486                                                 value);
09487                         if (lstatus != NC_NOERR 
09488                                 && (status == NC_NOERR || lstatus != NC_ERANGE))
09489                                 status = lstatus;
09490 
09491                         /*
09492                          * The following code permutes through the variable s
09493                          * external start-index space and it s internal address
09494                          * space.  At the UPC, this algorithm is commonly
09495                          * called "odometer code".
09496                          */
09497                         idim = maxidim;
09498                 carry:
09499                         value += mymap[idim];
09500                         mystart[idim] += mystride[idim];
09501                         if (mystart[idim] == stop[idim])
09502                         {
09503                                 mystart[idim] = start[idim];
09504                                 value -= length[idim];
09505                                 if (--idim < 0)
09506                                         break; /* normal return */
09507                                 goto carry;
09508                         }
09509                 } /* I/O loop */
09510         done:
09511                 free(mystart);
09512         } /* variable is array */
09513         return status;
09514 
09515 }

08962 {
08963         int status = ENOERR;
08964         NC *ncp;
08965         NC_var *varp;
08966         int maxidim;    /* maximum dimensional index */
08967 
08968         status = NC_check_id (ncid, &ncp);
08969         if (status != NC_NOERR)
08970                 return status;
08971 
08972         if (NC_indef (ncp))
08973         {
08974                 return NC_EINDEFINE;
08975         }
08976 
08977         varp = NC_lookupvar (ncp, varid);
08978         if (varp == NULL)
08979                 return NC_ENOTVAR;
08980 
08981         if(varp->type == NC_CHAR)
08982                 return NC_ECHAR;
08983 
08984         maxidim = (int) varp->ndims - 1;
08985 
08986         if (maxidim < 0)
08987         {
08988                 /*
08989                  * The variable is a scalar; consequently,
08990                  * there s only one thing to get and only one place to put it.
08991                  * (Why was I called?)
08992                  */
08993                 return getNCv_int (ncp, varp, start, 1, value);
08994         }
08995         
08996         /*
08997          * else
08998          * The variable is an array.
08999          */
09000         {
09001                 int idim;
09002                 size_t *mystart = NULL;
09003                 size_t *myedges;
09004                 size_t *iocount;        /* count vector */
09005                 size_t *stop;   /* stop indexes */
09006                 size_t *length; /* edge lengths in bytes */
09007                 ptrdiff_t *mystride;
09008                 ptrdiff_t *mymap;
09009 
09010                 /*
09011                  * Verify stride argument.
09012                  */
09013                 for (idim = 0; idim <= maxidim; ++idim)
09014                 {
09015                         if (stride != NULL
09016                                 && (stride[idim] == 0
09017                 /* cast needed for braindead systems with signed size_t */
09018                                 || (unsigned long) stride[idim] >= X_INT_MAX))
09019                         {
09020                                 return NC_ESTRIDE;
09021                         }
09022                 }
09023 
09024                 /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
09025                 mystart = (size_t *)calloc(varp->ndims * 7, sizeof(ptrdiff_t));
09026                 if(mystart == NULL)
09027                         return NC_ENOMEM;
09028                 myedges = mystart + varp->ndims;
09029                 iocount = myedges + varp->ndims;
09030                 stop = iocount + varp->ndims;
09031                 length = stop + varp->ndims;
09032                 mystride = (ptrdiff_t *)(length + varp->ndims);
09033                 mymap = mystride + varp->ndims;
09034 
09035                 /*
09036                  * Initialize I/O parameters.
09037                  */
09038                 for (idim = maxidim; idim >= 0; --idim)
09039                 {
09040                         mystart[idim] = start != NULL
09041                                 ? start[idim]
09042                                 : 0;
09043 
09044                         if (edges[idim] == 0)
09045                         {
09046                                 status = NC_NOERR;      /* read/write no data */
09047                                 goto done;
09048                         }
09049 
09050                         myedges[idim] = edges != NULL
09051                                 ? edges[idim]
09052                                 : idim == 0 && IS_RECVAR (varp)
09053                                 ? NC_get_numrecs(ncp) - mystart[idim]
09054                                 : varp->shape[idim] - mystart[idim];
09055                         mystride[idim] = stride != NULL
09056                                 ? stride[idim]
09057                                 : 1;
09058                         mymap[idim] = map != NULL
09059                                 ? map[idim]
09060                                 : idim == maxidim
09061                                 ? 1
09062                                 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
09063 
09064                         iocount[idim] = 1;
09065                         length[idim] = mymap[idim] * myedges[idim];
09066                         stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
09067                 }
09068 
09069                 /*
09070                  * Check start, edges
09071                  */
09072                 for (idim = maxidim; idim >= 0; --idim)
09073                 {
09074                         size_t dimlen = 
09075                                 idim == 0 && IS_RECVAR (varp)
09076                                         ? NC_get_numrecs(ncp)
09077                                           : varp->shape[idim];
09078                         if (mystart[idim] >= dimlen)
09079                         {
09080                                 status = NC_EINVALCOORDS;
09081                                 goto done;
09082                         }
09083 
09084                         if (mystart[idim] + myedges[idim] > dimlen)
09085                         {
09086                                 status = NC_EEDGE;
09087                                 goto done;
09088                         }
09089 
09090                 }
09091                 /*
09092                  * As an optimization, adjust I/O parameters when the fastest 
09093                  * dimension has unity stride both externally and internally.
09094                  * In this case, the user could have called a simpler routine
09095                  * (i.e. ncvarnc_get_vara_int()
09096                  */
09097                 if (mystride[maxidim] == 1
09098                         && mymap[maxidim] == 1)
09099                 {
09100                         iocount[maxidim] = myedges[maxidim];
09101                         mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
09102                         mymap[maxidim] = (ptrdiff_t) length[maxidim];
09103                 }
09104 
09105                 /*
09106                  * Perform I/O.  Exit when done.
09107                  */
09108                 for (;;)
09109                 {
09110                         /* TODO: */
09111                         int lstatus = nc_get_vara_int (ncid, varid, mystart, iocount,
09112                                                 value);
09113                         if (lstatus != NC_NOERR 
09114                                 && (status == NC_NOERR || lstatus != NC_ERANGE))
09115                                 status = lstatus;
09116 
09117                         /*
09118                          * The following code permutes through the variable s
09119                          * external start-index space and it s internal address
09120                          * space.  At the UPC, this algorithm is commonly
09121                          * called "odometer code".
09122                          */
09123                         idim = maxidim;
09124                 carry:
09125                         value += mymap[idim];
09126                         mystart[idim] += mystride[idim];
09127                         if (mystart[idim] == stop[idim])
09128                         {
09129                                 mystart[idim] = start[idim];
09130                                 value -= length[idim];
09131                                 if (--idim < 0)
09132                                         break; /* normal return */
09133                                 goto carry;
09134                         }
09135                 } /* I/O loop */
09136         done:
09137                 free(mystart);
09138         } /* variable is array */
09139         return status;
09140 
09141 }