1/* Do not edit this file. It is produced from the corresponding .m4 source */
2/*
3 * Copyright 1996, University Corporation for Atmospheric Research
4 *      See netcdf/COPYRIGHT file for copying and redistribution conditions.
5 */
6/* $Id: putget.m4 2783 2014-10-26 05:19:35Z wkliao $ */
7
8#include "config.h"
9#include <string.h>
10#include <stdlib.h>
11#include <assert.h>
12
13#include "netcdf.h"
14#include "nc3internal.h"
15#include "ncx.h"
16#include "fbits.h"
17#include "onstack.h"
18#ifdef LOCKNUMREC
19#  include <mpp/shmem.h> /* for SGI/Cray SHMEM routines */
20#  ifdef LN_TEST
21#    include <stdio.h>
22#  endif
23#endif
24#include "nc3dispatch.h"
25
26
27#undef MIN  /* system may define MIN somewhere and complain */
28#define MIN(mm,nn) (((mm) < (nn)) ? (mm) : (nn))
29
30static int
31readNCv(const NC3_INFOncp, const NC_varvarp, const size_t* start,
32        const size_t nelems, void* value, const nc_type memtype);
33static int
34writeNCv(NC3_INFOncp, const NC_varvarp, const size_t* start,
35         const size_t nelems, const void* value, const nc_type memtype);
36
37
38/* #define ODEBUG 1 */
39
40#if ODEBUG
41#include <stdio.h>
42/*
43 * Print the values of an array of size_t
44 */
45void
46arrayp(const char *label, size_t count, const size_t *array)
47{
48 (void) fprintf(stderr, "%s", label);
49 (void) fputc('\t',stderr);
50 for(; count > 0; count--, array++)
51 (void) fprintf(stderr," %lu", (unsigned long)*array);
52 (void) fputc('\n',stderr);
53}
54#endif /* ODEBUG */
55
56
57/* Begin fill */
58/*
59 * This is tunable parameter.
60 * It essentially controls the tradeoff between the number of times
61 * memcpy() gets called to copy the external data to fill
62 * a large buffer vs the number of times its called to
63 * prepare the external data.
64 */
65#if _SX
66/* NEC SX specific optimization */
67#define NFILL 2048
68#else
69#define NFILL 16
70#endif
71
72
73
74/*
75 * Next 6 type specific functions
76 * Fill a some memory with the default special value.
77 * Formerly
78NC_arrayfill()
79 */
80static int
81NC_fill_schar(
82 void **xpp,
83 size_t nelems) /* how many */
84{
85 schar fillp[NFILL * sizeof(double)/X_SIZEOF_CHAR];
86
87 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
88
89 {
90 schar *vp = fillp; /* lower bound of area to be filled */
91 const schar *const end = vp + nelems;
92 while(vp < end)
93 {
94 *vp++ = NC_FILL_BYTE;
95 }
96 }
97 return ncx_putn_schar_schar(xppnelemsfillp);
98}
99
100static int
101NC_fill_char(
102 void **xpp,
103 size_t nelems) /* how many */
104{
105 char fillp[NFILL * sizeof(double)/X_SIZEOF_CHAR];
106
107 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
108
109 {
110 char *vp = fillp; /* lower bound of area to be filled */
111 const char *const end = vp + nelems;
112 while(vp < end)
113 {
114 *vp++ = NC_FILL_CHAR;
115 }
116 }
117 return ncx_putn_char_char(xppnelemsfillp);
118}
119
120static int
121NC_fill_short(
122 void **xpp,
123 size_t nelems) /* how many */
124{
125 short fillp[NFILL * sizeof(double)/X_SIZEOF_SHORT];
126
127 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
128
129 {
130 short *vp = fillp; /* lower bound of area to be filled */
131 const short *const end = vp + nelems;
132 while(vp < end)
133 {
134 *vp++ = NC_FILL_SHORT;
135 }
136 }
137 return ncx_putn_short_short(xppnelemsfillp);
138}
139
140
141#if (SIZEOF_INT >= X_SIZEOF_INT)
142static int
143NC_fill_int(
144 void **xpp,
145 size_t nelems) /* how many */
146{
147 int fillp[NFILL * sizeof(double)/X_SIZEOF_INT];
148
149 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
150
151 {
152 int *vp = fillp; /* lower bound of area to be filled */
153 const int *const end = vp + nelems;
154 while(vp < end)
155 {
156 *vp++ = NC_FILL_INT;
157 }
158 }
159 return ncx_putn_int_int(xppnelemsfillp);
160}
161
162#elif SIZEOF_LONG == X_SIZEOF_INT
163static int
164NC_fill_int(
165 void **xpp,
166 size_t nelems) /* how many */
167{
168 long fillp[NFILL * sizeof(double)/X_SIZEOF_INT];
169
170 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
171
172 {
173 long *vp = fillp; /* lower bound of area to be filled */
174 const long *const end = vp + nelems;
175 while(vp < end)
176 {
177 *vp++ = NC_FILL_INT;
178 }
179 }
180 return ncx_putn_int_long(xppnelemsfillp);
181}
182
183#else
184#error "NC_fill_int implementation"
185#endif
186
187static int
188NC_fill_float(
189 void **xpp,
190 size_t nelems) /* how many */
191{
192 float fillp[NFILL * sizeof(double)/X_SIZEOF_FLOAT];
193
194 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
195
196 {
197 float *vp = fillp; /* lower bound of area to be filled */
198 const float *const end = vp + nelems;
199 while(vp < end)
200 {
201 *vp++ = NC_FILL_FLOAT;
202 }
203 }
204 return ncx_putn_float_float(xppnelemsfillp);
205}
206
207static int
208NC_fill_double(
209 void **xpp,
210 size_t nelems) /* how many */
211{
212 double fillp[NFILL * sizeof(double)/X_SIZEOF_DOUBLE];
213
214 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
215
216 {
217 double *vp = fillp; /* lower bound of area to be filled */
218 const double *const end = vp + nelems;
219 while(vp < end)
220 {
221 *vp++ = NC_FILL_DOUBLE;
222 }
223 }
224 return ncx_putn_double_double(xppnelemsfillp);
225}
226
227
228static int
229NC_fill_uchar(
230 void **xpp,
231 size_t nelems) /* how many */
232{
233 uchar fillp[NFILL * sizeof(double)/X_SIZEOF_UBYTE];
234
235 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
236
237 {
238 uchar *vp = fillp; /* lower bound of area to be filled */
239 const uchar *const end = vp + nelems;
240 while(vp < end)
241 {
242 *vp++ = NC_FILL_UBYTE;
243 }
244 }
245 return ncx_putn_uchar_uchar(xppnelemsfillp);
246}
247
248static int
249NC_fill_ushort(
250 void **xpp,
251 size_t nelems) /* how many */
252{
253 ushort fillp[NFILL * sizeof(double)/X_SIZEOF_USHORT];
254
255 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
256
257 {
258 ushort *vp = fillp; /* lower bound of area to be filled */
259 const ushort *const end = vp + nelems;
260 while(vp < end)
261 {
262 *vp++ = NC_FILL_USHORT;
263 }
264 }
265 return ncx_putn_ushort_ushort(xppnelemsfillp);
266}
267
268static int
269NC_fill_uint(
270 void **xpp,
271 size_t nelems) /* how many */
272{
273 uint fillp[NFILL * sizeof(double)/X_SIZEOF_UINT];
274
275 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
276
277 {
278 uint *vp = fillp; /* lower bound of area to be filled */
279 const uint *const end = vp + nelems;
280 while(vp < end)
281 {
282 *vp++ = NC_FILL_UINT;
283 }
284 }
285 return ncx_putn_uint_uint(xppnelemsfillp);
286}
287
288static int
289NC_fill_longlong(
290 void **xpp,
291 size_t nelems) /* how many */
292{
293 longlong fillp[NFILL * sizeof(double)/X_SIZEOF_LONGLONG];
294
295 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
296
297 {
298 longlong *vp = fillp; /* lower bound of area to be filled */
299 const longlong *const end = vp + nelems;
300 while(vp < end)
301 {
302 *vp++ = NC_FILL_INT64;
303 }
304 }
305 return ncx_putn_longlong_longlong(xppnelemsfillp);
306}
307
308static int
309NC_fill_ulonglong(
310 void **xpp,
311 size_t nelems) /* how many */
312{
313 ulonglong fillp[NFILL * sizeof(double)/X_SIZEOF_ULONGLONG];
314
315 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
316
317 {
318 ulonglong *vp = fillp; /* lower bound of area to be filled */
319 const ulonglong *const end = vp + nelems;
320 while(vp < end)
321 {
322 *vp++ = NC_FILL_UINT64;
323 }
324 }
325 return ncx_putn_ulonglong_ulonglong(xppnelemsfillp);
326}
327
328
329
330
331/*
332 * Fill the external space for variable 'varp' values at 'recno' with
333 * the appropriate value. If 'varp' is not a record variable, fill the
334 * whole thing.  For the special case when 'varp' is the only record
335 * variable and it is of type byte, char, or short, varsize should be
336 * ncp->recsize, otherwise it should be varp->len.
337 * Formerly
338xdr_NC_fill()
339 */
340int
341fill_NC_var(NC3_INFOncp, const NC_var *varp, size_t varsize, size_t recno)
342{
343 char xfillp[NFILL * X_SIZEOF_DOUBLE];
344 const size_t step = varp->xsz;
345 const size_t nelems = sizeof(xfillp)/step;
346 const size_t xsz = varp->xsz * nelems;
347 NC_attr **attrpp = NULL;
348 off_t offset;
349 size_t remaining = varsize;
350
351 void *xp;
352 int status = NC_NOERR;
353
354 /*
355  * Set up fill value
356  */
357 attrpp = NC_findattr(&varp->attrs_FillValue);
358 if( attrpp != NULL )
359 {
360 /* User defined fill value */
361 if( (*attrpp)->type != varp->type || (*attrpp)->nelems != 1 )
362 {
363 return NC_EBADTYPE;
364 }
365 else
366 {
367 /* Use the user defined value */
368 char *cp = xfillp;
369 const char *const end = &xfillp[sizeof(xfillp)];
370
371 assert(step <= (*attrpp)->xsz);
372
373 for( /*NADA*/; cp < endcp += step)
374 {
375 (void) memcpy(cp, (*attrpp)->xvaluestep);
376 }
377 }
378 }
379 else
380 {
381 /* use the default */
382
383 assert(xsz % X_ALIGN == 0);
384 assert(xsz <= sizeof(xfillp));
385
386 xp = xfillp;
387
388 switch(varp->type){
389 case NC_BYTE :
390 status = NC_fill_schar(&xpnelems);
391 break;
392 case NC_CHAR :
393 status = NC_fill_char(&xpnelems);
394 break;
395 case NC_SHORT :
396 status = NC_fill_short(&xpnelems);
397 break;
398 case NC_INT :
399 status = NC_fill_int(&xpnelems);
400 break;
401 case NC_FLOAT :
402 status = NC_fill_float(&xpnelems);
403 break;
404 case NC_DOUBLE :
405 status = NC_fill_double(&xpnelems);
406 break;
407                case NC_UBYTE :
408                        status = NC_fill_uchar(&xpnelems);
409                        break;
410                case NC_USHORT :
411                        status = NC_fill_ushort(&xpnelems);
412                        break;
413                case NC_UINT :
414                        status = NC_fill_uint(&xpnelems);
415                        break;
416                case NC_INT64 :
417                        status = NC_fill_longlong(&xpnelems);
418                        break;
419                case NC_UINT64 :
420                        status = NC_fill_ulonglong(&xpnelems);
421                        break;
422 default :
423 assert("fill_NC_var invalid type" == 0);
424 status = NC_EBADTYPE;
425 break;
426 }
427 if(status != NC_NOERR)
428 return status;
429
430 assert(xp == xfillp + xsz);
431 }
432
433 /*
434  * copyout:
435  * xfillp now contains 'nelems' elements of the fill value
436  * in external representation.
437  */
438
439 /*
440  * Copy it out.
441  */
442
443 offset = varp->begin;
444 if(IS_RECVAR(varp))
445 {
446 offset += (off_t)ncp->recsize * recno;
447 }
448
449 assert(remaining > 0);
450 for(;;)
451 {
452 const size_t chunksz = MIN(remainingncp->chunk);
453 size_t ii;
454
455 status = ncio_get(ncp->nciopoffsetchunksz,
456  RGN_WRITE, &xp);
457 if(status != NC_NOERR)
458 {
459 return status;
460 }
461
462 /*
463  * fill the chunksz buffer in units  of xsz
464  */
465 for(ii = 0; ii < chunksz/xszii++)
466 {
467 (void) memcpy(xpxfillpxsz);
468 xp = (char *)xp + xsz;
469 }
470 /*
471  * Deal with any remainder
472  */
473 {
474 const size_t rem = chunksz % xsz;
475 if(rem != 0)
476 {
477 (void) memcpy(xpxfillprem);
478 /* xp = (char *)xp + xsz; */
479 }
480
481 }
482
483 status = ncio_rel(ncp->nciopoffsetRGN_MODIFIED);
484
485 if(status != NC_NOERR)
486 {
487 break;
488 }
489
490 remaining -= chunksz;
491 if(remaining == 0)
492 break; /* normal loop exit */
493 offset += chunksz;
494
495 }
496
497 return status;
498}
499/* End fill */
500
501
502/*
503 * Add a record containing the fill values.
504 */
505static int
506NCfillrecord(NC3_INFOncp, const NC_var *const *varpp, size_t recno)
507{
508 size_t ii = 0;
509 for(; ii < ncp->vars.nelemsii++, varpp++)
510 {
511 if( !IS_RECVAR(*varpp) )
512 {
513 continue; /* skip non-record variables */
514 }
515 {
516 const int status = fill_NC_var(ncp, *varpp, (*varpp)->lenrecno);
517 if(status != NC_NOERR)
518 return status;
519 }
520 }
521 return NC_NOERR;
522}
523
524
525/*
526 * Add a record containing the fill values in the special case when
527 * there is exactly one record variable, where we don't require each
528 * record to be four-byte aligned (no record padding).
529 */
530static int
531NCfillspecialrecord(NC3_INFOncp, const NC_var *varp, size_t recno)
532{
533    int status;
534    assert(IS_RECVAR(varp));
535    status = fill_NC_var(ncpvarpncp->recsizerecno);
536    if(status != NC_NOERR)
537 return status;
538    return NC_NOERR;
539}
540
541
542/*
543 * It is advantageous to
544 * #define TOUCH_LAST
545 * when using memory mapped io.
546 */
547#if TOUCH_LAST
548/*
549 * Grow the file to a size which can contain recno
550 */
551static int
552NCtouchlast(NC3_INFOncp, const NC_var *const *varpp, size_t recno)
553{
554 int status = NC_NOERR;
555 const NC_var *varp = NULL;
556
557 {
558 size_t ii = 0;
559 for(; ii < ncp->vars.nelemsii++, varpp++)
560 {
561 if( !IS_RECVAR(*varpp) )
562 {
563 continue; /* skip non-record variables */
564 }
565 varp = *varpp;
566 }
567 }
568 assert(varp != NULL);
569 assert( IS_RECVAR(varp) );
570 {
571 const off_t offset = varp->begin
572 + (off_t)(recno-1) * (off_t)ncp->recsize
573 + (off_t)(varp->len - varp->xsz);
574 void *xp;
575
576
577 status = ncio_get(ncp->nciopoffsetvarp->xsz,
578  RGN_WRITE, &xp);
579 if(status != NC_NOERR)
580 return status;
581 (void)memset(xp, 0, varp->xsz);
582 status = ncio_rel(ncp->nciopoffsetRGN_MODIFIED);
583 }
584 return status;
585}
586#endif /* TOUCH_LAST */
587
588
589/*
590 * Ensure that the netcdf file has 'numrecs' records,
591 * add records and fill as necessary.
592 */
593static int
594NCvnrecs(NC3_INFOncp, size_t numrecs)
595{
596 int status = NC_NOERR;
597#ifdef LOCKNUMREC
598 ushmem_t myticket = 0, nowserving = 0;
599 ushmem_t numpe = (ushmem_t_num_pes();
600
601 /* get ticket and wait */
602 myticket = shmem_short_finc((shmem_t *) ncp->lock + LOCKNUMREC_LOCK,
603 ncp->lock[LOCKNUMREC_BASEPE]);
604#ifdef LN_TEST
605 fprintf(stderr,"%d of %d : ticket = %hu\n",
606 _my_pe(), _num_pes(), myticket);
607#endif
608 do {
609 shmem_short_get((shmem_t *) &nowserving,
610 (shmem_t *) ncp->lock + LOCKNUMREC_SERVING, 1,
611 ncp->lock[LOCKNUMREC_BASEPE]);
612#ifdef LN_TEST
613 fprintf(stderr,"%d of %d : serving = %hu\n",
614 _my_pe(), _num_pes(), nowserving);
615#endif
616 /* work-around for non-unique tickets */
617 if (nowserving > myticket && nowserving < myticket + numpe ) {
618 /* get a new ticket ... you've been bypassed */
619 /* and handle the unlikely wrap-around effect */
620 myticket = shmem_short_finc(
621 (shmem_t *) ncp->lock + LOCKNUMREC_LOCK,
622 ncp->lock[LOCKNUMREC_BASEPE]);
623#ifdef LN_TEST
624 fprintf(stderr,"%d of %d : new ticket = %hu\n",
625 _my_pe(), _num_pes(), myticket);
626#endif
627 }
628 } while(nowserving != myticket);
629 /* now our turn to check & update value */
630#endif
631
632 if(numrecs > NC_get_numrecs(ncp))
633 {
634
635
636#if TOUCH_LAST
637 status = NCtouchlast(ncp,
638 (const NC_var *const*)ncp->vars.value,
639 numrecs);
640 if(status != NC_NOERR)
641 goto common_return;
642#endif /* TOUCH_LAST */
643
644 set_NC_ndirty(ncp);
645
646 if(!NC_dofill(ncp))
647 {
648 /* Simply set the new numrecs value */
649 NC_set_numrecs(ncpnumrecs);
650 }
651 else
652 {
653     /* Treat two cases differently:
654         - exactly one record variable (no padding)
655                        - multiple record variables (each record padded
656                          to 4-byte alignment)
657     */
658     NC_var **vpp = (NC_var **)ncp->vars.value;
659     NC_var *const *const end = &vpp[ncp->vars.nelems];
660     NC_var *recvarp = NULL; /* last record var */
661     int numrecvars = 0;
662     size_t cur_nrecs;
663
664     /* determine how many record variables */
665     for( /*NADA*/; vpp < endvpp++) {
666 if(IS_RECVAR(*vpp)) {
667     recvarp = *vpp;
668     numrecvars++;
669 }
670     }
671
672     if (numrecvars != 1) { /* usual case */
673 /* Fill each record out to numrecs */
674 while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs)
675     {
676 status = NCfillrecord(ncp,
677 (const NC_var *const*)ncp->vars.value,
678 cur_nrecs);
679 if(status != NC_NOERR)
680 {
681 break;
682 }
683 NC_increase_numrecs(ncpcur_nrecs +1);
684 }
685 if(status != NC_NOERR)
686 goto common_return;
687     } else { /* special case */
688 /* Fill each record out to numrecs */
689 while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs)
690     {
691 status = NCfillspecialrecord(ncp,
692 recvarp,
693 cur_nrecs);
694 if(status != NC_NOERR)
695 {
696 break;
697 }
698 NC_increase_numrecs(ncpcur_nrecs +1);
699 }
700 if(status != NC_NOERR)
701 goto common_return;
702
703     }
704 }
705
706 if(NC_doNsync(ncp))
707 {
708 status = write_numrecs(ncp);
709 }
710
711 }
712common_return:
713#ifdef LOCKNUMREC
714 /* finished with our lock - increment serving number */
715 (void) shmem_short_finc((shmem_t *) ncp->lock + LOCKNUMREC_SERVING,
716 ncp->lock[LOCKNUMREC_BASEPE]);
717#endif
718 return status;
719}
720
721
722/*
723 * Check whether 'coord' values are valid for the variable.
724 */
725static int
726NCcoordck(NC3_INFOncp, const NC_var *varp, const size_t *coord)
727{
728 const size_t *ip;
729 size_t *up;
730
731 if(varp->ndims == 0)
732 return NC_NOERR; /* 'scalar' variable */
733
734 if(IS_RECVAR(varp))
735 {
736 if(*coord > X_UINT_MAX) /* rkr: bug fix from previous X_INT_MAX */
737 return NC_EINVALCOORDS; /* sanity check */
738 if(NC_readonly(ncp) && *coord >= NC_get_numrecs(ncp))
739 {
740 if(!NC_doNsync(ncp))
741 return NC_EINVALCOORDS;
742 /* else */
743 {
744 /* Update from disk and check again */
745 const int status = read_numrecs(ncp);
746 if(status != NC_NOERR)
747 return status;
748 if(*coord >= NC_get_numrecs(ncp))
749 return NC_EINVALCOORDS;
750 }
751 }
752 ip = coord + 1;
753 up = varp->shape + 1;
754 }
755 else
756 {
757 ip = coord;
758 up = varp->shape;
759 }
760
761#ifdef CDEBUG
762fprintf(stderr," NCcoordck: coord %ld, count %d, ip %ld\n",
763 coordvarp->ndimsip );
764#endif /* CDEBUG */
765
766 for(; ip < coord + varp->ndimsip++, up++)
767 {
768
769#ifdef CDEBUG
770fprintf(stderr," NCcoordck: ip %p, *ip %ld, up %p, *up %lu\n",
771 ip, *ipup, *up );
772#endif /* CDEBUG */
773
774 /* cast needed for braindead systems with signed size_t */
775 if((unsigned long) *ip >= (unsigned long) *up )
776 return NC_EINVALCOORDS;
777 }
778
779 return NC_NOERR;
780}
781
782
783/*
784 * Check whether 'edges' are valid for the variable and 'start'
785 */
786/*ARGSUSED*/
787static int
788NCedgeck(const NC3_INFOncp, const NC_var *varp,
789  const size_t *start, const size_t *edges)
790{
791 const size_t *const end = start + varp->ndims;
792 const size_t *shp = varp->shape;
793
794 if(varp->ndims == 0)
795 return NC_NOERR; /* 'scalar' variable */
796
797 if(IS_RECVAR(varp))
798 {
799 start++;
800 edges++;
801 shp++;
802 }
803
804 for(; start < endstart++, edges++, shp++)
805 {
806 /* cast needed for braindead systems with signed size_t */
807 if((unsigned long) *edges > *shp ||
808 (unsigned long) *start + (unsigned long) *edges > *shp)
809 {
810 return(NC_EEDGE);
811 }
812 }
813 return NC_NOERR;
814}
815
816
817/*
818 * Translate the (variable, coord) pair into a seek index
819 */
820static off_t
821NC_varoffset(const NC3_INFOncp, const NC_var *varp, const size_t *coord)
822{
823 if(varp->ndims == 0) /* 'scalar' variable */
824 return varp->begin;
825
826 if(varp->ndims == 1)
827 {
828 if(IS_RECVAR(varp))
829 return varp->begin +
830  (off_t)(*coord) * (off_t)ncp->recsize;
831 /* else */
832 return varp->begin + (off_t)(*coord) * (off_t)varp->xsz;
833 }
834 /* else */
835 {
836 off_t lcoord = (off_t)coord[varp->ndims -1];
837
838 off_t *up = varp->dsizes +1;
839 const size_t *ip = coord;
840 const off_t *const end = varp->dsizes + varp->ndims;
841
842 if(IS_RECVAR(varp))
843 up++, ip++;
844
845 for(; up < endup++, ip++)
846 lcoord += (off_t)(*up) * (off_t)(*ip);
847
848 lcoord *= varp->xsz;
849
850 if(IS_RECVAR(varp))
851 lcoord += (off_t)(*coord) * ncp->recsize;
852
853 lcoord += varp->begin;
854 return lcoord;
855 }
856}
857
858
859
860static int
861putNCvx_char_char(NC3_INFOncp, const NC_var *varp,
862  const size_t *start, size_t nelems, const char *value)
863{
864 off_t offset = NC_varoffset(ncpvarpstart);
865 size_t remaining = varp->xsz * nelems;
866 int status = NC_NOERR;
867 void *xp;
868
869 if(nelems == 0)
870 return NC_NOERR;
871
872 assert(value != NULL);
873
874 for(;;)
875 {
876 size_t extent = MIN(remainingncp->chunk);
877 size_t nput = ncx_howmany(varp->typeextent);
878
879 int lstatus = ncio_get(ncp->nciopoffsetextent,
880  RGN_WRITE, &xp);
881 if(lstatus != NC_NOERR)
882 return lstatus;
883
884 lstatus = ncx_putn_char_char(&xpnputvalue);
885 if(lstatus != NC_NOERR && status == NC_NOERR)
886 {
887 /* not fatal to the loop */
888 status = lstatus;
889 }
890
891 (void) ncio_rel(ncp->nciopoffset,
892  RGN_MODIFIED);
893
894 remaining -= extent;
895 if(remaining == 0)
896 break; /* normal loop exit */
897 offset += extent;
898 value += nput;
899
900 }
901
902 return status;
903}
904
905
906static int
907putNCvx_schar_schar(NC3_INFOncp, const NC_var *varp,
908  const size_t *start, size_t nelems, const schar *value)
909{
910 off_t offset = NC_varoffset(ncpvarpstart);
911 size_t remaining = varp->xsz * nelems;
912 int status = NC_NOERR;
913 void *xp;
914
915 if(nelems == 0)
916 return NC_NOERR;
917
918 assert(value != NULL);
919
920 for(;;)
921 {
922 size_t extent = MIN(remainingncp->chunk);
923 size_t nput = ncx_howmany(varp->typeextent);
924
925 int lstatus = ncio_get(ncp->nciopoffsetextent,
926  RGN_WRITE, &xp);
927 if(lstatus != NC_NOERR)
928 return lstatus;
929
930 lstatus = ncx_putn_schar_schar(&xpnputvalue);
931 if(lstatus != NC_NOERR && status == NC_NOERR)
932 {
933 /* not fatal to the loop */
934 status = lstatus;
935 }
936
937 (void) ncio_rel(ncp->nciopoffset,
938  RGN_MODIFIED);
939
940 remaining -= extent;
941 if(remaining == 0)
942 break; /* normal loop exit */
943 offset += extent;
944 value += nput;
945
946 }
947
948 return status;
949}
950
951static int
952putNCvx_schar_uchar(NC3_INFOncp, const NC_var *varp,
953  const size_t *start, size_t nelems, const uchar *value)
954{
955 off_t offset = NC_varoffset(ncpvarpstart);
956 size_t remaining = varp->xsz * nelems;
957 int status = NC_NOERR;
958 void *xp;
959
960 if(nelems == 0)
961 return NC_NOERR;
962
963 assert(value != NULL);
964
965 for(;;)
966 {
967 size_t extent = MIN(remainingncp->chunk);
968 size_t nput = ncx_howmany(varp->typeextent);
969
970 int lstatus = ncio_get(ncp->nciopoffsetextent,
971  RGN_WRITE, &xp);
972 if(lstatus != NC_NOERR)
973 return lstatus;
974
975 lstatus = ncx_putn_schar_uchar(&xpnputvalue);
976 if(lstatus != NC_NOERR && status == NC_NOERR)
977 {
978 /* not fatal to the loop */
979 status = lstatus;
980 }
981
982 (void) ncio_rel(ncp->nciopoffset,
983  RGN_MODIFIED);
984
985 remaining -= extent;
986 if(remaining == 0)
987 break; /* normal loop exit */
988 offset += extent;
989 value += nput;
990
991 }
992
993 return status;
994}
995
996static int
997putNCvx_schar_short(NC3_INFOncp, const NC_var *varp,
998  const size_t *start, size_t nelems, const short *value)
999{
1000 off_t offset = NC_varoffset(ncpvarpstart);
1001 size_t remaining = varp->xsz * nelems;
1002 int status = NC_NOERR;
1003 void *xp;
1004
1005 if(nelems == 0)
1006 return NC_NOERR;
1007
1008 assert(value != NULL);
1009
1010 for(;;)
1011 {
1012 size_t extent = MIN(remainingncp->chunk);
1013 size_t nput = ncx_howmany(varp->typeextent);
1014
1015 int lstatus = ncio_get(ncp->nciopoffsetextent,
1016  RGN_WRITE, &xp);
1017 if(lstatus != NC_NOERR)
1018 return lstatus;
1019
1020 lstatus = ncx_putn_schar_short(&xpnputvalue);
1021 if(lstatus != NC_NOERR && status == NC_NOERR)
1022 {
1023 /* not fatal to the loop */
1024 status = lstatus;
1025 }
1026
1027 (void) ncio_rel(ncp->nciopoffset,
1028  RGN_MODIFIED);
1029
1030 remaining -= extent;
1031 if(remaining == 0)
1032 break; /* normal loop exit */
1033 offset += extent;
1034 value += nput;
1035
1036 }
1037
1038 return status;
1039}
1040
1041static int
1042putNCvx_schar_int(NC3_INFOncp, const NC_var *varp,
1043  const size_t *start, size_t nelems, const int *value)
1044{
1045 off_t offset = NC_varoffset(ncpvarpstart);
1046 size_t remaining = varp->xsz * nelems;
1047 int status = NC_NOERR;
1048 void *xp;
1049
1050 if(nelems == 0)
1051 return NC_NOERR;
1052
1053 assert(value != NULL);
1054
1055 for(;;)
1056 {
1057 size_t extent = MIN(remainingncp->chunk);
1058 size_t nput = ncx_howmany(varp->typeextent);
1059
1060 int lstatus = ncio_get(ncp->nciopoffsetextent,
1061  RGN_WRITE, &xp);
1062 if(lstatus != NC_NOERR)
1063 return lstatus;
1064
1065 lstatus = ncx_putn_schar_int(&xpnputvalue);
1066 if(lstatus != NC_NOERR && status == NC_NOERR)
1067 {
1068 /* not fatal to the loop */
1069 status = lstatus;
1070 }
1071
1072 (void) ncio_rel(ncp->nciopoffset,
1073  RGN_MODIFIED);
1074
1075 remaining -= extent;
1076 if(remaining == 0)
1077 break; /* normal loop exit */
1078 offset += extent;
1079 value += nput;
1080
1081 }
1082
1083 return status;
1084}
1085
1086static int
1087putNCvx_schar_float(NC3_INFOncp, const NC_var *varp,
1088  const size_t *start, size_t nelems, const float *value)
1089{
1090 off_t offset = NC_varoffset(ncpvarpstart);
1091 size_t remaining = varp->xsz * nelems;
1092 int status = NC_NOERR;
1093 void *xp;
1094
1095 if(nelems == 0)
1096 return NC_NOERR;
1097
1098 assert(value != NULL);
1099
1100 for(;;)
1101 {
1102 size_t extent = MIN(remainingncp->chunk);
1103 size_t nput = ncx_howmany(varp->typeextent);
1104
1105 int lstatus = ncio_get(ncp->nciopoffsetextent,
1106  RGN_WRITE, &xp);
1107 if(lstatus != NC_NOERR)
1108 return lstatus;
1109
1110 lstatus = ncx_putn_schar_float(&xpnputvalue);
1111 if(lstatus != NC_NOERR && status == NC_NOERR)
1112 {
1113 /* not fatal to the loop */
1114 status = lstatus;
1115 }
1116
1117 (void) ncio_rel(ncp->nciopoffset,
1118  RGN_MODIFIED);
1119
1120 remaining -= extent;
1121 if(remaining == 0)
1122 break; /* normal loop exit */
1123 offset += extent;
1124 value += nput;
1125
1126 }
1127
1128 return status;
1129}
1130
1131static int
1132putNCvx_schar_double(NC3_INFOncp, const NC_var *varp,
1133  const size_t *start, size_t nelems, const double *value)
1134{
1135 off_t offset = NC_varoffset(ncpvarpstart);
1136 size_t remaining = varp->xsz * nelems;
1137 int status = NC_NOERR;
1138 void *xp;
1139
1140 if(nelems == 0)
1141 return NC_NOERR;
1142
1143 assert(value != NULL);
1144
1145 for(;;)
1146 {
1147 size_t extent = MIN(remainingncp->chunk);
1148 size_t nput = ncx_howmany(varp->typeextent);
1149
1150 int lstatus = ncio_get(ncp->nciopoffsetextent,
1151  RGN_WRITE, &xp);
1152 if(lstatus != NC_NOERR)
1153 return lstatus;
1154
1155 lstatus = ncx_putn_schar_double(&xpnputvalue);
1156 if(lstatus != NC_NOERR && status == NC_NOERR)
1157 {
1158 /* not fatal to the loop */
1159 status = lstatus;
1160 }
1161
1162 (void) ncio_rel(ncp->nciopoffset,
1163  RGN_MODIFIED);
1164
1165 remaining -= extent;
1166 if(remaining == 0)
1167 break; /* normal loop exit */
1168 offset += extent;
1169 value += nput;
1170
1171 }
1172
1173 return status;
1174}
1175
1176static int
1177putNCvx_schar_longlong(NC3_INFOncp, const NC_var *varp,
1178  const size_t *start, size_t nelems, const longlong *value)
1179{
1180 off_t offset = NC_varoffset(ncpvarpstart);
1181 size_t remaining = varp->xsz * nelems;
1182 int status = NC_NOERR;
1183 void *xp;
1184
1185 if(nelems == 0)
1186 return NC_NOERR;
1187
1188 assert(value != NULL);
1189
1190 for(;;)
1191 {
1192 size_t extent = MIN(remainingncp->chunk);
1193 size_t nput = ncx_howmany(varp->typeextent);
1194
1195 int lstatus = ncio_get(ncp->nciopoffsetextent,
1196  RGN_WRITE, &xp);
1197 if(lstatus != NC_NOERR)
1198 return lstatus;
1199
1200 lstatus = ncx_putn_schar_longlong(&xpnputvalue);
1201 if(lstatus != NC_NOERR && status == NC_NOERR)
1202 {
1203 /* not fatal to the loop */
1204 status = lstatus;
1205 }
1206
1207 (void) ncio_rel(ncp->nciopoffset,
1208  RGN_MODIFIED);
1209
1210 remaining -= extent;
1211 if(remaining == 0)
1212 break; /* normal loop exit */
1213 offset += extent;
1214 value += nput;
1215
1216 }
1217
1218 return status;
1219}
1220
1221static int
1222putNCvx_schar_ushort(NC3_INFOncp, const NC_var *varp,
1223  const size_t *start, size_t nelems, const ushort *value)
1224{
1225 off_t offset = NC_varoffset(ncpvarpstart);
1226 size_t remaining = varp->xsz * nelems;
1227 int status = NC_NOERR;
1228 void *xp;
1229
1230 if(nelems == 0)
1231 return NC_NOERR;
1232
1233 assert(value != NULL);
1234
1235 for(;;)
1236 {
1237 size_t extent = MIN(remainingncp->chunk);
1238 size_t nput = ncx_howmany(varp->typeextent);
1239
1240 int lstatus = ncio_get(ncp->nciopoffsetextent,
1241  RGN_WRITE, &xp);
1242 if(lstatus != NC_NOERR)
1243 return lstatus;
1244
1245 lstatus = ncx_putn_schar_ushort(&xpnputvalue);
1246 if(lstatus != NC_NOERR && status == NC_NOERR)
1247 {
1248 /* not fatal to the loop */
1249 status = lstatus;
1250 }
1251
1252 (void) ncio_rel(ncp->nciopoffset,
1253  RGN_MODIFIED);
1254
1255 remaining -= extent;
1256 if(remaining == 0)
1257 break; /* normal loop exit */
1258 offset += extent;
1259 value += nput;
1260
1261 }
1262
1263 return status;
1264}
1265
1266static int
1267putNCvx_schar_uint(NC3_INFOncp, const NC_var *varp,
1268  const size_t *start, size_t nelems, const uint *value)
1269{
1270 off_t offset = NC_varoffset(ncpvarpstart);
1271 size_t remaining = varp->xsz * nelems;
1272 int status = NC_NOERR;
1273 void *xp;
1274
1275 if(nelems == 0)
1276 return NC_NOERR;
1277
1278 assert(value != NULL);
1279
1280 for(;;)
1281 {
1282 size_t extent = MIN(remainingncp->chunk);
1283 size_t nput = ncx_howmany(varp->typeextent);
1284
1285 int lstatus = ncio_get(ncp->nciopoffsetextent,
1286  RGN_WRITE, &xp);
1287 if(lstatus != NC_NOERR)
1288 return lstatus;
1289
1290 lstatus = ncx_putn_schar_uint(&xpnputvalue);
1291 if(lstatus != NC_NOERR && status == NC_NOERR)
1292 {
1293 /* not fatal to the loop */
1294 status = lstatus;
1295 }
1296
1297 (void) ncio_rel(ncp->nciopoffset,
1298  RGN_MODIFIED);
1299
1300 remaining -= extent;
1301 if(remaining == 0)
1302 break; /* normal loop exit */
1303 offset += extent;
1304 value += nput;
1305
1306 }
1307
1308 return status;
1309}
1310
1311static int
1312putNCvx_schar_ulonglong(NC3_INFOncp, const NC_var *varp,
1313  const size_t *start, size_t nelems, const ulonglong *value)
1314{
1315 off_t offset = NC_varoffset(ncpvarpstart);
1316 size_t remaining = varp->xsz * nelems;
1317 int status = NC_NOERR;
1318 void *xp;
1319
1320 if(nelems == 0)
1321 return NC_NOERR;
1322
1323 assert(value != NULL);
1324
1325 for(;;)
1326 {
1327 size_t extent = MIN(remainingncp->chunk);
1328 size_t nput = ncx_howmany(varp->typeextent);
1329
1330 int lstatus = ncio_get(ncp->nciopoffsetextent,
1331  RGN_WRITE, &xp);
1332 if(lstatus != NC_NOERR)
1333 return lstatus;
1334
1335 lstatus = ncx_putn_schar_ulonglong(&xpnputvalue);
1336 if(lstatus != NC_NOERR && status == NC_NOERR)
1337 {
1338 /* not fatal to the loop */
1339 status = lstatus;
1340 }
1341
1342 (void) ncio_rel(ncp->nciopoffset,
1343  RGN_MODIFIED);
1344
1345 remaining -= extent;
1346 if(remaining == 0)
1347 break; /* normal loop exit */
1348 offset += extent;
1349 value += nput;
1350
1351 }
1352
1353 return status;
1354}
1355
1356
1357static int
1358putNCvx_short_schar(NC3_INFOncp, const NC_var *varp,
1359  const size_t *start, size_t nelems, const schar *value)
1360{
1361 off_t offset = NC_varoffset(ncpvarpstart);
1362 size_t remaining = varp->xsz * nelems;
1363 int status = NC_NOERR;
1364 void *xp;
1365
1366 if(nelems == 0)
1367 return NC_NOERR;
1368
1369 assert(value != NULL);
1370
1371 for(;;)
1372 {
1373 size_t extent = MIN(remainingncp->chunk);
1374 size_t nput = ncx_howmany(varp->typeextent);
1375
1376 int lstatus = ncio_get(ncp->nciopoffsetextent,
1377  RGN_WRITE, &xp);
1378 if(lstatus != NC_NOERR)
1379 return lstatus;
1380
1381 lstatus = ncx_putn_short_schar(&xpnputvalue);
1382 if(lstatus != NC_NOERR && status == NC_NOERR)
1383 {
1384 /* not fatal to the loop */
1385 status = lstatus;
1386 }
1387
1388 (void) ncio_rel(ncp->nciopoffset,
1389  RGN_MODIFIED);
1390
1391 remaining -= extent;
1392 if(remaining == 0)
1393 break; /* normal loop exit */
1394 offset += extent;
1395 value += nput;
1396
1397 }
1398
1399 return status;
1400}
1401
1402static int
1403putNCvx_short_uchar(NC3_INFOncp, const NC_var *varp,
1404  const size_t *start, size_t nelems, const uchar *value)
1405{
1406 off_t offset = NC_varoffset(ncpvarpstart);
1407 size_t remaining = varp->xsz * nelems;
1408 int status = NC_NOERR;
1409 void *xp;
1410
1411 if(nelems == 0)
1412 return NC_NOERR;
1413
1414 assert(value != NULL);
1415
1416 for(;;)
1417 {
1418 size_t extent = MIN(remainingncp->chunk);
1419 size_t nput = ncx_howmany(varp->typeextent);
1420
1421 int lstatus = ncio_get(ncp->nciopoffsetextent,
1422  RGN_WRITE, &xp);
1423 if(lstatus != NC_NOERR)
1424 return lstatus;
1425
1426 lstatus = ncx_putn_short_uchar(&xpnputvalue);
1427 if(lstatus != NC_NOERR && status == NC_NOERR)
1428 {
1429 /* not fatal to the loop */
1430 status = lstatus;
1431 }
1432
1433 (void) ncio_rel(ncp->nciopoffset,
1434  RGN_MODIFIED);
1435
1436 remaining -= extent;
1437 if(remaining == 0)
1438 break; /* normal loop exit */
1439 offset += extent;
1440 value += nput;
1441
1442 }
1443
1444 return status;
1445}
1446
1447static int
1448putNCvx_short_short(NC3_INFOncp, const NC_var *varp,
1449  const size_t *start, size_t nelems, const short *value)
1450{
1451 off_t offset = NC_varoffset(ncpvarpstart);
1452 size_t remaining = varp->xsz * nelems;
1453 int status = NC_NOERR;
1454 void *xp;
1455
1456 if(nelems == 0)
1457 return NC_NOERR;
1458
1459 assert(value != NULL);
1460
1461 for(;;)
1462 {
1463 size_t extent = MIN(remainingncp->chunk);
1464 size_t nput = ncx_howmany(varp->typeextent);
1465
1466 int lstatus = ncio_get(ncp->nciopoffsetextent,
1467  RGN_WRITE, &xp);
1468 if(lstatus != NC_NOERR)
1469 return lstatus;
1470
1471 lstatus = ncx_putn_short_short(&xpnputvalue);
1472 if(lstatus != NC_NOERR && status == NC_NOERR)
1473 {
1474 /* not fatal to the loop */
1475 status = lstatus;
1476 }
1477
1478 (void) ncio_rel(ncp->nciopoffset,
1479  RGN_MODIFIED);
1480
1481 remaining -= extent;
1482 if(remaining == 0)
1483 break; /* normal loop exit */
1484 offset += extent;
1485 value += nput;
1486
1487 }
1488
1489 return status;
1490}
1491
1492static int
1493putNCvx_short_int(NC3_INFOncp, const NC_var *varp,
1494  const size_t *start, size_t nelems, const int *value)
1495{
1496 off_t offset = NC_varoffset(ncpvarpstart);
1497 size_t remaining = varp->xsz * nelems;
1498 int status = NC_NOERR;
1499 void *xp;
1500
1501 if(nelems == 0)
1502 return NC_NOERR;
1503
1504 assert(value != NULL);
1505
1506 for(;;)
1507 {
1508 size_t extent = MIN(remainingncp->chunk);
1509 size_t nput = ncx_howmany(varp->typeextent);
1510
1511 int lstatus = ncio_get(ncp->nciopoffsetextent,
1512  RGN_WRITE, &xp);
1513 if(lstatus != NC_NOERR)
1514 return lstatus;
1515
1516 lstatus = ncx_putn_short_int(&xpnputvalue);
1517 if(lstatus != NC_NOERR && status == NC_NOERR)
1518 {
1519 /* not fatal to the loop */
1520 status = lstatus;
1521 }
1522
1523 (void) ncio_rel(ncp->nciopoffset,
1524  RGN_MODIFIED);
1525
1526 remaining -= extent;
1527 if(remaining == 0)
1528 break; /* normal loop exit */
1529 offset += extent;
1530 value += nput;
1531
1532 }
1533
1534 return status;
1535}
1536
1537static int
1538putNCvx_short_float(NC3_INFOncp, const NC_var *varp,
1539  const size_t *start, size_t nelems, const float *value)
1540{
1541 off_t offset = NC_varoffset(ncpvarpstart);
1542 size_t remaining = varp->xsz * nelems;
1543 int status = NC_NOERR;
1544 void *xp;
1545
1546 if(nelems == 0)
1547 return NC_NOERR;
1548
1549 assert(value != NULL);
1550
1551 for(;;)
1552 {
1553 size_t extent = MIN(remainingncp->chunk);
1554 size_t nput = ncx_howmany(varp->typeextent);
1555
1556 int lstatus = ncio_get(ncp->nciopoffsetextent,
1557  RGN_WRITE, &xp);
1558 if(lstatus != NC_NOERR)
1559 return lstatus;
1560
1561 lstatus = ncx_putn_short_float(&xpnputvalue);
1562 if(lstatus != NC_NOERR && status == NC_NOERR)
1563 {
1564 /* not fatal to the loop */
1565 status = lstatus;
1566 }
1567
1568 (void) ncio_rel(ncp->nciopoffset,
1569  RGN_MODIFIED);
1570
1571 remaining -= extent;
1572 if(remaining == 0)
1573 break; /* normal loop exit */
1574 offset += extent;
1575 value += nput;
1576
1577 }
1578
1579 return status;
1580}
1581
1582static int
1583putNCvx_short_double(NC3_INFOncp, const NC_var *varp,
1584  const size_t *start, size_t nelems, const double *value)
1585{
1586 off_t offset = NC_varoffset(ncpvarpstart);
1587 size_t remaining = varp->xsz * nelems;
1588 int status = NC_NOERR;
1589 void *xp;
1590
1591 if(nelems == 0)
1592 return NC_NOERR;
1593
1594 assert(value != NULL);
1595
1596 for(;;)
1597 {
1598 size_t extent = MIN(remainingncp->chunk);
1599 size_t nput = ncx_howmany(varp->typeextent);
1600
1601 int lstatus = ncio_get(ncp->nciopoffsetextent,
1602  RGN_WRITE, &xp);
1603 if(lstatus != NC_NOERR)
1604 return lstatus;
1605
1606 lstatus = ncx_putn_short_double(&xpnputvalue);
1607 if(lstatus != NC_NOERR && status == NC_NOERR)
1608 {
1609 /* not fatal to the loop */
1610 status = lstatus;
1611 }
1612
1613 (void) ncio_rel(ncp->nciopoffset,
1614  RGN_MODIFIED);
1615
1616 remaining -= extent;
1617 if(remaining == 0)
1618 break; /* normal loop exit */
1619 offset += extent;
1620 value += nput;
1621
1622 }
1623
1624 return status;
1625}
1626
1627static int
1628putNCvx_short_longlong(NC3_INFOncp, const NC_var *varp,
1629  const size_t *start, size_t nelems, const longlong *value)
1630{
1631 off_t offset = NC_varoffset(ncpvarpstart);
1632 size_t remaining = varp->xsz * nelems;
1633 int status = NC_NOERR;
1634 void *xp;
1635
1636 if(nelems == 0)
1637 return NC_NOERR;
1638
1639 assert(value != NULL);
1640
1641 for(;;)
1642 {
1643 size_t extent = MIN(remainingncp->chunk);
1644 size_t nput = ncx_howmany(varp->typeextent);
1645
1646 int lstatus = ncio_get(ncp->nciopoffsetextent,
1647  RGN_WRITE, &xp);
1648 if(lstatus != NC_NOERR)
1649 return lstatus;
1650
1651 lstatus = ncx_putn_short_longlong(&xpnputvalue);
1652 if(lstatus != NC_NOERR && status == NC_NOERR)
1653 {
1654 /* not fatal to the loop */
1655 status = lstatus;
1656 }
1657
1658 (void) ncio_rel(ncp->nciopoffset,
1659  RGN_MODIFIED);
1660
1661 remaining -= extent;
1662 if(remaining == 0)
1663 break; /* normal loop exit */
1664 offset += extent;
1665 value += nput;
1666
1667 }
1668
1669 return status;
1670}
1671
1672static int
1673putNCvx_short_ushort(NC3_INFOncp, const NC_var *varp,
1674  const size_t *start, size_t nelems, const ushort *value)
1675{
1676 off_t offset = NC_varoffset(ncpvarpstart);
1677 size_t remaining = varp->xsz * nelems;
1678 int status = NC_NOERR;
1679 void *xp;
1680
1681 if(nelems == 0)
1682 return NC_NOERR;
1683
1684 assert(value != NULL);
1685
1686 for(;;)
1687 {
1688 size_t extent = MIN(remainingncp->chunk);
1689 size_t nput = ncx_howmany(varp->typeextent);
1690
1691 int lstatus = ncio_get(ncp->nciopoffsetextent,
1692  RGN_WRITE, &xp);
1693 if(lstatus != NC_NOERR)
1694 return lstatus;
1695
1696 lstatus = ncx_putn_short_ushort(&xpnputvalue);
1697 if(lstatus != NC_NOERR && status == NC_NOERR)
1698 {
1699 /* not fatal to the loop */
1700 status = lstatus;
1701 }
1702
1703 (void) ncio_rel(ncp->nciopoffset,
1704  RGN_MODIFIED);
1705
1706 remaining -= extent;
1707 if(remaining == 0)
1708 break; /* normal loop exit */
1709 offset += extent;
1710 value += nput;
1711
1712 }
1713
1714 return status;
1715}
1716
1717static int
1718putNCvx_short_uint(NC3_INFOncp, const NC_var *varp,
1719  const size_t *start, size_t nelems, const uint *value)
1720{
1721 off_t offset = NC_varoffset(ncpvarpstart);
1722 size_t remaining = varp->xsz * nelems;
1723 int status = NC_NOERR;
1724 void *xp;
1725
1726 if(nelems == 0)
1727 return NC_NOERR;
1728
1729 assert(value != NULL);
1730
1731 for(;;)
1732 {
1733 size_t extent = MIN(remainingncp->chunk);
1734 size_t nput = ncx_howmany(varp->typeextent);
1735
1736 int lstatus = ncio_get(ncp->nciopoffsetextent,
1737  RGN_WRITE, &xp);
1738 if(lstatus != NC_NOERR)
1739 return lstatus;
1740
1741 lstatus = ncx_putn_short_uint(&xpnputvalue);
1742 if(lstatus != NC_NOERR && status == NC_NOERR)
1743 {
1744 /* not fatal to the loop */
1745 status = lstatus;
1746 }
1747
1748 (void) ncio_rel(ncp->nciopoffset,
1749  RGN_MODIFIED);
1750
1751 remaining -= extent;
1752 if(remaining == 0)
1753 break; /* normal loop exit */
1754 offset += extent;
1755 value += nput;
1756
1757 }
1758
1759 return status;
1760}
1761
1762static int
1763putNCvx_short_ulonglong(NC3_INFOncp, const NC_var *varp,
1764  const size_t *start, size_t nelems, const ulonglong *value)
1765{
1766 off_t offset = NC_varoffset(ncpvarpstart);
1767 size_t remaining = varp->xsz * nelems;
1768 int status = NC_NOERR;
1769 void *xp;
1770
1771 if(nelems == 0)
1772 return NC_NOERR;
1773
1774 assert(value != NULL);
1775
1776 for(;;)
1777 {
1778 size_t extent = MIN(remainingncp->chunk);
1779 size_t nput = ncx_howmany(varp->typeextent);
1780
1781 int lstatus = ncio_get(ncp->nciopoffsetextent,
1782  RGN_WRITE, &xp);
1783 if(lstatus != NC_NOERR)
1784 return lstatus;
1785
1786 lstatus = ncx_putn_short_ulonglong(&xpnputvalue);
1787 if(lstatus != NC_NOERR && status == NC_NOERR)
1788 {
1789 /* not fatal to the loop */
1790 status = lstatus;
1791 }
1792
1793 (void) ncio_rel(ncp->nciopoffset,
1794  RGN_MODIFIED);
1795
1796 remaining -= extent;
1797 if(remaining == 0)
1798 break; /* normal loop exit */
1799 offset += extent;
1800 value += nput;
1801
1802 }
1803
1804 return status;
1805}
1806
1807
1808static int
1809putNCvx_int_schar(NC3_INFOncp, const NC_var *varp,
1810  const size_t *start, size_t nelems, const schar *value)
1811{
1812 off_t offset = NC_varoffset(ncpvarpstart);
1813 size_t remaining = varp->xsz * nelems;
1814 int status = NC_NOERR;
1815 void *xp;
1816
1817 if(nelems == 0)
1818 return NC_NOERR;
1819
1820 assert(value != NULL);
1821
1822 for(;;)
1823 {
1824 size_t extent = MIN(remainingncp->chunk);
1825 size_t nput = ncx_howmany(varp->typeextent);
1826
1827 int lstatus = ncio_get(ncp->nciopoffsetextent,
1828  RGN_WRITE, &xp);
1829 if(lstatus != NC_NOERR)
1830 return lstatus;
1831
1832 lstatus = ncx_putn_int_schar(&xpnputvalue);
1833 if(lstatus != NC_NOERR && status == NC_NOERR)
1834 {
1835 /* not fatal to the loop */
1836 status = lstatus;
1837 }
1838
1839 (void) ncio_rel(ncp->nciopoffset,
1840  RGN_MODIFIED);
1841
1842 remaining -= extent;
1843 if(remaining == 0)
1844 break; /* normal loop exit */
1845 offset += extent;
1846 value += nput;
1847
1848 }
1849
1850 return status;
1851}
1852
1853static int
1854putNCvx_int_uchar(NC3_INFOncp, const NC_var *varp,
1855  const size_t *start, size_t nelems, const uchar *value)
1856{
1857 off_t offset = NC_varoffset(ncpvarpstart);
1858 size_t remaining = varp->xsz * nelems;
1859 int status = NC_NOERR;
1860 void *xp;
1861
1862 if(nelems == 0)
1863 return NC_NOERR;
1864
1865 assert(value != NULL);
1866
1867 for(;;)
1868 {
1869 size_t extent = MIN(remainingncp->chunk);
1870 size_t nput = ncx_howmany(varp->typeextent);
1871
1872 int lstatus = ncio_get(ncp->nciopoffsetextent,
1873  RGN_WRITE, &xp);
1874 if(lstatus != NC_NOERR)
1875 return lstatus;
1876
1877 lstatus = ncx_putn_int_uchar(&xpnputvalue);
1878 if(lstatus != NC_NOERR && status == NC_NOERR)
1879 {
1880 /* not fatal to the loop */
1881 status = lstatus;
1882 }
1883
1884 (void) ncio_rel(ncp->nciopoffset,
1885  RGN_MODIFIED);
1886
1887 remaining -= extent;
1888 if(remaining == 0)
1889 break; /* normal loop exit */
1890 offset += extent;
1891 value += nput;
1892
1893 }
1894
1895 return status;
1896}
1897
1898static int
1899putNCvx_int_short(NC3_INFOncp, const NC_var *varp,
1900  const size_t *start, size_t nelems, const short *value)
1901{
1902 off_t offset = NC_varoffset(ncpvarpstart);
1903 size_t remaining = varp->xsz * nelems;
1904 int status = NC_NOERR;
1905 void *xp;
1906
1907 if(nelems == 0)
1908 return NC_NOERR;
1909
1910 assert(value != NULL);
1911
1912 for(;;)
1913 {
1914 size_t extent = MIN(remainingncp->chunk);
1915 size_t nput = ncx_howmany(varp->typeextent);
1916
1917 int lstatus = ncio_get(ncp->nciopoffsetextent,
1918  RGN_WRITE, &xp);
1919 if(lstatus != NC_NOERR)
1920 return lstatus;
1921
1922 lstatus = ncx_putn_int_short(&xpnputvalue);
1923 if(lstatus != NC_NOERR && status == NC_NOERR)
1924 {
1925 /* not fatal to the loop */
1926 status = lstatus;
1927 }
1928
1929 (void) ncio_rel(ncp->nciopoffset,
1930  RGN_MODIFIED);
1931
1932 remaining -= extent;
1933 if(remaining == 0)
1934 break; /* normal loop exit */
1935 offset += extent;
1936 value += nput;
1937
1938 }
1939
1940 return status;
1941}
1942
1943static int
1944putNCvx_int_int(NC3_INFOncp, const NC_var *varp,
1945  const size_t *start, size_t nelems, const int *value)
1946{
1947 off_t offset = NC_varoffset(ncpvarpstart);
1948 size_t remaining = varp->xsz * nelems;
1949 int status = NC_NOERR;
1950 void *xp;
1951
1952 if(nelems == 0)
1953 return NC_NOERR;
1954
1955 assert(value != NULL);
1956
1957 for(;;)
1958 {
1959 size_t extent = MIN(remainingncp->chunk);
1960 size_t nput = ncx_howmany(varp->typeextent);
1961
1962 int lstatus = ncio_get(ncp->nciopoffsetextent,
1963  RGN_WRITE, &xp);
1964 if(lstatus != NC_NOERR)
1965 return lstatus;
1966
1967 lstatus = ncx_putn_int_int(&xpnputvalue);
1968 if(lstatus != NC_NOERR && status == NC_NOERR)
1969 {
1970 /* not fatal to the loop */
1971 status = lstatus;
1972 }
1973
1974 (void) ncio_rel(ncp->nciopoffset,
1975  RGN_MODIFIED);
1976
1977 remaining -= extent;
1978 if(remaining == 0)
1979 break; /* normal loop exit */
1980 offset += extent;
1981 value += nput;
1982
1983 }
1984
1985 return status;
1986}
1987
1988static int
1989putNCvx_int_float(NC3_INFOncp, const NC_var *varp,
1990  const size_t *start, size_t nelems, const float *value)
1991{
1992 off_t offset = NC_varoffset(ncpvarpstart);
1993 size_t remaining = varp->xsz * nelems;
1994 int status = NC_NOERR;
1995 void *xp;
1996
1997 if(nelems == 0)
1998 return NC_NOERR;
1999
2000 assert(value != NULL);
2001
2002 for(;;)
2003 {
2004 size_t extent = MIN(remainingncp->chunk);
2005 size_t nput = ncx_howmany(varp->typeextent);
2006
2007 int lstatus = ncio_get(ncp->nciopoffsetextent,
2008  RGN_WRITE, &xp);
2009 if(lstatus != NC_NOERR)
2010 return lstatus;
2011
2012 lstatus = ncx_putn_int_float(&xpnputvalue);
2013 if(lstatus != NC_NOERR && status == NC_NOERR)
2014 {
2015 /* not fatal to the loop */
2016 status = lstatus;
2017 }
2018
2019 (void) ncio_rel(ncp->nciopoffset,
2020  RGN_MODIFIED);
2021
2022 remaining -= extent;
2023 if(remaining == 0)
2024 break; /* normal loop exit */
2025 offset += extent;
2026 value += nput;
2027
2028 }
2029
2030 return status;
2031}
2032
2033static int
2034putNCvx_int_double(NC3_INFOncp, const NC_var *varp,
2035  const size_t *start, size_t nelems, const double *value)
2036{
2037 off_t offset = NC_varoffset(ncpvarpstart);
2038 size_t remaining = varp->xsz * nelems;
2039 int status = NC_NOERR;
2040 void *xp;
2041
2042 if(nelems == 0)
2043 return NC_NOERR;
2044
2045 assert(value != NULL);
2046
2047 for(;;)
2048 {
2049 size_t extent = MIN(remainingncp->chunk);
2050 size_t nput = ncx_howmany(varp->typeextent);
2051
2052 int lstatus = ncio_get(ncp->nciopoffsetextent,
2053  RGN_WRITE, &xp);
2054 if(lstatus != NC_NOERR)
2055 return lstatus;
2056
2057 lstatus = ncx_putn_int_double(&xpnputvalue);
2058 if(lstatus != NC_NOERR && status == NC_NOERR)
2059 {
2060 /* not fatal to the loop */
2061 status = lstatus;
2062 }
2063
2064 (void) ncio_rel(ncp->nciopoffset,
2065  RGN_MODIFIED);
2066
2067 remaining -= extent;
2068 if(remaining == 0)
2069 break; /* normal loop exit */
2070 offset += extent;
2071 value += nput;
2072
2073 }
2074
2075 return status;
2076}
2077
2078static int
2079putNCvx_int_longlong(NC3_INFOncp, const NC_var *varp,
2080  const size_t *start, size_t nelems, const longlong *value)
2081{
2082 off_t offset = NC_varoffset(ncpvarpstart);
2083 size_t remaining = varp->xsz * nelems;
2084 int status = NC_NOERR;
2085 void *xp;
2086
2087 if(nelems == 0)
2088 return NC_NOERR;
2089
2090 assert(value != NULL);
2091
2092 for(;;)
2093 {
2094 size_t extent = MIN(remainingncp->chunk);
2095 size_t nput = ncx_howmany(varp->typeextent);
2096
2097 int lstatus = ncio_get(ncp->nciopoffsetextent,
2098  RGN_WRITE, &xp);
2099 if(lstatus != NC_NOERR)
2100 return lstatus;
2101
2102 lstatus = ncx_putn_int_longlong(&xpnputvalue);
2103 if(lstatus != NC_NOERR && status == NC_NOERR)
2104 {
2105 /* not fatal to the loop */
2106 status = lstatus;
2107 }
2108
2109 (void) ncio_rel(ncp->nciopoffset,
2110  RGN_MODIFIED);
2111
2112 remaining -= extent;
2113 if(remaining == 0)
2114 break; /* normal loop exit */
2115 offset += extent;
2116 value += nput;
2117
2118 }
2119
2120 return status;
2121}
2122
2123static int
2124putNCvx_int_ushort(NC3_INFOncp, const NC_var *varp,
2125  const size_t *start, size_t nelems, const ushort *value)
2126{
2127 off_t offset = NC_varoffset(ncpvarpstart);
2128 size_t remaining = varp->xsz * nelems;
2129 int status = NC_NOERR;
2130 void *xp;
2131
2132 if(nelems == 0)
2133 return NC_NOERR;
2134
2135 assert(value != NULL);
2136
2137 for(;;)
2138 {
2139 size_t extent = MIN(remainingncp->chunk);
2140 size_t nput = ncx_howmany(varp->typeextent);
2141
2142 int lstatus = ncio_get(ncp->nciopoffsetextent,
2143  RGN_WRITE, &xp);
2144 if(lstatus != NC_NOERR)
2145 return lstatus;
2146
2147 lstatus = ncx_putn_int_ushort(&xpnputvalue);
2148 if(lstatus != NC_NOERR && status == NC_NOERR)
2149 {
2150 /* not fatal to the loop */
2151 status = lstatus;
2152 }
2153
2154 (void) ncio_rel(ncp->nciopoffset,
2155  RGN_MODIFIED);
2156
2157 remaining -= extent;
2158 if(remaining == 0)
2159 break; /* normal loop exit */
2160 offset += extent;
2161 value += nput;
2162
2163 }
2164
2165 return status;
2166}
2167
2168static int
2169putNCvx_int_uint(NC3_INFOncp, const NC_var *varp,
2170  const size_t *start, size_t nelems, const uint *value)
2171{
2172 off_t offset = NC_varoffset(ncpvarpstart);
2173 size_t remaining = varp->xsz * nelems;
2174 int status = NC_NOERR;
2175 void *xp;
2176
2177 if(nelems == 0)
2178 return NC_NOERR;
2179
2180 assert(value != NULL);
2181
2182 for(;;)
2183 {
2184 size_t extent = MIN(remainingncp->chunk);
2185 size_t nput = ncx_howmany(varp->typeextent);
2186
2187 int lstatus = ncio_get(ncp->nciopoffsetextent,
2188  RGN_WRITE, &xp);
2189 if(lstatus != NC_NOERR)
2190 return lstatus;
2191
2192 lstatus = ncx_putn_int_uint(&xpnputvalue);
2193 if(lstatus != NC_NOERR && status == NC_NOERR)
2194 {
2195 /* not fatal to the loop */
2196 status = lstatus;
2197 }
2198
2199 (void) ncio_rel(ncp->nciopoffset,
2200  RGN_MODIFIED);
2201
2202 remaining -= extent;
2203 if(remaining == 0)
2204 break; /* normal loop exit */
2205 offset += extent;
2206 value += nput;
2207
2208 }
2209
2210 return status;
2211}
2212
2213static int
2214putNCvx_int_ulonglong(NC3_INFOncp, const NC_var *varp,
2215  const size_t *start, size_t nelems, const ulonglong *value)
2216{
2217 off_t offset = NC_varoffset(ncpvarpstart);
2218 size_t remaining = varp->xsz * nelems;
2219 int status = NC_NOERR;
2220 void *xp;
2221
2222 if(nelems == 0)
2223 return NC_NOERR;
2224
2225 assert(value != NULL);
2226
2227 for(;;)
2228 {
2229 size_t extent = MIN(remainingncp->chunk);
2230 size_t nput = ncx_howmany(varp->typeextent);
2231
2232 int lstatus = ncio_get(ncp->nciopoffsetextent,
2233  RGN_WRITE, &xp);
2234 if(lstatus != NC_NOERR)
2235 return lstatus;
2236
2237 lstatus = ncx_putn_int_ulonglong(&xpnputvalue);
2238 if(lstatus != NC_NOERR && status == NC_NOERR)
2239 {
2240 /* not fatal to the loop */
2241 status = lstatus;
2242 }
2243
2244 (void) ncio_rel(ncp->nciopoffset,
2245  RGN_MODIFIED);
2246
2247 remaining -= extent;
2248 if(remaining == 0)
2249 break; /* normal loop exit */
2250 offset += extent;
2251 value += nput;
2252
2253 }
2254
2255 return status;
2256}
2257
2258
2259static int
2260putNCvx_float_schar(NC3_INFOncp, const NC_var *varp,
2261  const size_t *start, size_t nelems, const schar *value)
2262{
2263 off_t offset = NC_varoffset(ncpvarpstart);
2264 size_t remaining = varp->xsz * nelems;
2265 int status = NC_NOERR;
2266 void *xp;
2267
2268 if(nelems == 0)
2269 return NC_NOERR;
2270
2271 assert(value != NULL);
2272
2273 for(;;)
2274 {
2275 size_t extent = MIN(remainingncp->chunk);
2276 size_t nput = ncx_howmany(varp->typeextent);
2277
2278 int lstatus = ncio_get(ncp->nciopoffsetextent,
2279  RGN_WRITE, &xp);
2280 if(lstatus != NC_NOERR)
2281 return lstatus;
2282
2283 lstatus = ncx_putn_float_schar(&xpnputvalue);
2284 if(lstatus != NC_NOERR && status == NC_NOERR)
2285 {
2286 /* not fatal to the loop */
2287 status = lstatus;
2288 }
2289
2290 (void) ncio_rel(ncp->nciopoffset,
2291  RGN_MODIFIED);
2292
2293 remaining -= extent;
2294 if(remaining == 0)
2295 break; /* normal loop exit */
2296 offset += extent;
2297 value += nput;
2298
2299 }
2300
2301 return status;
2302}
2303
2304static int
2305putNCvx_float_uchar(NC3_INFOncp, const NC_var *varp,
2306  const size_t *start, size_t nelems, const uchar *value)
2307{
2308 off_t offset = NC_varoffset(ncpvarpstart);
2309 size_t remaining = varp->xsz * nelems;
2310 int status = NC_NOERR;
2311 void *xp;
2312
2313 if(nelems == 0)
2314 return NC_NOERR;
2315
2316 assert(value != NULL);
2317
2318 for(;;)
2319 {
2320 size_t extent = MIN(remainingncp->chunk);
2321 size_t nput = ncx_howmany(varp->typeextent);
2322
2323 int lstatus = ncio_get(ncp->nciopoffsetextent,
2324  RGN_WRITE, &xp);
2325 if(lstatus != NC_NOERR)
2326 return lstatus;
2327
2328 lstatus = ncx_putn_float_uchar(&xpnputvalue);
2329 if(lstatus != NC_NOERR && status == NC_NOERR)
2330 {
2331 /* not fatal to the loop */
2332 status = lstatus;
2333 }
2334
2335 (void) ncio_rel(ncp->nciopoffset,
2336  RGN_MODIFIED);
2337
2338 remaining -= extent;
2339 if(remaining == 0)
2340 break; /* normal loop exit */
2341 offset += extent;
2342 value += nput;
2343
2344 }
2345
2346 return status;
2347}
2348
2349static int
2350putNCvx_float_short(NC3_INFOncp, const NC_var *varp,
2351  const size_t *start, size_t nelems, const short *value)
2352{
2353 off_t offset = NC_varoffset(ncpvarpstart);
2354 size_t remaining = varp->xsz * nelems;
2355 int status = NC_NOERR;
2356 void *xp;
2357
2358 if(nelems == 0)
2359 return NC_NOERR;
2360
2361 assert(value != NULL);
2362
2363 for(;;)
2364 {
2365 size_t extent = MIN(remainingncp->chunk);
2366 size_t nput = ncx_howmany(varp->typeextent);
2367
2368 int lstatus = ncio_get(ncp->nciopoffsetextent,
2369  RGN_WRITE, &xp);
2370 if(lstatus != NC_NOERR)
2371 return lstatus;
2372
2373 lstatus = ncx_putn_float_short(&xpnputvalue);
2374 if(lstatus != NC_NOERR && status == NC_NOERR)
2375 {
2376 /* not fatal to the loop */
2377 status = lstatus;
2378 }
2379
2380 (void) ncio_rel(ncp->nciopoffset,
2381  RGN_MODIFIED);
2382
2383 remaining -= extent;
2384 if(remaining == 0)
2385 break; /* normal loop exit */
2386 offset += extent;
2387 value += nput;
2388
2389 }
2390
2391 return status;
2392}
2393
2394static int
2395putNCvx_float_int(NC3_INFOncp, const NC_var *varp,
2396  const size_t *start, size_t nelems, const int *value)
2397{
2398 off_t offset = NC_varoffset(ncpvarpstart);
2399 size_t remaining = varp->xsz * nelems;
2400 int status = NC_NOERR;
2401 void *xp;
2402
2403 if(nelems == 0)
2404 return NC_NOERR;
2405
2406 assert(value != NULL);
2407
2408 for(;;)
2409 {
2410 size_t extent = MIN(remainingncp->chunk);
2411 size_t nput = ncx_howmany(varp->typeextent);
2412
2413 int lstatus = ncio_get(ncp->nciopoffsetextent,
2414  RGN_WRITE, &xp);
2415 if(lstatus != NC_NOERR)
2416 return lstatus;
2417
2418 lstatus = ncx_putn_float_int(&xpnputvalue);
2419 if(lstatus != NC_NOERR && status == NC_NOERR)
2420 {
2421 /* not fatal to the loop */
2422 status = lstatus;
2423 }
2424
2425 (void) ncio_rel(ncp->nciopoffset,
2426  RGN_MODIFIED);
2427
2428 remaining -= extent;
2429 if(remaining == 0)
2430 break; /* normal loop exit */
2431 offset += extent;
2432 value += nput;
2433
2434 }
2435
2436 return status;
2437}
2438
2439static int
2440putNCvx_float_float(NC3_INFOncp, const NC_var *varp,
2441  const size_t *start, size_t nelems, const float *value)
2442{
2443 off_t offset = NC_varoffset(ncpvarpstart);
2444 size_t remaining = varp->xsz * nelems;
2445 int status = NC_NOERR;
2446 void *xp;
2447
2448 if(nelems == 0)
2449 return NC_NOERR;
2450
2451 assert(value != NULL);
2452
2453 for(;;)
2454 {
2455 size_t extent = MIN(remainingncp->chunk);
2456 size_t nput = ncx_howmany(varp->typeextent);
2457
2458 int lstatus = ncio_get(ncp->nciopoffsetextent,
2459  RGN_WRITE, &xp);
2460 if(lstatus != NC_NOERR)
2461 return lstatus;
2462
2463 lstatus = ncx_putn_float_float(&xpnputvalue);
2464 if(lstatus != NC_NOERR && status == NC_NOERR)
2465 {
2466 /* not fatal to the loop */
2467 status = lstatus;
2468 }
2469
2470 (void) ncio_rel(ncp->nciopoffset,
2471  RGN_MODIFIED);
2472
2473 remaining -= extent;
2474 if(remaining == 0)
2475 break; /* normal loop exit */
2476 offset += extent;
2477 value += nput;
2478
2479 }
2480
2481 return status;
2482}
2483
2484static int
2485putNCvx_float_double(NC3_INFOncp, const NC_var *varp,
2486  const size_t *start, size_t nelems, const double *value)
2487{
2488 off_t offset = NC_varoffset(ncpvarpstart);
2489 size_t remaining = varp->xsz * nelems;
2490 int status = NC_NOERR;
2491 void *xp;
2492
2493 if(nelems == 0)
2494 return NC_NOERR;
2495
2496 assert(value != NULL);
2497
2498 for(;;)
2499 {
2500 size_t extent = MIN(remainingncp->chunk);
2501 size_t nput = ncx_howmany(varp->typeextent);
2502
2503 int lstatus = ncio_get(ncp->nciopoffsetextent,
2504  RGN_WRITE, &xp);
2505 if(lstatus != NC_NOERR)
2506 return lstatus;
2507
2508 lstatus = ncx_putn_float_double(&xpnputvalue);
2509 if(lstatus != NC_NOERR && status == NC_NOERR)
2510 {
2511 /* not fatal to the loop */
2512 status = lstatus;
2513 }
2514
2515 (void) ncio_rel(ncp->nciopoffset,
2516  RGN_MODIFIED);
2517
2518 remaining -= extent;
2519 if(remaining == 0)
2520 break; /* normal loop exit */
2521 offset += extent;
2522 value += nput;
2523
2524 }
2525
2526 return status;
2527}
2528
2529static int
2530putNCvx_float_longlong(NC3_INFOncp, const NC_var *varp,
2531  const size_t *start, size_t nelems, const longlong *value)
2532{
2533 off_t offset = NC_varoffset(ncpvarpstart);
2534 size_t remaining = varp->xsz * nelems;
2535 int status = NC_NOERR;
2536 void *xp;
2537
2538 if(nelems == 0)
2539 return NC_NOERR;
2540
2541 assert(value != NULL);
2542
2543 for(;;)
2544 {
2545 size_t extent = MIN(remainingncp->chunk);
2546 size_t nput = ncx_howmany(varp->typeextent);
2547
2548 int lstatus = ncio_get(ncp->nciopoffsetextent,
2549  RGN_WRITE, &xp);
2550 if(lstatus != NC_NOERR)
2551 return lstatus;
2552
2553 lstatus = ncx_putn_float_longlong(&xpnputvalue);
2554 if(lstatus != NC_NOERR && status == NC_NOERR)
2555 {
2556 /* not fatal to the loop */
2557 status = lstatus;
2558 }
2559
2560 (void) ncio_rel(ncp->nciopoffset,
2561  RGN_MODIFIED);
2562
2563 remaining -= extent;
2564 if(remaining == 0)
2565 break; /* normal loop exit */
2566 offset += extent;
2567 value += nput;
2568
2569 }
2570
2571 return status;
2572}
2573
2574static int
2575putNCvx_float_ushort(NC3_INFOncp, const NC_var *varp,
2576  const size_t *start, size_t nelems, const ushort *value)
2577{
2578 off_t offset = NC_varoffset(ncpvarpstart);
2579 size_t remaining = varp->xsz * nelems;
2580 int status = NC_NOERR;
2581 void *xp;
2582
2583 if(nelems == 0)
2584 return NC_NOERR;
2585
2586 assert(value != NULL);
2587
2588 for(;;)
2589 {
2590 size_t extent = MIN(remainingncp->chunk);
2591 size_t nput = ncx_howmany(varp->typeextent);
2592
2593 int lstatus = ncio_get(ncp->nciopoffsetextent,
2594  RGN_WRITE, &xp);
2595 if(lstatus != NC_NOERR)
2596 return lstatus;
2597
2598 lstatus = ncx_putn_float_ushort(&xpnputvalue);
2599 if(lstatus != NC_NOERR && status == NC_NOERR)
2600 {
2601 /* not fatal to the loop */
2602 status = lstatus;
2603 }
2604
2605 (void) ncio_rel(ncp->nciopoffset,
2606  RGN_MODIFIED);
2607
2608 remaining -= extent;
2609 if(remaining == 0)
2610 break; /* normal loop exit */
2611 offset += extent;
2612 value += nput;
2613
2614 }
2615
2616 return status;
2617}
2618
2619static int
2620putNCvx_float_uint(NC3_INFOncp, const NC_var *varp,
2621  const size_t *start, size_t nelems, const uint *value)
2622{
2623 off_t offset = NC_varoffset(ncpvarpstart);
2624 size_t remaining = varp->xsz * nelems;
2625 int status = NC_NOERR;
2626 void *xp;
2627
2628 if(nelems == 0)
2629 return NC_NOERR;
2630
2631 assert(value != NULL);
2632
2633 for(;;)
2634 {
2635 size_t extent = MIN(remainingncp->chunk);
2636 size_t nput = ncx_howmany(varp->typeextent);
2637
2638 int lstatus = ncio_get(ncp->nciopoffsetextent,
2639  RGN_WRITE, &xp);
2640 if(lstatus != NC_NOERR)
2641 return lstatus;
2642
2643 lstatus = ncx_putn_float_uint(&xpnputvalue);
2644 if(lstatus != NC_NOERR && status == NC_NOERR)
2645 {
2646 /* not fatal to the loop */
2647 status = lstatus;
2648 }
2649
2650 (void) ncio_rel(ncp->nciopoffset,
2651  RGN_MODIFIED);
2652
2653 remaining -= extent;
2654 if(remaining == 0)
2655 break; /* normal loop exit */
2656 offset += extent;
2657 value += nput;
2658
2659 }
2660
2661 return status;
2662}
2663
2664static int
2665putNCvx_float_ulonglong(NC3_INFOncp, const NC_var *varp,
2666  const size_t *start, size_t nelems, const ulonglong *value)
2667{
2668 off_t offset = NC_varoffset(ncpvarpstart);
2669 size_t remaining = varp->xsz * nelems;
2670 int status = NC_NOERR;
2671 void *xp;
2672
2673 if(nelems == 0)
2674 return NC_NOERR;
2675
2676 assert(value != NULL);
2677
2678 for(;;)
2679 {
2680 size_t extent = MIN(remainingncp->chunk);
2681 size_t nput = ncx_howmany(varp->typeextent);
2682
2683 int lstatus = ncio_get(ncp->nciopoffsetextent,
2684  RGN_WRITE, &xp);
2685 if(lstatus != NC_NOERR)
2686 return lstatus;
2687
2688 lstatus = ncx_putn_float_ulonglong(&xpnputvalue);
2689 if(lstatus != NC_NOERR && status == NC_NOERR)
2690 {
2691 /* not fatal to the loop */
2692 status = lstatus;
2693 }
2694
2695 (void) ncio_rel(ncp->nciopoffset,
2696  RGN_MODIFIED);
2697
2698 remaining -= extent;
2699 if(remaining == 0)
2700 break; /* normal loop exit */
2701 offset += extent;
2702 value += nput;
2703
2704 }
2705
2706 return status;
2707}
2708
2709
2710static int
2711putNCvx_double_schar(NC3_INFOncp, const NC_var *varp,
2712  const size_t *start, size_t nelems, const schar *value)
2713{
2714 off_t offset = NC_varoffset(ncpvarpstart);
2715 size_t remaining = varp->xsz * nelems;
2716 int status = NC_NOERR;
2717 void *xp;
2718
2719 if(nelems == 0)
2720 return NC_NOERR;
2721
2722 assert(value != NULL);
2723
2724 for(;;)
2725 {
2726 size_t extent = MIN(remainingncp->chunk);
2727 size_t nput = ncx_howmany(varp->typeextent);
2728
2729 int lstatus = ncio_get(ncp->nciopoffsetextent,
2730  RGN_WRITE, &xp);
2731 if(lstatus != NC_NOERR)
2732 return lstatus;
2733
2734 lstatus = ncx_putn_double_schar(&xpnputvalue);
2735 if(lstatus != NC_NOERR && status == NC_NOERR)
2736 {
2737 /* not fatal to the loop */
2738 status = lstatus;
2739 }
2740
2741 (void) ncio_rel(ncp->nciopoffset,
2742  RGN_MODIFIED);
2743
2744 remaining -= extent;
2745 if(remaining == 0)
2746 break; /* normal loop exit */
2747 offset += extent;
2748 value += nput;
2749
2750 }
2751
2752 return status;
2753}
2754
2755static int
2756putNCvx_double_uchar(NC3_INFOncp, const NC_var *varp,
2757  const size_t *start, size_t nelems, const uchar *value)
2758{
2759 off_t offset = NC_varoffset(ncpvarpstart);
2760 size_t remaining = varp->xsz * nelems;
2761 int status = NC_NOERR;
2762 void *xp;
2763
2764 if(nelems == 0)
2765 return NC_NOERR;
2766
2767 assert(value != NULL);
2768
2769 for(;;)
2770 {
2771 size_t extent = MIN(remainingncp->chunk);
2772 size_t nput = ncx_howmany(varp->typeextent);
2773
2774 int lstatus = ncio_get(ncp->nciopoffsetextent,
2775  RGN_WRITE, &xp);
2776 if(lstatus != NC_NOERR)
2777 return lstatus;
2778
2779 lstatus = ncx_putn_double_uchar(&xpnputvalue);
2780 if(lstatus != NC_NOERR && status == NC_NOERR)
2781 {
2782 /* not fatal to the loop */
2783 status = lstatus;
2784 }
2785
2786 (void) ncio_rel(ncp->nciopoffset,
2787  RGN_MODIFIED);
2788
2789 remaining -= extent;
2790 if(remaining == 0)
2791 break; /* normal loop exit */
2792 offset += extent;
2793 value += nput;
2794
2795 }
2796
2797 return status;
2798}
2799
2800static int
2801putNCvx_double_short(NC3_INFOncp, const NC_var *varp,
2802  const size_t *start, size_t nelems, const short *value)
2803{
2804 off_t offset = NC_varoffset(ncpvarpstart);
2805 size_t remaining = varp->xsz * nelems;
2806 int status = NC_NOERR;
2807 void *xp;
2808
2809 if(nelems == 0)
2810 return NC_NOERR;
2811
2812 assert(value != NULL);
2813
2814 for(;;)
2815 {
2816 size_t extent = MIN(remainingncp->chunk);
2817 size_t nput = ncx_howmany(varp->typeextent);
2818
2819 int lstatus = ncio_get(ncp->nciopoffsetextent,
2820  RGN_WRITE, &xp);
2821 if(lstatus != NC_NOERR)
2822 return lstatus;
2823
2824 lstatus = ncx_putn_double_short(&xpnputvalue);
2825 if(lstatus != NC_NOERR && status == NC_NOERR)
2826 {
2827 /* not fatal to the loop */
2828 status = lstatus;
2829 }
2830
2831 (void) ncio_rel(ncp->nciopoffset,
2832  RGN_MODIFIED);
2833
2834 remaining -= extent;
2835 if(remaining == 0)
2836 break; /* normal loop exit */
2837 offset += extent;
2838 value += nput;
2839
2840 }
2841
2842 return status;
2843}
2844
2845static int
2846putNCvx_double_int(NC3_INFOncp, const NC_var *varp,
2847  const size_t *start, size_t nelems, const int *value)
2848{
2849 off_t offset = NC_varoffset(ncpvarpstart);
2850 size_t remaining = varp->xsz * nelems;
2851 int status = NC_NOERR;
2852 void *xp;
2853
2854 if(nelems == 0)
2855 return NC_NOERR;
2856
2857 assert(value != NULL);
2858
2859 for(;;)
2860 {
2861 size_t extent = MIN(remainingncp->chunk);
2862 size_t nput = ncx_howmany(varp->typeextent);
2863
2864 int lstatus = ncio_get(ncp->nciopoffsetextent,
2865  RGN_WRITE, &xp);
2866 if(lstatus != NC_NOERR)
2867 return lstatus;
2868
2869 lstatus = ncx_putn_double_int(&xpnputvalue);
2870 if(lstatus != NC_NOERR && status == NC_NOERR)
2871 {
2872 /* not fatal to the loop */
2873 status = lstatus;
2874 }
2875
2876 (void) ncio_rel(ncp->nciopoffset,
2877  RGN_MODIFIED);
2878
2879 remaining -= extent;
2880 if(remaining == 0)
2881 break; /* normal loop exit */
2882 offset += extent;
2883 value += nput;
2884
2885 }
2886
2887 return status;
2888}
2889
2890static int
2891putNCvx_double_float(NC3_INFOncp, const NC_var *varp,
2892  const size_t *start, size_t nelems, const float *value)
2893{
2894 off_t offset = NC_varoffset(ncpvarpstart);
2895 size_t remaining = varp->xsz * nelems;
2896 int status = NC_NOERR;
2897 void *xp;
2898
2899 if(nelems == 0)
2900 return NC_NOERR;
2901
2902 assert(value != NULL);
2903
2904 for(;;)
2905 {
2906 size_t extent = MIN(remainingncp->chunk);
2907 size_t nput = ncx_howmany(varp->typeextent);
2908
2909 int lstatus = ncio_get(ncp->nciopoffsetextent,
2910  RGN_WRITE, &xp);
2911 if(lstatus != NC_NOERR)
2912 return lstatus;
2913
2914 lstatus = ncx_putn_double_float(&xpnputvalue);
2915 if(lstatus != NC_NOERR && status == NC_NOERR)
2916 {
2917 /* not fatal to the loop */
2918 status = lstatus;
2919 }
2920
2921 (void) ncio_rel(ncp->nciopoffset,
2922  RGN_MODIFIED);
2923
2924 remaining -= extent;
2925 if(remaining == 0)
2926 break; /* normal loop exit */
2927 offset += extent;
2928 value += nput;
2929
2930 }
2931
2932 return status;
2933}
2934
2935static int
2936putNCvx_double_double(NC3_INFOncp, const NC_var *varp,
2937  const size_t *start, size_t nelems, const double *value)
2938{
2939 off_t offset = NC_varoffset(ncpvarpstart);
2940 size_t remaining = varp->xsz * nelems;
2941 int status = NC_NOERR;
2942 void *xp;
2943
2944 if(nelems == 0)
2945 return NC_NOERR;
2946
2947 assert(value != NULL);
2948
2949 for(;;)
2950 {
2951 size_t extent = MIN(remainingncp->chunk);
2952 size_t nput = ncx_howmany(varp->typeextent);
2953
2954 int lstatus = ncio_get(ncp->nciopoffsetextent,
2955  RGN_WRITE, &xp);
2956 if(lstatus != NC_NOERR)
2957 return lstatus;
2958
2959 lstatus = ncx_putn_double_double(&xpnputvalue);
2960 if(lstatus != NC_NOERR && status == NC_NOERR)
2961 {
2962 /* not fatal to the loop */
2963 status = lstatus;
2964 }
2965
2966 (void) ncio_rel(ncp->nciopoffset,
2967  RGN_MODIFIED);
2968
2969 remaining -= extent;
2970 if(remaining == 0)
2971 break; /* normal loop exit */
2972 offset += extent;
2973 value += nput;
2974
2975 }
2976
2977 return status;
2978}
2979
2980static int
2981putNCvx_double_longlong(NC3_INFOncp, const NC_var *varp,
2982  const size_t *start, size_t nelems, const longlong *value)
2983{
2984 off_t offset = NC_varoffset(ncpvarpstart);
2985 size_t remaining = varp->xsz * nelems;
2986 int status = NC_NOERR;
2987 void *xp;
2988
2989 if(nelems == 0)
2990 return NC_NOERR;
2991
2992 assert(value != NULL);
2993
2994 for(;;)
2995 {
2996 size_t extent = MIN(remainingncp->chunk);
2997 size_t nput = ncx_howmany(varp->typeextent);
2998
2999 int lstatus = ncio_get(ncp->nciopoffsetextent,
3000  RGN_WRITE, &xp);
3001 if(lstatus != NC_NOERR)
3002 return lstatus;
3003
3004 lstatus = ncx_putn_double_longlong(&xpnputvalue);
3005 if(lstatus != NC_NOERR && status == NC_NOERR)
3006 {
3007 /* not fatal to the loop */
3008 status = lstatus;
3009 }
3010
3011 (void) ncio_rel(ncp->nciopoffset,
3012  RGN_MODIFIED);
3013
3014 remaining -= extent;
3015 if(remaining == 0)
3016 break; /* normal loop exit */
3017 offset += extent;
3018 value += nput;
3019
3020 }
3021
3022 return status;
3023}
3024
3025static int
3026putNCvx_double_ushort(NC3_INFOncp, const NC_var *varp,
3027  const size_t *start, size_t nelems, const ushort *value)
3028{
3029 off_t offset = NC_varoffset(ncpvarpstart);
3030 size_t remaining = varp->xsz * nelems;
3031 int status = NC_NOERR;
3032 void *xp;
3033
3034 if(nelems == 0)
3035 return NC_NOERR;
3036
3037 assert(value != NULL);
3038
3039 for(;;)
3040 {
3041 size_t extent = MIN(remainingncp->chunk);
3042 size_t nput = ncx_howmany(varp->typeextent);
3043
3044 int lstatus = ncio_get(ncp->nciopoffsetextent,
3045  RGN_WRITE, &xp);
3046 if(lstatus != NC_NOERR)
3047 return lstatus;
3048
3049 lstatus = ncx_putn_double_ushort(&xpnputvalue);
3050 if(lstatus != NC_NOERR && status == NC_NOERR)
3051 {
3052 /* not fatal to the loop */
3053 status = lstatus;
3054 }
3055
3056 (void) ncio_rel(ncp->nciopoffset,
3057  RGN_MODIFIED);
3058
3059 remaining -= extent;
3060 if(remaining == 0)
3061 break; /* normal loop exit */
3062 offset += extent;
3063 value += nput;
3064
3065 }
3066
3067 return status;
3068}
3069
3070static int
3071putNCvx_double_uint(NC3_INFOncp, const NC_var *varp,
3072  const size_t *start, size_t nelems, const uint *value)
3073{
3074 off_t offset = NC_varoffset(ncpvarpstart);
3075 size_t remaining = varp->xsz * nelems;
3076 int status = NC_NOERR;
3077 void *xp;
3078
3079 if(nelems == 0)
3080 return NC_NOERR;
3081
3082 assert(value != NULL);
3083
3084 for(;;)
3085 {
3086 size_t extent = MIN(remainingncp->chunk);
3087 size_t nput = ncx_howmany(varp->typeextent);
3088
3089 int lstatus = ncio_get(ncp->nciopoffsetextent,
3090  RGN_WRITE, &xp);
3091 if(lstatus != NC_NOERR)
3092 return lstatus;
3093
3094 lstatus = ncx_putn_double_uint(&xpnputvalue);
3095 if(lstatus != NC_NOERR && status == NC_NOERR)
3096 {
3097 /* not fatal to the loop */
3098 status = lstatus;
3099 }
3100
3101 (void) ncio_rel(ncp->nciopoffset,
3102  RGN_MODIFIED);
3103
3104 remaining -= extent;
3105 if(remaining == 0)
3106 break; /* normal loop exit */
3107 offset += extent;
3108 value += nput;
3109
3110 }
3111
3112 return status;
3113}
3114
3115static int
3116putNCvx_double_ulonglong(NC3_INFOncp, const NC_var *varp,
3117  const size_t *start, size_t nelems, const ulonglong *value)
3118{
3119 off_t offset = NC_varoffset(ncpvarpstart);
3120 size_t remaining = varp->xsz * nelems;
3121 int status = NC_NOERR;
3122 void *xp;
3123
3124 if(nelems == 0)
3125 return NC_NOERR;
3126
3127 assert(value != NULL);
3128
3129 for(;;)
3130 {
3131 size_t extent = MIN(remainingncp->chunk);
3132 size_t nput = ncx_howmany(varp->typeextent);
3133
3134 int lstatus = ncio_get(ncp->nciopoffsetextent,
3135  RGN_WRITE, &xp);
3136 if(lstatus != NC_NOERR)
3137 return lstatus;
3138
3139 lstatus = ncx_putn_double_ulonglong(&xpnputvalue);
3140 if(lstatus != NC_NOERR && status == NC_NOERR)
3141 {
3142 /* not fatal to the loop */
3143 status = lstatus;
3144 }
3145
3146 (void) ncio_rel(ncp->nciopoffset,
3147  RGN_MODIFIED);
3148
3149 remaining -= extent;
3150 if(remaining == 0)
3151 break; /* normal loop exit */
3152 offset += extent;
3153 value += nput;
3154
3155 }
3156
3157 return status;
3158}
3159
3160
3161static int
3162putNCvx_uchar_schar(NC3_INFOncp, const NC_var *varp,
3163  const size_t *start, size_t nelems, const schar *value)
3164{
3165 off_t offset = NC_varoffset(ncpvarpstart);
3166 size_t remaining = varp->xsz * nelems;
3167 int status = NC_NOERR;
3168 void *xp;
3169
3170 if(nelems == 0)
3171 return NC_NOERR;
3172
3173 assert(value != NULL);
3174
3175 for(;;)
3176 {
3177 size_t extent = MIN(remainingncp->chunk);
3178 size_t nput = ncx_howmany(varp->typeextent);
3179
3180 int lstatus = ncio_get(ncp->nciopoffsetextent,
3181  RGN_WRITE, &xp);
3182 if(lstatus != NC_NOERR)
3183 return lstatus;
3184
3185 lstatus = ncx_putn_uchar_schar(&xpnputvalue);
3186 if(lstatus != NC_NOERR && status == NC_NOERR)
3187 {
3188 /* not fatal to the loop */
3189 status = lstatus;
3190 }
3191
3192 (void) ncio_rel(ncp->nciopoffset,
3193  RGN_MODIFIED);
3194
3195 remaining -= extent;
3196 if(remaining == 0)
3197 break; /* normal loop exit */
3198 offset += extent;
3199 value += nput;
3200
3201 }
3202
3203 return status;
3204}
3205
3206static int
3207putNCvx_uchar_uchar(NC3_INFOncp, const NC_var *varp,
3208  const size_t *start, size_t nelems, const uchar *value)
3209{
3210 off_t offset = NC_varoffset(ncpvarpstart);
3211 size_t remaining = varp->xsz * nelems;
3212 int status = NC_NOERR;
3213 void *xp;
3214
3215 if(nelems == 0)
3216 return NC_NOERR;
3217
3218 assert(value != NULL);
3219
3220 for(;;)
3221 {
3222 size_t extent = MIN(remainingncp->chunk);
3223 size_t nput = ncx_howmany(varp->typeextent);
3224
3225 int lstatus = ncio_get(ncp->nciopoffsetextent,
3226  RGN_WRITE, &xp);
3227 if(lstatus != NC_NOERR)
3228 return lstatus;
3229
3230 lstatus = ncx_putn_uchar_uchar(&xpnputvalue);
3231 if(lstatus != NC_NOERR && status == NC_NOERR)
3232 {
3233 /* not fatal to the loop */
3234 status = lstatus;
3235 }
3236
3237 (void) ncio_rel(ncp->nciopoffset,
3238  RGN_MODIFIED);
3239
3240 remaining -= extent;
3241 if(remaining == 0)
3242 break; /* normal loop exit */
3243 offset += extent;
3244 value += nput;
3245
3246 }
3247
3248 return status;
3249}
3250
3251static int
3252putNCvx_uchar_short(NC3_INFOncp, const NC_var *varp,
3253  const size_t *start, size_t nelems, const short *value)
3254{
3255 off_t offset = NC_varoffset(ncpvarpstart);
3256 size_t remaining = varp->xsz * nelems;
3257 int status = NC_NOERR;
3258 void *xp;
3259
3260 if(nelems == 0)
3261 return NC_NOERR;
3262
3263 assert(value != NULL);
3264
3265 for(;;)
3266 {
3267 size_t extent = MIN(remainingncp->chunk);
3268 size_t nput = ncx_howmany(varp->typeextent);
3269
3270 int lstatus = ncio_get(ncp->nciopoffsetextent,
3271  RGN_WRITE, &xp);
3272 if(lstatus != NC_NOERR)
3273 return lstatus;
3274
3275 lstatus = ncx_putn_uchar_short(&xpnputvalue);
3276 if(lstatus != NC_NOERR && status == NC_NOERR)
3277 {
3278 /* not fatal to the loop */
3279 status = lstatus;
3280 }
3281
3282 (void) ncio_rel(ncp->nciopoffset,
3283  RGN_MODIFIED);
3284
3285 remaining -= extent;
3286 if(remaining == 0)
3287 break; /* normal loop exit */
3288 offset += extent;
3289 value += nput;
3290
3291 }
3292
3293 return status;
3294}
3295
3296static int
3297putNCvx_uchar_int(NC3_INFOncp, const NC_var *varp,
3298  const size_t *start, size_t nelems, const int *value)
3299{
3300 off_t offset = NC_varoffset(ncpvarpstart);
3301 size_t remaining = varp->xsz * nelems;
3302 int status = NC_NOERR;
3303 void *xp;
3304
3305 if(nelems == 0)
3306 return NC_NOERR;
3307
3308 assert(value != NULL);
3309
3310 for(;;)
3311 {
3312 size_t extent = MIN(remainingncp->chunk);
3313 size_t nput = ncx_howmany(varp->typeextent);
3314
3315 int lstatus = ncio_get(ncp->nciopoffsetextent,
3316  RGN_WRITE, &xp);
3317 if(lstatus != NC_NOERR)
3318 return lstatus;
3319
3320 lstatus = ncx_putn_uchar_int(&xpnputvalue);
3321 if(lstatus != NC_NOERR && status == NC_NOERR)
3322 {
3323 /* not fatal to the loop */
3324 status = lstatus;
3325 }
3326
3327 (void) ncio_rel(ncp->nciopoffset,
3328  RGN_MODIFIED);
3329
3330 remaining -= extent;
3331 if(remaining == 0)
3332 break; /* normal loop exit */
3333 offset += extent;
3334 value += nput;
3335
3336 }
3337
3338 return status;
3339}
3340
3341static int
3342putNCvx_uchar_float(NC3_INFOncp, const NC_var *varp,
3343  const size_t *start, size_t nelems, const float *value)
3344{
3345 off_t offset = NC_varoffset(ncpvarpstart);
3346 size_t remaining = varp->xsz * nelems;
3347 int status = NC_NOERR;
3348 void *xp;
3349
3350 if(nelems == 0)
3351 return NC_NOERR;
3352
3353 assert(value != NULL);
3354
3355 for(;;)
3356 {
3357 size_t extent = MIN(remainingncp->chunk);
3358 size_t nput = ncx_howmany(varp->typeextent);
3359
3360 int lstatus = ncio_get(ncp->nciopoffsetextent,
3361  RGN_WRITE, &xp);
3362 if(lstatus != NC_NOERR)
3363 return lstatus;
3364
3365 lstatus = ncx_putn_uchar_float(&xpnputvalue);
3366 if(lstatus != NC_NOERR && status == NC_NOERR)
3367 {
3368 /* not fatal to the loop */
3369 status = lstatus;
3370 }
3371
3372 (void) ncio_rel(ncp->nciopoffset,
3373  RGN_MODIFIED);
3374
3375 remaining -= extent;
3376 if(remaining == 0)
3377 break; /* normal loop exit */
3378 offset += extent;
3379 value += nput;
3380
3381 }
3382
3383 return status;
3384}
3385
3386static int
3387putNCvx_uchar_double(NC3_INFOncp, const NC_var *varp,
3388  const size_t *start, size_t nelems, const double *value)
3389{
3390 off_t offset = NC_varoffset(ncpvarpstart);
3391 size_t remaining = varp->xsz * nelems;
3392 int status = NC_NOERR;
3393 void *xp;
3394
3395 if(nelems == 0)
3396 return NC_NOERR;
3397
3398 assert(value != NULL);
3399
3400 for(;;)
3401 {
3402 size_t extent = MIN(remainingncp->chunk);
3403 size_t nput = ncx_howmany(varp->typeextent);
3404
3405 int lstatus = ncio_get(ncp->nciopoffsetextent,
3406  RGN_WRITE, &xp);
3407 if(lstatus != NC_NOERR)
3408 return lstatus;
3409
3410 lstatus = ncx_putn_uchar_double(&xpnputvalue);
3411 if(lstatus != NC_NOERR && status == NC_NOERR)
3412 {
3413 /* not fatal to the loop */
3414 status = lstatus;
3415 }
3416
3417 (void) ncio_rel(ncp->nciopoffset,
3418  RGN_MODIFIED);
3419
3420 remaining -= extent;
3421 if(remaining == 0)
3422 break; /* normal loop exit */
3423 offset += extent;
3424 value += nput;
3425
3426 }
3427
3428 return status;
3429}
3430
3431static int
3432putNCvx_uchar_longlong(NC3_INFOncp, const NC_var *varp,
3433  const size_t *start, size_t nelems, const longlong *value)
3434{
3435 off_t offset = NC_varoffset(ncpvarpstart);
3436 size_t remaining = varp->xsz * nelems;
3437 int status = NC_NOERR;
3438 void *xp;
3439
3440 if(nelems == 0)
3441 return NC_NOERR;
3442
3443 assert(value != NULL);
3444
3445 for(;;)
3446 {
3447 size_t extent = MIN(remainingncp->chunk);
3448 size_t nput = ncx_howmany(varp->typeextent);
3449
3450 int lstatus = ncio_get(ncp->nciopoffsetextent,
3451  RGN_WRITE, &xp);
3452 if(lstatus != NC_NOERR)
3453 return lstatus;
3454
3455 lstatus = ncx_putn_uchar_longlong(&xpnputvalue);
3456 if(lstatus != NC_NOERR && status == NC_NOERR)
3457 {
3458 /* not fatal to the loop */
3459 status = lstatus;
3460 }
3461
3462 (void) ncio_rel(ncp->nciopoffset,
3463  RGN_MODIFIED);
3464
3465 remaining -= extent;
3466 if(remaining == 0)
3467 break; /* normal loop exit */
3468 offset += extent;
3469 value += nput;
3470
3471 }
3472
3473 return status;
3474}
3475
3476static int
3477putNCvx_uchar_ushort(NC3_INFOncp, const NC_var *varp,
3478  const size_t *start, size_t nelems, const ushort *value)
3479{
3480 off_t offset = NC_varoffset(ncpvarpstart);
3481 size_t remaining = varp->xsz * nelems;
3482 int status = NC_NOERR;
3483 void *xp;
3484
3485 if(nelems == 0)
3486 return NC_NOERR;
3487
3488 assert(value != NULL);
3489
3490 for(;;)
3491 {
3492 size_t extent = MIN(remainingncp->chunk);
3493 size_t nput = ncx_howmany(varp->typeextent);
3494
3495 int lstatus = ncio_get(ncp->nciopoffsetextent,
3496  RGN_WRITE, &xp);
3497 if(lstatus != NC_NOERR)
3498 return lstatus;
3499
3500 lstatus = ncx_putn_uchar_ushort(&xpnputvalue);
3501 if(lstatus != NC_NOERR && status == NC_NOERR)
3502 {
3503 /* not fatal to the loop */
3504 status = lstatus;
3505 }
3506
3507 (void) ncio_rel(ncp->nciopoffset,
3508  RGN_MODIFIED);
3509
3510 remaining -= extent;
3511 if(remaining == 0)
3512 break; /* normal loop exit */
3513 offset += extent;
3514 value += nput;
3515
3516 }
3517
3518 return status;
3519}
3520
3521static int
3522putNCvx_uchar_uint(NC3_INFOncp, const NC_var *varp,
3523  const size_t *start, size_t nelems, const uint *value)
3524{
3525 off_t offset = NC_varoffset(ncpvarpstart);
3526 size_t remaining = varp->xsz * nelems;
3527 int status = NC_NOERR;
3528 void *xp;
3529
3530 if(nelems == 0)
3531 return NC_NOERR;
3532
3533 assert(value != NULL);
3534
3535 for(;;)
3536 {
3537 size_t extent = MIN(remainingncp->chunk);
3538 size_t nput = ncx_howmany(varp->typeextent);
3539
3540 int lstatus = ncio_get(ncp->nciopoffsetextent,
3541  RGN_WRITE, &xp);
3542 if(lstatus != NC_NOERR)
3543 return lstatus;
3544
3545 lstatus = ncx_putn_uchar_uint(&xpnputvalue);
3546 if(lstatus != NC_NOERR && status == NC_NOERR)
3547 {
3548 /* not fatal to the loop */
3549 status = lstatus;
3550 }
3551
3552 (void) ncio_rel(ncp->nciopoffset,
3553  RGN_MODIFIED);
3554
3555 remaining -= extent;
3556 if(remaining == 0)
3557 break; /* normal loop exit */
3558 offset += extent;
3559 value += nput;
3560
3561 }
3562
3563 return status;
3564}
3565
3566static int
3567putNCvx_uchar_ulonglong(NC3_INFOncp, const NC_var *varp,
3568  const size_t *start, size_t nelems, const ulonglong *value)
3569{
3570 off_t offset = NC_varoffset(ncpvarpstart);
3571 size_t remaining = varp->xsz * nelems;
3572 int status = NC_NOERR;
3573 void *xp;
3574
3575 if(nelems == 0)
3576 return NC_NOERR;
3577
3578 assert(value != NULL);
3579
3580 for(;;)
3581 {
3582 size_t extent = MIN(remainingncp->chunk);
3583 size_t nput = ncx_howmany(varp->typeextent);
3584
3585 int lstatus = ncio_get(ncp->nciopoffsetextent,
3586  RGN_WRITE, &xp);
3587 if(lstatus != NC_NOERR)
3588 return lstatus;
3589
3590 lstatus = ncx_putn_uchar_ulonglong(&xpnputvalue);
3591 if(lstatus != NC_NOERR && status == NC_NOERR)
3592 {
3593 /* not fatal to the loop */
3594 status = lstatus;
3595 }
3596
3597 (void) ncio_rel(ncp->nciopoffset,
3598  RGN_MODIFIED);
3599
3600 remaining -= extent;
3601 if(remaining == 0)
3602 break; /* normal loop exit */
3603 offset += extent;
3604 value += nput;
3605
3606 }
3607
3608 return status;
3609}
3610
3611
3612static int
3613putNCvx_ushort_schar(NC3_INFOncp, const NC_var *varp,
3614  const size_t *start, size_t nelems, const schar *value)
3615{
3616 off_t offset = NC_varoffset(ncpvarpstart);
3617 size_t remaining = varp->xsz * nelems;
3618 int status = NC_NOERR;
3619 void *xp;
3620
3621 if(nelems == 0)
3622 return NC_NOERR;
3623
3624 assert(value != NULL);
3625
3626 for(;;)
3627 {
3628 size_t extent = MIN(remainingncp->chunk);
3629 size_t nput = ncx_howmany(varp->typeextent);
3630
3631 int lstatus = ncio_get(ncp->nciopoffsetextent,
3632  RGN_WRITE, &xp);
3633 if(lstatus != NC_NOERR)
3634 return lstatus;
3635
3636 lstatus = ncx_putn_ushort_schar(&xpnputvalue);
3637 if(lstatus != NC_NOERR && status == NC_NOERR)
3638 {
3639 /* not fatal to the loop */
3640 status = lstatus;
3641 }
3642
3643 (void) ncio_rel(ncp->nciopoffset,
3644  RGN_MODIFIED);
3645
3646 remaining -= extent;
3647 if(remaining == 0)
3648 break; /* normal loop exit */
3649 offset += extent;
3650 value += nput;
3651
3652 }
3653
3654 return status;
3655}
3656
3657static int
3658putNCvx_ushort_uchar(NC3_INFOncp, const NC_var *varp,
3659  const size_t *start, size_t nelems, const uchar *value)
3660{
3661 off_t offset = NC_varoffset(ncpvarpstart);
3662 size_t remaining = varp->xsz * nelems;
3663 int status = NC_NOERR;
3664 void *xp;
3665
3666 if(nelems == 0)
3667 return NC_NOERR;
3668
3669 assert(value != NULL);
3670
3671 for(;;)
3672 {
3673 size_t extent = MIN(remainingncp->chunk);
3674 size_t nput = ncx_howmany(varp->typeextent);
3675
3676 int lstatus = ncio_get(ncp->nciopoffsetextent,
3677  RGN_WRITE, &xp);
3678 if(lstatus != NC_NOERR)
3679 return lstatus;
3680
3681 lstatus = ncx_putn_ushort_uchar(&xpnputvalue);
3682 if(lstatus != NC_NOERR && status == NC_NOERR)
3683 {
3684 /* not fatal to the loop */
3685 status = lstatus;
3686 }
3687
3688 (void) ncio_rel(ncp->nciopoffset,
3689  RGN_MODIFIED);
3690
3691 remaining -= extent;
3692 if(remaining == 0)
3693 break; /* normal loop exit */
3694 offset += extent;
3695 value += nput;
3696
3697 }
3698
3699 return status;
3700}
3701
3702static int
3703putNCvx_ushort_short(NC3_INFOncp, const NC_var *varp,
3704  const size_t *start, size_t nelems, const short *value)
3705{
3706 off_t offset = NC_varoffset(ncpvarpstart);
3707 size_t remaining = varp->xsz * nelems;
3708 int status = NC_NOERR;
3709 void *xp;
3710
3711 if(nelems == 0)
3712 return NC_NOERR;
3713
3714 assert(value != NULL);
3715
3716 for(;;)
3717 {
3718 size_t extent = MIN(remainingncp->chunk);
3719 size_t nput = ncx_howmany(varp->typeextent);
3720
3721 int lstatus = ncio_get(ncp->nciopoffsetextent,
3722  RGN_WRITE, &xp);
3723 if(lstatus != NC_NOERR)
3724 return lstatus;
3725
3726 lstatus = ncx_putn_ushort_short(&xpnputvalue);
3727 if(lstatus != NC_NOERR && status == NC_NOERR)
3728 {
3729 /* not fatal to the loop */
3730 status = lstatus;
3731 }
3732
3733 (void) ncio_rel(ncp->nciopoffset,
3734  RGN_MODIFIED);
3735
3736 remaining -= extent;
3737 if(remaining == 0)
3738 break; /* normal loop exit */
3739 offset += extent;
3740 value += nput;
3741
3742 }
3743
3744 return status;
3745}
3746
3747static int
3748putNCvx_ushort_int(NC3_INFOncp, const NC_var *varp,
3749  const size_t *start, size_t nelems, const int *value)
3750{
3751 off_t offset = NC_varoffset(ncpvarpstart);
3752 size_t remaining = varp->xsz * nelems;
3753 int status = NC_NOERR;
3754 void *xp;
3755
3756 if(nelems == 0)
3757 return NC_NOERR;
3758
3759 assert(value != NULL);
3760
3761 for(;;)
3762 {
3763 size_t extent = MIN(remainingncp->chunk);
3764 size_t nput = ncx_howmany(varp->typeextent);
3765
3766 int lstatus = ncio_get(ncp->nciopoffsetextent,
3767  RGN_WRITE, &xp);
3768 if(lstatus != NC_NOERR)
3769 return lstatus;
3770
3771 lstatus = ncx_putn_ushort_int(&xpnputvalue);
3772 if(lstatus != NC_NOERR && status == NC_NOERR)
3773 {
3774 /* not fatal to the loop */
3775 status = lstatus;
3776 }
3777
3778 (void) ncio_rel(ncp->nciopoffset,
3779  RGN_MODIFIED);
3780
3781 remaining -= extent;
3782 if(remaining == 0)
3783 break; /* normal loop exit */
3784 offset += extent;
3785 value += nput;
3786
3787 }
3788
3789 return status;
3790}
3791
3792static int
3793putNCvx_ushort_float(NC3_INFOncp, const NC_var *varp,
3794  const size_t *start, size_t nelems, const float *value)
3795{
3796 off_t offset = NC_varoffset(ncpvarpstart);
3797 size_t remaining = varp->xsz * nelems;
3798 int status = NC_NOERR;
3799 void *xp;
3800
3801 if(nelems == 0)
3802 return NC_NOERR;
3803
3804 assert(value != NULL);
3805
3806 for(;;)
3807 {
3808 size_t extent = MIN(remainingncp->chunk);
3809 size_t nput = ncx_howmany(varp->typeextent);
3810
3811 int lstatus = ncio_get(ncp->nciopoffsetextent,
3812  RGN_WRITE, &xp);
3813 if(lstatus != NC_NOERR)
3814 return lstatus;
3815
3816 lstatus = ncx_putn_ushort_float(&xpnputvalue);
3817 if(lstatus != NC_NOERR && status == NC_NOERR)
3818 {
3819 /* not fatal to the loop */
3820 status = lstatus;
3821 }
3822
3823 (void) ncio_rel(ncp->nciopoffset,
3824  RGN_MODIFIED);
3825
3826 remaining -= extent;
3827 if(remaining == 0)
3828 break; /* normal loop exit */
3829 offset += extent;
3830 value += nput;
3831
3832 }
3833
3834 return status;
3835}
3836
3837static int
3838putNCvx_ushort_double(NC3_INFOncp, const NC_var *varp,
3839  const size_t *start, size_t nelems, const double *value)
3840{
3841 off_t offset = NC_varoffset(ncpvarpstart);
3842 size_t remaining = varp->xsz * nelems;
3843 int status = NC_NOERR;
3844 void *xp;
3845
3846 if(nelems == 0)
3847 return NC_NOERR;
3848
3849 assert(value != NULL);
3850
3851 for(;;)
3852 {
3853 size_t extent = MIN(remainingncp->chunk);
3854 size_t nput = ncx_howmany(varp->typeextent);
3855
3856 int lstatus = ncio_get(ncp->nciopoffsetextent,
3857  RGN_WRITE, &xp);
3858 if(lstatus != NC_NOERR)
3859 return lstatus;
3860
3861 lstatus = ncx_putn_ushort_double(&xpnputvalue);
3862 if(lstatus != NC_NOERR && status == NC_NOERR)
3863 {
3864 /* not fatal to the loop */
3865 status = lstatus;
3866 }
3867
3868 (void) ncio_rel(ncp->nciopoffset,
3869  RGN_MODIFIED);
3870
3871 remaining -= extent;
3872 if(remaining == 0)
3873 break; /* normal loop exit */
3874 offset += extent;
3875 value += nput;
3876
3877 }
3878
3879 return status;
3880}
3881
3882static int
3883putNCvx_ushort_longlong(NC3_INFOncp, const NC_var *varp,
3884  const size_t *start, size_t nelems, const longlong *value)
3885{
3886 off_t offset = NC_varoffset(ncpvarpstart);
3887 size_t remaining = varp->xsz * nelems;
3888 int status = NC_NOERR;
3889 void *xp;
3890
3891 if(nelems == 0)
3892 return NC_NOERR;
3893
3894 assert(value != NULL);
3895
3896 for(;;)
3897 {
3898 size_t extent = MIN(remainingncp->chunk);
3899 size_t nput = ncx_howmany(varp->typeextent);
3900
3901 int lstatus = ncio_get(ncp->nciopoffsetextent,
3902  RGN_WRITE, &xp);
3903 if(lstatus != NC_NOERR)
3904 return lstatus;
3905
3906 lstatus = ncx_putn_ushort_longlong(&xpnputvalue);
3907 if(lstatus != NC_NOERR && status == NC_NOERR)
3908 {
3909 /* not fatal to the loop */
3910 status = lstatus;
3911 }
3912
3913 (void) ncio_rel(ncp->nciopoffset,
3914  RGN_MODIFIED);
3915
3916 remaining -= extent;
3917 if(remaining == 0)
3918 break; /* normal loop exit */
3919 offset += extent;
3920 value += nput;
3921
3922 }
3923
3924 return status;
3925}
3926
3927static int
3928putNCvx_ushort_ushort(NC3_INFOncp, const NC_var *varp,
3929  const size_t *start, size_t nelems, const ushort *value)
3930{
3931 off_t offset = NC_varoffset(ncpvarpstart);
3932 size_t remaining = varp->xsz * nelems;
3933 int status = NC_NOERR;
3934 void *xp;
3935
3936 if(nelems == 0)
3937 return NC_NOERR;
3938
3939 assert(value != NULL);
3940
3941 for(;;)
3942 {
3943 size_t extent = MIN(remainingncp->chunk);
3944 size_t nput = ncx_howmany(varp->typeextent);
3945
3946 int lstatus = ncio_get(ncp->nciopoffsetextent,
3947  RGN_WRITE, &xp);
3948 if(lstatus != NC_NOERR)
3949 return lstatus;
3950
3951 lstatus = ncx_putn_ushort_ushort(&xpnputvalue);
3952 if(lstatus != NC_NOERR && status == NC_NOERR)
3953 {
3954 /* not fatal to the loop */
3955 status = lstatus;
3956 }
3957
3958 (void) ncio_rel(ncp->nciopoffset,
3959  RGN_MODIFIED);
3960
3961 remaining -= extent;
3962 if(remaining == 0)
3963 break; /* normal loop exit */
3964 offset += extent;
3965 value += nput;
3966
3967 }
3968
3969 return status;
3970}
3971
3972static int
3973putNCvx_ushort_uint(NC3_INFOncp, const NC_var *varp,
3974  const size_t *start, size_t nelems, const uint *value)
3975{
3976 off_t offset = NC_varoffset(ncpvarpstart);
3977 size_t remaining = varp->xsz * nelems;
3978 int status = NC_NOERR;
3979 void *xp;
3980
3981 if(nelems == 0)
3982 return NC_NOERR;
3983
3984 assert(value != NULL);
3985
3986 for(;;)
3987 {
3988 size_t extent = MIN(remainingncp->chunk);
3989 size_t nput = ncx_howmany(varp->typeextent);
3990
3991 int lstatus = ncio_get(ncp->nciopoffsetextent,
3992  RGN_WRITE, &xp);
3993 if(lstatus != NC_NOERR)
3994 return lstatus;
3995
3996 lstatus = ncx_putn_ushort_uint(&xpnputvalue);
3997 if(lstatus != NC_NOERR && status == NC_NOERR)
3998 {
3999 /* not fatal to the loop */
4000 status = lstatus;
4001 }
4002
4003 (void) ncio_rel(ncp->nciopoffset,
4004  RGN_MODIFIED);
4005
4006 remaining -= extent;
4007 if(remaining == 0)
4008 break; /* normal loop exit */
4009 offset += extent;
4010 value += nput;
4011
4012 }
4013
4014 return status;
4015}
4016
4017static int
4018putNCvx_ushort_ulonglong(NC3_INFOncp, const NC_var *varp,
4019  const size_t *start, size_t nelems, const ulonglong *value)
4020{
4021 off_t offset = NC_varoffset(ncpvarpstart);
4022 size_t remaining = varp->xsz * nelems;
4023 int status = NC_NOERR;
4024 void *xp;
4025
4026 if(nelems == 0)
4027 return NC_NOERR;
4028
4029 assert(value != NULL);
4030
4031 for(;;)
4032 {
4033 size_t extent = MIN(remainingncp->chunk);
4034 size_t nput = ncx_howmany(varp->typeextent);
4035
4036 int lstatus = ncio_get(ncp->nciopoffsetextent,
4037  RGN_WRITE, &xp);
4038 if(lstatus != NC_NOERR)
4039 return lstatus;
4040
4041 lstatus = ncx_putn_ushort_ulonglong(&xpnputvalue);
4042 if(lstatus != NC_NOERR && status == NC_NOERR)
4043 {
4044 /* not fatal to the loop */
4045 status = lstatus;
4046 }
4047
4048 (void) ncio_rel(ncp->nciopoffset,
4049  RGN_MODIFIED);
4050
4051 remaining -= extent;
4052 if(remaining == 0)
4053 break; /* normal loop exit */
4054 offset += extent;
4055 value += nput;
4056
4057 }
4058
4059 return status;
4060}
4061
4062
4063static int
4064putNCvx_uint_schar(NC3_INFOncp, const NC_var *varp,
4065  const size_t *start, size_t nelems, const schar *value)
4066{
4067 off_t offset = NC_varoffset(ncpvarpstart);
4068 size_t remaining = varp->xsz * nelems;
4069 int status = NC_NOERR;
4070 void *xp;
4071
4072 if(nelems == 0)
4073 return NC_NOERR;
4074
4075 assert(value != NULL);
4076
4077 for(;;)
4078 {
4079 size_t extent = MIN(remainingncp->chunk);
4080 size_t nput = ncx_howmany(varp->typeextent);
4081
4082 int lstatus = ncio_get(ncp->nciopoffsetextent,
4083  RGN_WRITE, &xp);
4084 if(lstatus != NC_NOERR)
4085 return lstatus;
4086
4087 lstatus = ncx_putn_uint_schar(&xpnputvalue);
4088 if(lstatus != NC_NOERR && status == NC_NOERR)
4089 {
4090 /* not fatal to the loop */
4091 status = lstatus;
4092 }
4093
4094 (void) ncio_rel(ncp->nciopoffset,
4095  RGN_MODIFIED);
4096
4097 remaining -= extent;
4098 if(remaining == 0)
4099 break; /* normal loop exit */
4100 offset += extent;
4101 value += nput;
4102
4103 }
4104
4105 return status;
4106}
4107
4108static int
4109putNCvx_uint_uchar(NC3_INFOncp, const NC_var *varp,
4110  const size_t *start, size_t nelems, const uchar *value)
4111{
4112 off_t offset = NC_varoffset(ncpvarpstart);
4113 size_t remaining = varp->xsz * nelems;
4114 int status = NC_NOERR;
4115 void *xp;
4116
4117 if(nelems == 0)
4118 return NC_NOERR;
4119
4120 assert(value != NULL);
4121
4122 for(;;)
4123 {
4124 size_t extent = MIN(remainingncp->chunk);
4125 size_t nput = ncx_howmany(varp->typeextent);
4126
4127 int lstatus = ncio_get(ncp->nciopoffsetextent,
4128  RGN_WRITE, &xp);
4129 if(lstatus != NC_NOERR)
4130 return lstatus;
4131
4132 lstatus = ncx_putn_uint_uchar(&xpnputvalue);
4133 if(lstatus != NC_NOERR && status == NC_NOERR)
4134 {
4135 /* not fatal to the loop */
4136 status = lstatus;
4137 }
4138
4139 (void) ncio_rel(ncp->nciopoffset,
4140  RGN_MODIFIED);
4141
4142 remaining -= extent;
4143 if(remaining == 0)
4144 break; /* normal loop exit */
4145 offset += extent;
4146 value += nput;
4147
4148 }
4149
4150 return status;
4151}
4152
4153static int
4154putNCvx_uint_short(NC3_INFOncp, const NC_var *varp,
4155  const size_t *start, size_t nelems, const short *value)
4156{
4157 off_t offset = NC_varoffset(ncpvarpstart);
4158 size_t remaining = varp->xsz * nelems;
4159 int status = NC_NOERR;
4160 void *xp;
4161
4162 if(nelems == 0)
4163 return NC_NOERR;
4164
4165 assert(value != NULL);
4166
4167 for(;;)
4168 {
4169 size_t extent = MIN(remainingncp->chunk);
4170 size_t nput = ncx_howmany(varp->typeextent);
4171
4172 int lstatus = ncio_get(ncp->nciopoffsetextent,
4173  RGN_WRITE, &xp);
4174 if(lstatus != NC_NOERR)
4175 return lstatus;
4176
4177 lstatus = ncx_putn_uint_short(&xpnputvalue);
4178 if(lstatus != NC_NOERR && status == NC_NOERR)
4179 {
4180 /* not fatal to the loop */
4181 status = lstatus;
4182 }
4183
4184 (void) ncio_rel(ncp->nciopoffset,
4185  RGN_MODIFIED);
4186
4187 remaining -= extent;
4188 if(remaining == 0)
4189 break; /* normal loop exit */
4190 offset += extent;
4191 value += nput;
4192
4193 }
4194
4195 return status;
4196}
4197
4198static int
4199putNCvx_uint_int(NC3_INFOncp, const NC_var *varp,
4200  const size_t *start, size_t nelems, const int *value)
4201{
4202 off_t offset = NC_varoffset(ncpvarpstart);
4203 size_t remaining = varp->xsz * nelems;
4204 int status = NC_NOERR;
4205 void *xp;
4206
4207 if(nelems == 0)
4208 return NC_NOERR;
4209
4210 assert(value != NULL);
4211
4212 for(;;)
4213 {
4214 size_t extent = MIN(remainingncp->chunk);
4215 size_t nput = ncx_howmany(varp->typeextent);
4216
4217 int lstatus = ncio_get(ncp->nciopoffsetextent,
4218  RGN_WRITE, &xp);
4219 if(lstatus != NC_NOERR)
4220 return lstatus;
4221
4222 lstatus = ncx_putn_uint_int(&xpnputvalue);
4223 if(lstatus != NC_NOERR && status == NC_NOERR)
4224 {
4225 /* not fatal to the loop */
4226 status = lstatus;
4227 }
4228
4229 (void) ncio_rel(ncp->nciopoffset,
4230  RGN_MODIFIED);
4231
4232 remaining -= extent;
4233 if(remaining == 0)
4234 break; /* normal loop exit */
4235 offset += extent;
4236 value += nput;
4237
4238 }
4239
4240 return status;
4241}
4242
4243static int
4244putNCvx_uint_float(NC3_INFOncp, const NC_var *varp,
4245  const size_t *start, size_t nelems, const float *value)
4246{
4247 off_t offset = NC_varoffset(ncpvarpstart);
4248 size_t remaining = varp->xsz * nelems;
4249 int status = NC_NOERR;
4250 void *xp;
4251
4252 if(nelems == 0)
4253 return NC_NOERR;
4254
4255 assert(value != NULL);
4256
4257 for(;;)
4258 {
4259 size_t extent = MIN(remainingncp->chunk);
4260 size_t nput = ncx_howmany(varp->typeextent);
4261
4262 int lstatus = ncio_get(ncp->nciopoffsetextent,
4263  RGN_WRITE, &xp);
4264 if(lstatus != NC_NOERR)
4265 return lstatus;
4266
4267 lstatus = ncx_putn_uint_float(&xpnputvalue);
4268 if(lstatus != NC_NOERR && status == NC_NOERR)
4269 {
4270 /* not fatal to the loop */
4271 status = lstatus;
4272 }
4273
4274 (void) ncio_rel(ncp->nciopoffset,
4275  RGN_MODIFIED);
4276
4277 remaining -= extent;
4278 if(remaining == 0)
4279 break; /* normal loop exit */
4280 offset += extent;
4281 value += nput;
4282
4283 }
4284
4285 return status;
4286}
4287
4288static int
4289putNCvx_uint_double(NC3_INFOncp, const NC_var *varp,
4290  const size_t *start, size_t nelems, const double *value)
4291{
4292 off_t offset = NC_varoffset(ncpvarpstart);
4293 size_t remaining = varp->xsz * nelems;
4294 int status = NC_NOERR;
4295 void *xp;
4296
4297 if(nelems == 0)
4298 return NC_NOERR;
4299
4300 assert(value != NULL);
4301
4302 for(;;)
4303 {
4304 size_t extent = MIN(remainingncp->chunk);
4305 size_t nput = ncx_howmany(varp->typeextent);
4306
4307 int lstatus = ncio_get(ncp->nciopoffsetextent,
4308  RGN_WRITE, &xp);
4309 if(lstatus != NC_NOERR)
4310 return lstatus;
4311
4312 lstatus = ncx_putn_uint_double(&xpnputvalue);
4313 if(lstatus != NC_NOERR && status == NC_NOERR)
4314 {
4315 /* not fatal to the loop */
4316 status = lstatus;
4317 }
4318
4319 (void) ncio_rel(ncp->nciopoffset,
4320  RGN_MODIFIED);
4321
4322 remaining -= extent;
4323 if(remaining == 0)
4324 break; /* normal loop exit */
4325 offset += extent;
4326 value += nput;
4327
4328 }
4329
4330 return status;
4331}
4332
4333static int
4334putNCvx_uint_longlong(NC3_INFOncp, const NC_var *varp,
4335  const size_t *start, size_t nelems, const longlong *value)
4336{
4337 off_t offset = NC_varoffset(ncpvarpstart);
4338 size_t remaining = varp->xsz * nelems;
4339 int status = NC_NOERR;
4340 void *xp;
4341
4342 if(nelems == 0)
4343 return NC_NOERR;
4344
4345 assert(value != NULL);
4346
4347 for(;;)
4348 {
4349 size_t extent = MIN(remainingncp->chunk);
4350 size_t nput = ncx_howmany(varp->typeextent);
4351
4352 int lstatus = ncio_get(ncp->nciopoffsetextent,
4353  RGN_WRITE, &xp);
4354 if(lstatus != NC_NOERR)
4355 return lstatus;
4356
4357 lstatus = ncx_putn_uint_longlong(&xpnputvalue);
4358 if(lstatus != NC_NOERR && status == NC_NOERR)
4359 {
4360 /* not fatal to the loop */
4361 status = lstatus;
4362 }
4363
4364 (void) ncio_rel(ncp->nciopoffset,
4365  RGN_MODIFIED);
4366
4367 remaining -= extent;
4368 if(remaining == 0)
4369 break; /* normal loop exit */
4370 offset += extent;
4371 value += nput;
4372
4373 }
4374
4375 return status;
4376}
4377
4378static int
4379putNCvx_uint_ushort(NC3_INFOncp, const NC_var *varp,
4380  const size_t *start, size_t nelems, const ushort *value)
4381{
4382 off_t offset = NC_varoffset(ncpvarpstart);
4383 size_t remaining = varp->xsz * nelems;
4384 int status = NC_NOERR;
4385 void *xp;
4386
4387 if(nelems == 0)
4388 return NC_NOERR;
4389
4390 assert(value != NULL);
4391
4392 for(;;)
4393 {
4394 size_t extent = MIN(remainingncp->chunk);
4395 size_t nput = ncx_howmany(varp->typeextent);
4396
4397 int lstatus = ncio_get(ncp->nciopoffsetextent,
4398  RGN_WRITE, &xp);
4399 if(lstatus != NC_NOERR)
4400 return lstatus;
4401
4402 lstatus = ncx_putn_uint_ushort(&xpnputvalue);
4403 if(lstatus != NC_NOERR && status == NC_NOERR)
4404 {
4405 /* not fatal to the loop */
4406 status = lstatus;
4407 }
4408
4409 (void) ncio_rel(ncp->nciopoffset,
4410  RGN_MODIFIED);
4411
4412 remaining -= extent;
4413 if(remaining == 0)
4414 break; /* normal loop exit */
4415 offset += extent;
4416 value += nput;
4417
4418 }
4419
4420 return status;
4421}
4422
4423static int
4424putNCvx_uint_uint(NC3_INFOncp, const NC_var *varp,
4425  const size_t *start, size_t nelems, const uint *value)
4426{
4427 off_t offset = NC_varoffset(ncpvarpstart);
4428 size_t remaining = varp->xsz * nelems;
4429 int status = NC_NOERR;
4430 void *xp;
4431
4432 if(nelems == 0)
4433 return NC_NOERR;
4434
4435 assert(value != NULL);
4436
4437 for(;;)
4438 {
4439 size_t extent = MIN(remainingncp->chunk);
4440 size_t nput = ncx_howmany(varp->typeextent);
4441
4442 int lstatus = ncio_get(ncp->nciopoffsetextent,
4443  RGN_WRITE, &xp);
4444 if(lstatus != NC_NOERR)
4445 return lstatus;
4446
4447 lstatus = ncx_putn_uint_uint(&xpnputvalue);
4448 if(lstatus != NC_NOERR && status == NC_NOERR)
4449 {
4450 /* not fatal to the loop */
4451 status = lstatus;
4452 }
4453
4454 (void) ncio_rel(ncp->nciopoffset,
4455  RGN_MODIFIED);
4456
4457 remaining -= extent;
4458 if(remaining == 0)
4459 break; /* normal loop exit */
4460 offset += extent;
4461 value += nput;
4462
4463 }
4464
4465 return status;
4466}
4467
4468static int
4469putNCvx_uint_ulonglong(NC3_INFOncp, const NC_var *varp,
4470  const size_t *start, size_t nelems, const ulonglong *value)
4471{
4472 off_t offset = NC_varoffset(ncpvarpstart);
4473 size_t remaining = varp->xsz * nelems;
4474 int status = NC_NOERR;
4475 void *xp;
4476
4477 if(nelems == 0)
4478 return NC_NOERR;
4479
4480 assert(value != NULL);
4481
4482 for(;;)
4483 {
4484 size_t extent = MIN(remainingncp->chunk);
4485 size_t nput = ncx_howmany(varp->typeextent);
4486
4487 int lstatus = ncio_get(ncp->nciopoffsetextent,
4488  RGN_WRITE, &xp);
4489 if(lstatus != NC_NOERR)
4490 return lstatus;
4491
4492 lstatus = ncx_putn_uint_ulonglong(&xpnputvalue);
4493 if(lstatus != NC_NOERR && status == NC_NOERR)
4494 {
4495 /* not fatal to the loop */
4496 status = lstatus;
4497 }
4498
4499 (void) ncio_rel(ncp->nciopoffset,
4500  RGN_MODIFIED);
4501
4502 remaining -= extent;
4503 if(remaining == 0)
4504 break; /* normal loop exit */
4505 offset += extent;
4506 value += nput;
4507
4508 }
4509
4510 return status;
4511}
4512
4513
4514static int
4515putNCvx_longlong_schar(NC3_INFOncp, const NC_var *varp,
4516  const size_t *start, size_t nelems, const schar *value)
4517{
4518 off_t offset = NC_varoffset(ncpvarpstart);
4519 size_t remaining = varp->xsz * nelems;
4520 int status = NC_NOERR;
4521 void *xp;
4522
4523 if(nelems == 0)
4524 return NC_NOERR;
4525
4526 assert(value != NULL);
4527
4528 for(;;)
4529 {
4530 size_t extent = MIN(remainingncp->chunk);
4531 size_t nput = ncx_howmany(varp->typeextent);
4532
4533 int lstatus = ncio_get(ncp->nciopoffsetextent,
4534  RGN_WRITE, &xp);
4535 if(lstatus != NC_NOERR)
4536 return lstatus;
4537
4538 lstatus = ncx_putn_longlong_schar(&xpnputvalue);
4539 if(lstatus != NC_NOERR && status == NC_NOERR)
4540 {
4541 /* not fatal to the loop */
4542 status = lstatus;
4543 }
4544
4545 (void) ncio_rel(ncp->nciopoffset,
4546  RGN_MODIFIED);
4547
4548 remaining -= extent;
4549 if(remaining == 0)
4550 break; /* normal loop exit */
4551 offset += extent;
4552 value += nput;
4553
4554 }
4555
4556 return status;
4557}
4558
4559static int
4560putNCvx_longlong_uchar(NC3_INFOncp, const NC_var *varp,
4561  const size_t *start, size_t nelems, const uchar *value)
4562{
4563 off_t offset = NC_varoffset(ncpvarpstart);
4564 size_t remaining = varp->xsz * nelems;
4565 int status = NC_NOERR;
4566 void *xp;
4567
4568 if(nelems == 0)
4569 return NC_NOERR;
4570
4571 assert(value != NULL);
4572
4573 for(;;)
4574 {
4575 size_t extent = MIN(remainingncp->chunk);
4576 size_t nput = ncx_howmany(varp->typeextent);
4577
4578 int lstatus = ncio_get(ncp->nciopoffsetextent,
4579  RGN_WRITE, &xp);
4580 if(lstatus != NC_NOERR)
4581 return lstatus;
4582
4583 lstatus = ncx_putn_longlong_uchar(&xpnputvalue);
4584 if(lstatus != NC_NOERR && status == NC_NOERR)
4585 {
4586 /* not fatal to the loop */
4587 status = lstatus;
4588 }
4589
4590 (void) ncio_rel(ncp->nciopoffset,
4591  RGN_MODIFIED);
4592
4593 remaining -= extent;
4594 if(remaining == 0)
4595 break; /* normal loop exit */
4596 offset += extent;
4597 value += nput;
4598
4599 }
4600
4601 return status;
4602}
4603
4604static int
4605putNCvx_longlong_short(NC3_INFOncp, const NC_var *varp,
4606  const size_t *start, size_t nelems, const short *value)
4607{
4608 off_t offset = NC_varoffset(ncpvarpstart);
4609 size_t remaining = varp->xsz * nelems;
4610 int status = NC_NOERR;
4611 void *xp;
4612
4613 if(nelems == 0)
4614 return NC_NOERR;
4615
4616 assert(value != NULL);
4617
4618 for(;;)
4619 {
4620 size_t extent = MIN(remainingncp->chunk);
4621 size_t nput = ncx_howmany(varp->typeextent);
4622
4623 int lstatus = ncio_get(ncp->nciopoffsetextent,
4624  RGN_WRITE, &xp);
4625 if(lstatus != NC_NOERR)
4626 return lstatus;
4627
4628 lstatus = ncx_putn_longlong_short(&xpnputvalue);
4629 if(lstatus != NC_NOERR && status == NC_NOERR)
4630 {
4631 /* not fatal to the loop */
4632 status = lstatus;
4633 }
4634
4635 (void) ncio_rel(ncp->nciopoffset,
4636  RGN_MODIFIED);
4637
4638 remaining -= extent;
4639 if(remaining == 0)
4640 break; /* normal loop exit */
4641 offset += extent;
4642 value += nput;
4643
4644 }
4645
4646 return status;
4647}
4648
4649static int
4650putNCvx_longlong_int(NC3_INFOncp, const NC_var *varp,
4651  const size_t *start, size_t nelems, const int *value)
4652{
4653 off_t offset = NC_varoffset(ncpvarpstart);
4654 size_t remaining = varp->xsz * nelems;
4655 int status = NC_NOERR;
4656 void *xp;
4657
4658 if(nelems == 0)
4659 return NC_NOERR;
4660
4661 assert(value != NULL);
4662
4663 for(;;)
4664 {
4665 size_t extent = MIN(remainingncp->chunk);
4666 size_t nput = ncx_howmany(varp->typeextent);
4667
4668 int lstatus = ncio_get(ncp->nciopoffsetextent,
4669  RGN_WRITE, &xp);
4670 if(lstatus != NC_NOERR)
4671 return lstatus;
4672
4673 lstatus = ncx_putn_longlong_int(&xpnputvalue);
4674 if(lstatus != NC_NOERR && status == NC_NOERR)
4675 {
4676 /* not fatal to the loop */
4677 status = lstatus;
4678 }
4679
4680 (void) ncio_rel(ncp->nciopoffset,
4681  RGN_MODIFIED);
4682
4683 remaining -= extent;
4684 if(remaining == 0)
4685 break; /* normal loop exit */
4686 offset += extent;
4687 value += nput;
4688
4689 }
4690
4691 return status;
4692}
4693
4694static int
4695putNCvx_longlong_float(NC3_INFOncp, const NC_var *varp,
4696  const size_t *start, size_t nelems, const float *value)
4697{
4698 off_t offset = NC_varoffset(ncpvarpstart);
4699 size_t remaining = varp->xsz * nelems;
4700 int status = NC_NOERR;
4701 void *xp;
4702
4703 if(nelems == 0)
4704 return NC_NOERR;
4705
4706 assert(value != NULL);
4707
4708 for(;;)
4709 {
4710 size_t extent = MIN(remainingncp->chunk);
4711 size_t nput = ncx_howmany(varp->typeextent);
4712
4713 int lstatus = ncio_get(ncp->nciopoffsetextent,
4714  RGN_WRITE, &xp);
4715 if(lstatus != NC_NOERR)
4716 return lstatus;
4717
4718 lstatus = ncx_putn_longlong_float(&xpnputvalue);
4719 if(lstatus != NC_NOERR && status == NC_NOERR)
4720 {
4721 /* not fatal to the loop */
4722 status = lstatus;
4723 }
4724
4725 (void) ncio_rel(ncp->nciopoffset,
4726  RGN_MODIFIED);
4727
4728 remaining -= extent;
4729 if(remaining == 0)
4730 break; /* normal loop exit */
4731 offset += extent;
4732 value += nput;
4733
4734 }
4735
4736 return status;
4737}
4738
4739static int
4740putNCvx_longlong_double(NC3_INFOncp, const NC_var *varp,
4741  const size_t *start, size_t nelems, const double *value)
4742{
4743 off_t offset = NC_varoffset(ncpvarpstart);
4744 size_t remaining = varp->xsz * nelems;
4745 int status = NC_NOERR;
4746 void *xp;
4747
4748 if(nelems == 0)
4749 return NC_NOERR;
4750
4751 assert(value != NULL);
4752
4753 for(;;)
4754 {
4755 size_t extent = MIN(remainingncp->chunk);
4756 size_t nput = ncx_howmany(varp->typeextent);
4757
4758 int lstatus = ncio_get(ncp->nciopoffsetextent,
4759  RGN_WRITE, &xp);
4760 if(lstatus != NC_NOERR)
4761 return lstatus;
4762
4763 lstatus = ncx_putn_longlong_double(&xpnputvalue);
4764 if(lstatus != NC_NOERR && status == NC_NOERR)
4765 {
4766 /* not fatal to the loop */
4767 status = lstatus;
4768 }
4769
4770 (void) ncio_rel(ncp->nciopoffset,
4771  RGN_MODIFIED);
4772
4773 remaining -= extent;
4774 if(remaining == 0)
4775 break; /* normal loop exit */
4776 offset += extent;
4777 value += nput;
4778
4779 }
4780
4781 return status;
4782}
4783
4784static int
4785putNCvx_longlong_longlong(NC3_INFOncp, const NC_var *varp,
4786  const size_t *start, size_t nelems, const longlong *value)
4787{
4788 off_t offset = NC_varoffset(ncpvarpstart);
4789 size_t remaining = varp->xsz * nelems;
4790 int status = NC_NOERR;
4791 void *xp;
4792
4793 if(nelems == 0)
4794 return NC_NOERR;
4795
4796 assert(value != NULL);
4797
4798 for(;;)
4799 {
4800 size_t extent = MIN(remainingncp->chunk);
4801 size_t nput = ncx_howmany(varp->typeextent);
4802
4803 int lstatus = ncio_get(ncp->nciopoffsetextent,
4804  RGN_WRITE, &xp);
4805 if(lstatus != NC_NOERR)
4806 return lstatus;
4807
4808 lstatus = ncx_putn_longlong_longlong(&xpnputvalue);
4809 if(lstatus != NC_NOERR && status == NC_NOERR)
4810 {
4811 /* not fatal to the loop */
4812 status = lstatus;
4813 }
4814
4815 (void) ncio_rel(ncp->nciopoffset,
4816  RGN_MODIFIED);
4817
4818 remaining -= extent;
4819 if(remaining == 0)
4820 break; /* normal loop exit */
4821 offset += extent;
4822 value += nput;
4823
4824 }
4825
4826 return status;
4827}
4828
4829static int
4830putNCvx_longlong_ushort(NC3_INFOncp, const NC_var *varp,
4831  const size_t *start, size_t nelems, const ushort *value)
4832{
4833 off_t offset = NC_varoffset(ncpvarpstart);
4834 size_t remaining = varp->xsz * nelems;
4835 int status = NC_NOERR;
4836 void *xp;
4837
4838 if(nelems == 0)
4839 return NC_NOERR;
4840
4841 assert(value != NULL);
4842
4843 for(;;)
4844 {
4845 size_t extent = MIN(remainingncp->chunk);
4846 size_t nput = ncx_howmany(varp->typeextent);
4847
4848 int lstatus = ncio_get(ncp->nciopoffsetextent,
4849  RGN_WRITE, &xp);
4850 if(lstatus != NC_NOERR)
4851 return lstatus;
4852
4853 lstatus = ncx_putn_longlong_ushort(&xpnputvalue);
4854 if(lstatus != NC_NOERR && status == NC_NOERR)
4855 {
4856 /* not fatal to the loop */
4857 status = lstatus;
4858 }
4859
4860 (void) ncio_rel(ncp->nciopoffset,
4861  RGN_MODIFIED);
4862
4863 remaining -= extent;
4864 if(remaining == 0)
4865 break; /* normal loop exit */
4866 offset += extent;
4867 value += nput;
4868
4869 }
4870
4871 return status;
4872}
4873
4874static int
4875putNCvx_longlong_uint(NC3_INFOncp, const NC_var *varp,
4876  const size_t *start, size_t nelems, const uint *value)
4877{
4878 off_t offset = NC_varoffset(ncpvarpstart);
4879 size_t remaining = varp->xsz * nelems;
4880 int status = NC_NOERR;
4881 void *xp;
4882
4883 if(nelems == 0)
4884 return NC_NOERR;
4885
4886 assert(value != NULL);
4887
4888 for(;;)
4889 {
4890 size_t extent = MIN(remainingncp->chunk);
4891 size_t nput = ncx_howmany(varp->typeextent);
4892
4893 int lstatus = ncio_get(ncp->nciopoffsetextent,
4894  RGN_WRITE, &xp);
4895 if(lstatus != NC_NOERR)
4896 return lstatus;
4897
4898 lstatus = ncx_putn_longlong_uint(&xpnputvalue);
4899 if(lstatus != NC_NOERR && status == NC_NOERR)
4900 {
4901 /* not fatal to the loop */
4902 status = lstatus;
4903 }
4904
4905 (void) ncio_rel(ncp->nciopoffset,
4906  RGN_MODIFIED);
4907
4908 remaining -= extent;
4909 if(remaining == 0)
4910 break; /* normal loop exit */
4911 offset += extent;
4912 value += nput;
4913
4914 }
4915
4916 return status;
4917}
4918
4919static int
4920putNCvx_longlong_ulonglong(NC3_INFOncp, const NC_var *varp,
4921  const size_t *start, size_t nelems, const ulonglong *value)
4922{
4923 off_t offset = NC_varoffset(ncpvarpstart);
4924 size_t remaining = varp->xsz * nelems;
4925 int status = NC_NOERR;
4926 void *xp;
4927
4928 if(nelems == 0)
4929 return NC_NOERR;
4930
4931 assert(value != NULL);
4932
4933 for(;;)
4934 {
4935 size_t extent = MIN(remainingncp->chunk);
4936 size_t nput = ncx_howmany(varp->typeextent);
4937
4938 int lstatus = ncio_get(ncp->nciopoffsetextent,
4939  RGN_WRITE, &xp);
4940 if(lstatus != NC_NOERR)
4941 return lstatus;
4942
4943 lstatus = ncx_putn_longlong_ulonglong(&xpnputvalue);
4944 if(lstatus != NC_NOERR && status == NC_NOERR)
4945 {
4946 /* not fatal to the loop */
4947 status = lstatus;
4948 }
4949
4950 (void) ncio_rel(ncp->nciopoffset,
4951  RGN_MODIFIED);
4952
4953 remaining -= extent;
4954 if(remaining == 0)
4955 break; /* normal loop exit */
4956 offset += extent;
4957 value += nput;
4958
4959 }
4960
4961 return status;
4962}
4963
4964
4965static int
4966putNCvx_ulonglong_schar(NC3_INFOncp, const NC_var *varp,
4967  const size_t *start, size_t nelems, const schar *value)
4968{
4969 off_t offset = NC_varoffset(ncpvarpstart);
4970 size_t remaining = varp->xsz * nelems;
4971 int status = NC_NOERR;
4972 void *xp;
4973
4974 if(nelems == 0)
4975 return NC_NOERR;
4976
4977 assert(value != NULL);
4978
4979 for(;;)
4980 {
4981 size_t extent = MIN(remainingncp->chunk);
4982 size_t nput = ncx_howmany(varp->typeextent);
4983
4984 int lstatus = ncio_get(ncp->nciopoffsetextent,
4985  RGN_WRITE, &xp);
4986 if(lstatus != NC_NOERR)
4987 return lstatus;
4988
4989 lstatus = ncx_putn_ulonglong_schar(&xpnputvalue);
4990 if(lstatus != NC_NOERR && status == NC_NOERR)
4991 {
4992 /* not fatal to the loop */
4993 status = lstatus;
4994 }
4995
4996 (void) ncio_rel(ncp->nciopoffset,
4997  RGN_MODIFIED);
4998
4999 remaining -= extent;
5000 if(remaining == 0)
5001 break; /* normal loop exit */
5002 offset += extent;
5003 value += nput;
5004
5005 }
5006
5007 return status;
5008}
5009
5010static int
5011putNCvx_ulonglong_uchar(NC3_INFOncp, const NC_var *varp,
5012  const size_t *start, size_t nelems, const uchar *value)
5013{
5014 off_t offset = NC_varoffset(ncpvarpstart);
5015 size_t remaining = varp->xsz * nelems;
5016 int status = NC_NOERR;
5017 void *xp;
5018
5019 if(nelems == 0)
5020 return NC_NOERR;
5021
5022 assert(value != NULL);
5023
5024 for(;;)
5025 {
5026 size_t extent = MIN(remainingncp->chunk);
5027 size_t nput = ncx_howmany(varp->typeextent);
5028
5029 int lstatus = ncio_get(ncp->nciopoffsetextent,
5030  RGN_WRITE, &xp);
5031 if(lstatus != NC_NOERR)
5032 return lstatus;
5033
5034 lstatus = ncx_putn_ulonglong_uchar(&xpnputvalue);
5035 if(lstatus != NC_NOERR && status == NC_NOERR)
5036 {
5037 /* not fatal to the loop */
5038 status = lstatus;
5039 }
5040
5041 (void) ncio_rel(ncp->nciopoffset,
5042  RGN_MODIFIED);
5043
5044 remaining -= extent;
5045 if(remaining == 0)
5046 break; /* normal loop exit */
5047 offset += extent;
5048 value += nput;
5049
5050 }
5051
5052 return status;
5053}
5054
5055static int
5056putNCvx_ulonglong_short(NC3_INFOncp, const NC_var *varp,
5057  const size_t *start, size_t nelems, const short *value)
5058{
5059 off_t offset = NC_varoffset(ncpvarpstart);
5060 size_t remaining = varp->xsz * nelems;
5061 int status = NC_NOERR;
5062 void *xp;
5063
5064 if(nelems == 0)
5065 return NC_NOERR;
5066
5067 assert(value != NULL);
5068
5069 for(;;)
5070 {
5071 size_t extent = MIN(remainingncp->chunk);
5072 size_t nput = ncx_howmany(varp->typeextent);
5073
5074 int lstatus = ncio_get(ncp->nciopoffsetextent,
5075  RGN_WRITE, &xp);
5076 if(lstatus != NC_NOERR)
5077 return lstatus;
5078
5079 lstatus = ncx_putn_ulonglong_short(&xpnputvalue);
5080 if(lstatus != NC_NOERR && status == NC_NOERR)
5081 {
5082 /* not fatal to the loop */
5083 status = lstatus;
5084 }
5085
5086 (void) ncio_rel(ncp->nciopoffset,
5087  RGN_MODIFIED);
5088
5089 remaining -= extent;
5090 if(remaining == 0)
5091 break; /* normal loop exit */
5092 offset += extent;
5093 value += nput;
5094
5095 }
5096
5097 return status;
5098}
5099
5100static int
5101putNCvx_ulonglong_int(NC3_INFOncp, const NC_var *varp,
5102  const size_t *start, size_t nelems, const int *value)
5103{
5104 off_t offset = NC_varoffset(ncpvarpstart);
5105 size_t remaining = varp->xsz * nelems;
5106 int status = NC_NOERR;
5107 void *xp;
5108
5109 if(nelems == 0)
5110 return NC_NOERR;
5111
5112 assert(value != NULL);
5113
5114 for(;;)
5115 {
5116 size_t extent = MIN(remainingncp->chunk);
5117 size_t nput = ncx_howmany(varp->typeextent);
5118
5119 int lstatus = ncio_get(ncp->nciopoffsetextent,
5120  RGN_WRITE, &xp);
5121 if(lstatus != NC_NOERR)
5122 return lstatus;
5123
5124 lstatus = ncx_putn_ulonglong_int(&xpnputvalue);
5125 if(lstatus != NC_NOERR && status == NC_NOERR)
5126 {
5127 /* not fatal to the loop */
5128 status = lstatus;
5129 }
5130
5131 (void) ncio_rel(ncp->nciopoffset,
5132  RGN_MODIFIED);
5133
5134 remaining -= extent;
5135 if(remaining == 0)
5136 break; /* normal loop exit */
5137 offset += extent;
5138 value += nput;
5139
5140 }
5141
5142 return status;
5143}
5144
5145static int
5146putNCvx_ulonglong_float(NC3_INFOncp, const NC_var *varp,
5147  const size_t *start, size_t nelems, const float *value)
5148{
5149 off_t offset = NC_varoffset(ncpvarpstart);
5150 size_t remaining = varp->xsz * nelems;
5151 int status = NC_NOERR;
5152 void *xp;
5153
5154 if(nelems == 0)
5155 return NC_NOERR;
5156
5157 assert(value != NULL);
5158
5159 for(;;)
5160 {
5161 size_t extent = MIN(remainingncp->chunk);
5162 size_t nput = ncx_howmany(varp->typeextent);
5163
5164 int lstatus = ncio_get(ncp->nciopoffsetextent,
5165  RGN_WRITE, &xp);
5166 if(lstatus != NC_NOERR)
5167 return lstatus;
5168
5169 lstatus = ncx_putn_ulonglong_float(&xpnputvalue);
5170 if(lstatus != NC_NOERR && status == NC_NOERR)
5171 {
5172 /* not fatal to the loop */
5173 status = lstatus;
5174 }
5175
5176 (void) ncio_rel(ncp->nciopoffset,
5177  RGN_MODIFIED);
5178
5179 remaining -= extent;
5180 if(remaining == 0)
5181 break; /* normal loop exit */
5182 offset += extent;
5183 value += nput;
5184
5185 }
5186
5187 return status;
5188}
5189
5190static int
5191putNCvx_ulonglong_double(NC3_INFOncp, const NC_var *varp,
5192  const size_t *start, size_t nelems, const double *value)
5193{
5194 off_t offset = NC_varoffset(ncpvarpstart);
5195 size_t remaining = varp->xsz * nelems;
5196 int status = NC_NOERR;
5197 void *xp;
5198
5199 if(nelems == 0)
5200 return NC_NOERR;
5201
5202 assert(value != NULL);
5203
5204 for(;;)
5205 {
5206 size_t extent = MIN(remainingncp->chunk);
5207 size_t nput = ncx_howmany(varp->typeextent);
5208
5209 int lstatus = ncio_get(ncp->nciopoffsetextent,
5210  RGN_WRITE, &xp);
5211 if(lstatus != NC_NOERR)
5212 return lstatus;
5213
5214 lstatus = ncx_putn_ulonglong_double(&xpnputvalue);
5215 if(lstatus != NC_NOERR && status == NC_NOERR)
5216 {
5217 /* not fatal to the loop */
5218 status = lstatus;
5219 }
5220
5221 (void) ncio_rel(ncp->nciopoffset,
5222  RGN_MODIFIED);
5223
5224 remaining -= extent;
5225 if(remaining == 0)
5226 break; /* normal loop exit */
5227 offset += extent;
5228 value += nput;
5229
5230 }
5231
5232 return status;
5233}
5234
5235static int
5236putNCvx_ulonglong_longlong(NC3_INFOncp, const NC_var *varp,
5237  const size_t *start, size_t nelems, const longlong *value)
5238{
5239 off_t offset = NC_varoffset(ncpvarpstart);
5240 size_t remaining = varp->xsz * nelems;
5241 int status = NC_NOERR;
5242 void *xp;
5243
5244 if(nelems == 0)
5245 return NC_NOERR;
5246
5247 assert(value != NULL);
5248
5249 for(;;)
5250 {
5251 size_t extent = MIN(remainingncp->chunk);
5252 size_t nput = ncx_howmany(varp->typeextent);
5253
5254 int lstatus = ncio_get(ncp->nciopoffsetextent,
5255  RGN_WRITE, &xp);
5256 if(lstatus != NC_NOERR)
5257 return lstatus;
5258
5259 lstatus = ncx_putn_ulonglong_longlong(&xpnputvalue);
5260 if(lstatus != NC_NOERR && status == NC_NOERR)
5261 {
5262 /* not fatal to the loop */
5263 status = lstatus;
5264 }
5265
5266 (void) ncio_rel(ncp->nciopoffset,
5267  RGN_MODIFIED);
5268
5269 remaining -= extent;
5270 if(remaining == 0)
5271 break; /* normal loop exit */
5272 offset += extent;
5273 value += nput;
5274
5275 }
5276
5277 return status;
5278}
5279
5280static int
5281putNCvx_ulonglong_ushort(NC3_INFOncp, const NC_var *varp,
5282  const size_t *start, size_t nelems, const ushort *value)
5283{
5284 off_t offset = NC_varoffset(ncpvarpstart);
5285 size_t remaining = varp->xsz * nelems;
5286 int status = NC_NOERR;
5287 void *xp;
5288
5289 if(nelems == 0)
5290 return NC_NOERR;
5291
5292 assert(value != NULL);
5293
5294 for(;;)
5295 {
5296 size_t extent = MIN(remainingncp->chunk);
5297 size_t nput = ncx_howmany(varp->typeextent);
5298
5299 int lstatus = ncio_get(ncp->nciopoffsetextent,
5300  RGN_WRITE, &xp);
5301 if(lstatus != NC_NOERR)
5302 return lstatus;
5303
5304 lstatus = ncx_putn_ulonglong_ushort(&xpnputvalue);
5305 if(lstatus != NC_NOERR && status == NC_NOERR)
5306 {
5307 /* not fatal to the loop */
5308 status = lstatus;
5309 }
5310
5311 (void) ncio_rel(ncp->nciopoffset,
5312  RGN_MODIFIED);
5313
5314 remaining -= extent;
5315 if(remaining == 0)
5316 break; /* normal loop exit */
5317 offset += extent;
5318 value += nput;
5319
5320 }
5321
5322 return status;
5323}
5324
5325static int
5326putNCvx_ulonglong_uint(NC3_INFOncp, const NC_var *varp,
5327  const size_t *start, size_t nelems, const uint *value)
5328{
5329 off_t offset = NC_varoffset(ncpvarpstart);
5330 size_t remaining = varp->xsz * nelems;
5331 int status = NC_NOERR;
5332 void *xp;
5333
5334 if(nelems == 0)
5335 return NC_NOERR;
5336
5337 assert(value != NULL);
5338
5339 for(;;)
5340 {
5341 size_t extent = MIN(remainingncp->chunk);
5342 size_t nput = ncx_howmany(varp->typeextent);
5343
5344 int lstatus = ncio_get(ncp->nciopoffsetextent,
5345  RGN_WRITE, &xp);
5346 if(lstatus != NC_NOERR)
5347 return lstatus;
5348
5349 lstatus = ncx_putn_ulonglong_uint(&xpnputvalue);
5350 if(lstatus != NC_NOERR && status == NC_NOERR)
5351 {
5352 /* not fatal to the loop */
5353 status = lstatus;
5354 }
5355
5356 (void) ncio_rel(ncp->nciopoffset,
5357  RGN_MODIFIED);
5358
5359 remaining -= extent;
5360 if(remaining == 0)
5361 break; /* normal loop exit */
5362 offset += extent;
5363 value += nput;
5364
5365 }
5366
5367 return status;
5368}
5369
5370static int
5371putNCvx_ulonglong_ulonglong(NC3_INFOncp, const NC_var *varp,
5372  const size_t *start, size_t nelems, const ulonglong *value)
5373{
5374 off_t offset = NC_varoffset(ncpvarpstart);
5375 size_t remaining = varp->xsz * nelems;
5376 int status = NC_NOERR;
5377 void *xp;
5378
5379 if(nelems == 0)
5380 return NC_NOERR;
5381
5382 assert(value != NULL);
5383
5384 for(;;)
5385 {
5386 size_t extent = MIN(remainingncp->chunk);
5387 size_t nput = ncx_howmany(varp->typeextent);
5388
5389 int lstatus = ncio_get(ncp->nciopoffsetextent,
5390  RGN_WRITE, &xp);
5391 if(lstatus != NC_NOERR)
5392 return lstatus;
5393
5394 lstatus = ncx_putn_ulonglong_ulonglong(&xpnputvalue);
5395 if(lstatus != NC_NOERR && status == NC_NOERR)
5396 {
5397 /* not fatal to the loop */
5398 status = lstatus;
5399 }
5400
5401 (void) ncio_rel(ncp->nciopoffset,
5402  RGN_MODIFIED);
5403
5404 remaining -= extent;
5405 if(remaining == 0)
5406 break; /* normal loop exit */
5407 offset += extent;
5408 value += nput;
5409
5410 }
5411
5412 return status;
5413}
5414
5415
5416
5417static int
5418getNCvx_char_char(const NC3_INFOncp, const NC_var *varp,
5419  const size_t *start, size_t nelems, char *value)
5420{
5421 off_t offset = NC_varoffset(ncpvarpstart);
5422 size_t remaining = varp->xsz * nelems;
5423 int status = NC_NOERR;
5424 const void *xp;
5425
5426 if(nelems == 0)
5427 return NC_NOERR;
5428
5429 assert(value != NULL);
5430
5431 for(;;)
5432 {
5433 size_t extent = MIN(remainingncp->chunk);
5434 size_t nget = ncx_howmany(varp->typeextent);
5435
5436 int lstatus = ncio_get(ncp->nciopoffsetextent,
5437  0, (void **)&xp); /* cast away const */
5438 if(lstatus != NC_NOERR)
5439 return lstatus;
5440
5441 lstatus = ncx_getn_char_char(&xpngetvalue);
5442 if(lstatus != NC_NOERR && status == NC_NOERR)
5443 status = lstatus;
5444
5445 (void) ncio_rel(ncp->nciopoffset, 0);
5446
5447 remaining -= extent;
5448 if(remaining == 0)
5449 break; /* normal loop exit */
5450 offset += extent;
5451 value += nget;
5452 }
5453
5454 return status;
5455}
5456
5457
5458static int
5459getNCvx_schar_schar(const NC3_INFOncp, const NC_var *varp,
5460  const size_t *start, size_t nelemsschar *value)
5461{
5462 off_t offset = NC_varoffset(ncpvarpstart);
5463 size_t remaining = varp->xsz * nelems;
5464 int status = NC_NOERR;
5465 const void *xp;
5466
5467 if(nelems == 0)
5468 return NC_NOERR;
5469
5470 assert(value != NULL);
5471
5472 for(;;)
5473 {
5474 size_t extent = MIN(remainingncp->chunk);
5475 size_t nget = ncx_howmany(varp->typeextent);
5476
5477 int lstatus = ncio_get(ncp->nciopoffsetextent,
5478  0, (void **)&xp); /* cast away const */
5479 if(lstatus != NC_NOERR)
5480 return lstatus;
5481
5482 lstatus = ncx_getn_schar_schar(&xpngetvalue);
5483 if(lstatus != NC_NOERR && status == NC_NOERR)
5484 status = lstatus;
5485
5486 (void) ncio_rel(ncp->nciopoffset, 0);
5487
5488 remaining -= extent;
5489 if(remaining == 0)
5490 break; /* normal loop exit */
5491 offset += extent;
5492 value += nget;
5493 }
5494
5495 return status;
5496}
5497
5498static int
5499getNCvx_schar_short(const NC3_INFOncp, const NC_var *varp,
5500  const size_t *start, size_t nelems, short *value)
5501{
5502 off_t offset = NC_varoffset(ncpvarpstart);
5503 size_t remaining = varp->xsz * nelems;
5504 int status = NC_NOERR;
5505 const void *xp;
5506
5507 if(nelems == 0)
5508 return NC_NOERR;
5509
5510 assert(value != NULL);
5511
5512 for(;;)
5513 {
5514 size_t extent = MIN(remainingncp->chunk);
5515 size_t nget = ncx_howmany(varp->typeextent);
5516
5517 int lstatus = ncio_get(ncp->nciopoffsetextent,
5518  0, (void **)&xp); /* cast away const */
5519 if(lstatus != NC_NOERR)
5520 return lstatus;
5521
5522 lstatus = ncx_getn_schar_short(&xpngetvalue);
5523 if(lstatus != NC_NOERR && status == NC_NOERR)
5524 status = lstatus;
5525
5526 (void) ncio_rel(ncp->nciopoffset, 0);
5527
5528 remaining -= extent;
5529 if(remaining == 0)
5530 break; /* normal loop exit */
5531 offset += extent;
5532 value += nget;
5533 }
5534
5535 return status;
5536}
5537
5538static int
5539getNCvx_schar_int(const NC3_INFOncp, const NC_var *varp,
5540  const size_t *start, size_t nelems, int *value)
5541{
5542 off_t offset = NC_varoffset(ncpvarpstart);
5543 size_t remaining = varp->xsz * nelems;
5544 int status = NC_NOERR;
5545 const void *xp;
5546
5547 if(nelems == 0)
5548 return NC_NOERR;
5549
5550 assert(value != NULL);
5551
5552 for(;;)
5553 {
5554 size_t extent = MIN(remainingncp->chunk);
5555 size_t nget = ncx_howmany(varp->typeextent);
5556
5557 int lstatus = ncio_get(ncp->nciopoffsetextent,
5558  0, (void **)&xp); /* cast away const */
5559 if(lstatus != NC_NOERR)
5560 return lstatus;
5561
5562 lstatus = ncx_getn_schar_int(&xpngetvalue);
5563 if(lstatus != NC_NOERR && status == NC_NOERR)
5564 status = lstatus;
5565
5566 (void) ncio_rel(ncp->nciopoffset, 0);
5567
5568 remaining -= extent;
5569 if(remaining == 0)
5570 break; /* normal loop exit */
5571 offset += extent;
5572 value += nget;
5573 }
5574
5575 return status;
5576}
5577
5578static int
5579getNCvx_schar_float(const NC3_INFOncp, const NC_var *varp,
5580  const size_t *start, size_t nelems, float *value)
5581{
5582 off_t offset = NC_varoffset(ncpvarpstart);
5583 size_t remaining = varp->xsz * nelems;
5584 int status = NC_NOERR;
5585 const void *xp;
5586
5587 if(nelems == 0)
5588 return NC_NOERR;
5589
5590 assert(value != NULL);
5591
5592 for(;;)
5593 {
5594 size_t extent = MIN(remainingncp->chunk);
5595 size_t nget = ncx_howmany(varp->typeextent);
5596
5597 int lstatus = ncio_get(ncp->nciopoffsetextent,
5598  0, (void **)&xp); /* cast away const */
5599 if(lstatus != NC_NOERR)
5600 return lstatus;
5601
5602 lstatus = ncx_getn_schar_float(&xpngetvalue);
5603 if(lstatus != NC_NOERR && status == NC_NOERR)
5604 status = lstatus;
5605
5606 (void) ncio_rel(ncp->nciopoffset, 0);
5607
5608 remaining -= extent;
5609 if(remaining == 0)
5610 break; /* normal loop exit */
5611 offset += extent;
5612 value += nget;
5613 }
5614
5615 return status;
5616}
5617
5618static int
5619getNCvx_schar_double(const NC3_INFOncp, const NC_var *varp,
5620  const size_t *start, size_t nelems, double *value)
5621{
5622 off_t offset = NC_varoffset(ncpvarpstart);
5623 size_t remaining = varp->xsz * nelems;
5624 int status = NC_NOERR;
5625 const void *xp;
5626
5627 if(nelems == 0)
5628 return NC_NOERR;
5629
5630 assert(value != NULL);
5631
5632 for(;;)
5633 {
5634 size_t extent = MIN(remainingncp->chunk);
5635 size_t nget = ncx_howmany(varp->typeextent);
5636
5637 int lstatus = ncio_get(ncp->nciopoffsetextent,
5638  0, (void **)&xp); /* cast away const */
5639 if(lstatus != NC_NOERR)
5640 return lstatus;
5641
5642 lstatus = ncx_getn_schar_double(&xpngetvalue);
5643 if(lstatus != NC_NOERR && status == NC_NOERR)
5644 status = lstatus;
5645
5646 (void) ncio_rel(ncp->nciopoffset, 0);
5647
5648 remaining -= extent;
5649 if(remaining == 0)
5650 break; /* normal loop exit */
5651 offset += extent;
5652 value += nget;
5653 }
5654
5655 return status;
5656}
5657
5658static int
5659getNCvx_schar_longlong(const NC3_INFOncp, const NC_var *varp,
5660  const size_t *start, size_t nelemslonglong *value)
5661{
5662 off_t offset = NC_varoffset(ncpvarpstart);
5663 size_t remaining = varp->xsz * nelems;
5664 int status = NC_NOERR;
5665 const void *xp;
5666
5667 if(nelems == 0)
5668 return NC_NOERR;
5669
5670 assert(value != NULL);
5671
5672 for(;;)
5673 {
5674 size_t extent = MIN(remainingncp->chunk);
5675 size_t nget = ncx_howmany(varp->typeextent);
5676
5677 int lstatus = ncio_get(ncp->nciopoffsetextent,
5678  0, (void **)&xp); /* cast away const */
5679 if(lstatus != NC_NOERR)
5680 return lstatus;
5681
5682 lstatus = ncx_getn_schar_longlong(&xpngetvalue);
5683 if(lstatus != NC_NOERR && status == NC_NOERR)
5684 status = lstatus;
5685
5686 (void) ncio_rel(ncp->nciopoffset, 0);
5687