1/*********************************************************************
2 *   Copyright 1993, UCAR/Unidata
3 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
4 *********************************************************************/
5
6/* WARNING: Order of mpi.h, nc.h, and pnetcdf.h is important */
7#include "config.h"
8#include <stdlib.h>
9#include <mpi.h>
10#include "nc.h"
11#include "ncdispatch.h"
12/* Must follow netcdf.h */
13#include <pnetcdf.h>
14
15typedef struct NCP_INFO
16{
17   /* pnetcdf_file will be true if the file is created/opened with the
18    * parallel-netcdf library. pnetcdf_access_mode keeps track of
19    * whether independpent or collective mode is
20    * desired. pnetcdf_ndims keeps track of how many dims each var
21    * has, which I need to know to convert start, count, and stride
22    * arrays from size_t to MPI_Offset. (I can't use an inq function
23    * to find out the number of dims, because these are collective in
24    * pnetcdf.) */
25   int pnetcdf_access_mode;
26NCP_INFO;
27
28/* Define accessors for the dispatchdata */
29#define NCP_DATA(nc) ((NCP_INFO*)(nc)->dispatchdata)
30#define NCP_DATA_SET(nc,data) ((nc)->dispatchdata = (void*)(data))
31
32/* Cannot have NC_MPIPOSIX flag, ignore NC_MPIIO as PnetCDF use MPIIO */
33static const int LEGAL_CREATE_FLAGS = (NC_NOCLOBBER | NC_64BIT_OFFSET | NC_CLASSIC_MODEL | NC_SHARE | NC_LOCK | NC_64BIT_DATA | NC_MPIIO);
34
35static const int LEGAL_OPEN_FLAGS = (NC_WRITE | NC_NOCLOBBER | NC_SHARE | NC_LOCK | NC_CLASSIC_MODEL | NC_64BIT_OFFSET | NC_64BIT_DATA | NC_MPIIO);
36
37
38/**************************************************/
39
40static int
41NCP_create(const char *path, int cmode,
42   size_t initialsz, int basepe, size_t *chunksizehintp,
43   int use_parallel, void* mpidata,
44   struct NC_DispatchtableNCnc)
45{
46    int resdefault_format;
47    NCP_INFOnc5;
48    MPI_Comm comm = MPI_COMM_WORLD;
49    MPI_Info info = MPI_INFO_NULL;
50
51    /* Check the cmode for only valid flags*/
52    if(cmode & ~LEGAL_CREATE_FLAGS)
53 return NC_EINVAL;
54
55    /* Cannot have both MPIO flags */
56    if((cmode & (NC_MPIIO|NC_MPIPOSIX)) == (NC_MPIIO|NC_MPIPOSIX))
57 return NC_EINVAL;
58
59    /* Cannot have both NC_64BIT_OFFSET & NC_64BIT_DATA */
60    if((cmode & (NC_64BIT_OFFSET|NC_64BIT_DATA)) == (NC_64BIT_OFFSET|NC_64BIT_DATA))
61  return NC_EINVAL;
62
63    default_format = nc_get_default_format();
64    /* if (default_format == NC_FORMAT_CLASSIC) then we respect the format set in cmode */
65    if (default_format == NC_FORMAT_64BIT_OFFSET) {
66        if (! (cmode & NC_64BIT_OFFSET)) /* check if cmode has NC_64BIT_OFFSET already */
67            cmode |= NC_64BIT_OFFSET;
68    }
69    else if (default_format == NC_FORMAT_CDF5) {
70        if (! (cmode & NC_64BIT_DATA)) /* check if cmode has NC_64BIT_DATA already */
71            cmode |= NC_64BIT_DATA;
72    }
73
74    /* No MPI environment initialized */
75    if (mpidata == NULL) return NC_ENOPAR;
76
77    comm = ((NC_MPI_INFO *)mpidata)->comm;
78    info = ((NC_MPI_INFO *)mpidata)->info;
79
80    /* Create our specific NCP_INFO instance */
81    nc5 = (NCP_INFO*)calloc(1,sizeof(NCP_INFO));
82    if(nc5 == NULL) return NC_ENOMEM;
83
84    /* Link nc5 and nc */
85    NCP_DATA_SET(nc,nc5);
86
87    /* Fix up the cmode by keeping only essential flags;
88       these are the flags that are the same in netcf.h and pnetcdf.h
89    */
90    /* It turns out that pnetcdf.h defines a flag called
91       NC_64BIT_DATA (not to be confused with NC_64BIT_OFFSET).
92       This flag is essential to getting ncmpi_create to create
93       a proper pnetcdf format file.
94       We have set the value of NC_64BIT_DATA to be the same as in pnetcdf.h
95       (as of pnetcdf version 1.6.0) to avoid conflicts.
96       In any case, this flag must be set.
97    */
98    /* PnetCDF recognizes the flags below for create and ignores NC_LOCK and  NC_SHARE */
99    cmode &= (NC_WRITE | NC_NOCLOBBER | NC_SHARE | NC_64BIT_OFFSET | NC_64BIT_DATA);
100    res = ncmpi_create(commpathcmodeinfo, &(nc->int_ncid));
101
102    if(res && nc5 != NULL) free(nc5); /* reclaim allocated space */
103    return res;
104}
105
106static int
107NCP_open(const char *path, int cmode,
108     int basepe, size_t *chunksizehintp,
109     int use_parallel, void* mpidata,
110     struct NC_DispatchtableNCnc)
111{
112    int res;
113    NCP_INFOnc5;
114    MPI_Comm comm = MPI_COMM_WORLD;
115    MPI_Info info = MPI_INFO_NULL;
116
117    /* Check the cmode for only valid flags*/
118    if(cmode & ~LEGAL_OPEN_FLAGS)
119 return NC_EINVAL;
120
121    /* Cannot have both MPIO flags */
122    if((cmode & (NC_MPIIO|NC_MPIPOSIX)) == (NC_MPIIO|NC_MPIPOSIX))
123 return NC_EINVAL;
124
125    /* Appears that this comment is wrong; allow 64 bit offset*/
126    /* Cannot have 64 bit offset flag */
127    /* if(cmode & (NC_64BIT_OFFSET)) return NC_EINVAL; */
128
129    if(mpidata != NULL) {
130        comm = ((NC_MPI_INFO *)mpidata)->comm;
131        info = ((NC_MPI_INFO *)mpidata)->info;
132    } else {
133 comm = MPI_COMM_WORLD;
134 info = MPI_INFO_NULL;
135    }
136
137   /* PnetCDF recognizes the flags NC_WRITE and NC_NOCLOBBER for file open
138     * and ignores NC_LOCK, NC_SHARE, NC_64BIT_OFFSET, and NC_64BIT_DATA.
139     * Ignoring the NC_64BIT_OFFSET and NC_64BIT_DATA flags is because the
140     * file is already in one of the CDF-formats, and setting these 2 flags
141     * will not change the format of that file.
142     */
143
144    cmode &= (NC_WRITE | NC_NOCLOBBER);
145
146    /* Create our specific NCP_INFO instance */
147    nc5 = (NCP_INFO*)calloc(1,sizeof(NCP_INFO));
148    if(nc5 == NULL) return NC_ENOMEM;
149
150    /* Link nc5 and nc */
151    NCP_DATA_SET(nc,nc5);
152
153    res = ncmpi_open(commpathcmodeinfo, &(nc->int_ncid));
154
155    /* Default to independent access, like netCDF-4/HDF5 files. */
156    if(!res) {
157 res = ncmpi_begin_indep_data(nc->int_ncid);
158 nc5->pnetcdf_access_mode = NC_INDEPENDENT;
159    }
160
161    return res;
162}
163
164static int
165NCP_redef(int ncid)
166{
167    NCnc;
168    int status = NC_check_id(ncid, &nc);
169    if(status != NC_NOERR) return status;
170    return ncmpi_redef(nc->int_ncid);
171}
172
173static int
174NCP__enddef(int ncid, size_t h_minfree, size_t v_align, size_t v_minfree, size_t r_align)
175{
176    int status;
177    NCnc;
178    NCP_INFOnc5;
179    MPI_Offset mpi_h_minfree = h_minfree;
180    MPI_Offset mpi_v_align   = v_align;
181    MPI_Offset mpi_v_minfree = v_minfree;
182    MPI_Offset mpi_r_align   = r_align;
183
184    status = NC_check_id(ncid, &nc);
185    if(status != NC_NOERR)
186 return status;
187
188    nc5 = NCP_DATA(nc);
189    assert(nc5);
190
191    /* causes implicitly defined warning; may be because of old installed pnetcdf? */
192#if 0
193    /* In PnetCDF ncmpi__enddef() is only implemented in v1.5.0 and later */
194    status = ncmpi__enddef(nc->int_ncidmpi_h_minfreempi_v_align,
195                           mpi_v_minfreempi_r_align);
196#else
197    status = ncmpi_enddef(nc->int_ncid);
198#endif
199
200    if(!status) {
201 if (nc5->pnetcdf_access_mode == NC_INDEPENDENT)
202     status = ncmpi_begin_indep_data(nc->int_ncid);
203    }
204    return status;
205}
206
207static int
208NCP_sync(int ncid)
209{
210    NCnc;
211    int status = NC_check_id(ncid, &nc);
212    if(status != NC_NOERR) return status;
213    return ncmpi_sync(nc->int_ncid);
214}
215
216static int
217NCP_abort(int ncid)
218{
219    NCnc;
220    NCP_INFOnc5;
221    int status = NC_check_id(ncid, &nc);
222    if(status != NC_NOERR) goto done;
223
224    status = ncmpi_abort(nc->int_ncid);
225
226done:
227    nc5 = NCP_DATA(nc);
228    if(nc5 != NULL) free(nc5); /* reclaim allocated space */
229    return status;
230}
231
232
233static int
234NCP_close(int ncid)
235{
236    NCnc;
237    NCP_INFOnc5;
238    int status = NC_check_id(ncid, &nc);
239    if(status != NC_NOERR) goto done;
240
241    status = ncmpi_close(nc->int_ncid);
242
243done:
244    nc5 = NCP_DATA(nc);
245    if(nc5 != NULL) free(nc5); /* reclaim allocated space */
246    return status;
247}
248
249static int
250NCP_set_fill(int ncid, int fillmode, int *old_mode_ptr)
251{
252    NCnc;
253    int status = NC_check_id(ncid, &nc);
254    if(status != NC_NOERR) return status;
255    return ncmpi_set_fill(nc->int_ncid,fillmode,old_mode_ptr);
256}
257
258static int
259NCP_inq_base_pe(int ncid, int* pep)
260{
261    if(pep) *pep = 0;
262    return NC_NOERR;
263}
264
265static int
266NCP_set_base_pe(int ncid, int pe)
267{
268    return NC_NOERR;
269}
270
271static int
272NCP_inq_format(int ncid, int* formatp)
273{
274    NCnc;
275    int status = NC_check_id(ncid, &nc);
276    if(status != NC_NOERR) return status;
277    status = ncmpi_inq_format(nc->int_ncid,formatp);
278    return status;
279}
280
281static int
282NCP_inq_format_extended(int ncid, int* formatp, int *modep)
283{
284    NCnc;
285    int status = NC_check_id(ncid, &nc);
286    if(status != NC_NOERR) return status;
287    if(modep) *modep = nc->mode;
288    /* Note that we do not use NC_FORMAT_CDF5 because PNETCDF has a dispatch table */
289    if(formatp) *formatp = NC_FORMATX_PNETCDF;
290    return NC_NOERR;
291}
292
293static int
294NCP_inq(int ncid,
295 int *ndimsp,
296 int *nvarsp,
297 int *nattsp,
298 int *unlimp)
299{
300    NCnc;
301    int status = NC_check_id(ncid, &nc);
302    if(status != NC_NOERR) return status;
303    return ncmpi_inq(nc->int_ncid,ndimsp,nvarsp,nattsp,unlimp);
304}
305
306
307static int
308NCP_inq_type(int ncidnc_type typeid, char* name, size_t* size)
309{
310    /* Assert mode & NC_FORMAT_CDF5 */
311    if (typeid < NC_BYTE || typeid >= NC_STRING)
312           return NC_EBADTYPE;
313    if(name)
314 strcpy(nameNC_atomictypename(typeid));
315    if(size)
316        *size = NC_atomictypelen(typeid);
317   return NC_NOERR;
318}
319
320static int
321NCP_def_dim(int ncid, const char* name, size_t len, int* idp)
322{
323    int status;
324    NCP_INFOnc5;
325    NCnc;
326
327    status = NC_check_id(ncid, &nc);
328    if(status != NC_NOERR)
329 return status;
330
331    nc5 = NCP_DATA(nc);
332    assert(nc5);
333
334    return ncmpi_def_dim(nc->int_ncidnamelenidp);
335}
336
337static int
338NCP_inq_dimid(int ncid, const char *name, int *idp)
339{
340    NCnc;
341    int status = NC_check_id(ncid, &nc);
342    if(status != NC_NOERR) return status;
343    return ncmpi_inq_dimid(nc->int_ncid,name,idp);
344}
345
346static int
347NCP_inq_dim(int ncid, int dimid, char *name, size_t* lenp)
348{
349    int status;
350    NCnc;
351    MPI_Offset mpilen;
352    status = NC_check_id(ncid, &nc);
353    if(status != NC_NOERR) return status;
354    status = ncmpi_inq_dim(nc->int_ncid,dimid,name,&mpilen);
355    if(lenp) *lenp = mpilen;
356    return status;
357}
358
359static int
360NCP_inq_unlimdim(int ncid,  int *unlimdimidp)
361{
362    NCnc;
363    int status = NC_check_id(ncid, &nc);
364    if(status != NC_NOERR) return status;
365    return ncmpi_inq_unlimdim(nc->int_ncid,unlimdimidp);
366}
367
368static int
369NCP_rename_dim(int ncid, int dimid, const char* newname)
370{
371    NCnc;
372    int status = NC_check_id(ncid, &nc);
373    if(status != NC_NOERR) return status;
374    return ncmpi_rename_dim(nc->int_ncid,dimid,newname);
375}
376
377static int
378NCP_inq_att(int ncid, int varid, const char* namenc_typextypep, size_t* lenp)
379{
380    NCnc;
381    MPI_Offset mpilen;
382    int status = NC_check_id(ncid, &nc);
383    if(status != NC_NOERR) return status;
384    status = ncmpi_inq_att(nc->int_ncid,varid,name,xtypep,&mpilen);
385    if(status != NC_NOERR) return status;
386    if(lenp) *lenp = mpilen;
387    return status;
388}
389
390static int
391NCP_inq_attid(int ncid, int varid, const char *name, int *idp)
392{
393    NCnc;
394    int status = NC_check_id(ncid, &nc);
395    if(status != NC_NOERR) return status;
396    return ncmpi_inq_attid(nc->int_ncid,varid,name,idp);
397}
398
399static int
400NCP_inq_attname(int ncid, int varid, int attnum, char *name)
401{
402    NCnc;
403    int status = NC_check_id(ncid, &nc);
404    if(status != NC_NOERR) return status;
405    return ncmpi_inq_attname(nc->int_ncid,varid,attnum,name);
406
407}
408
409static int
410NCP_rename_att(int ncid, int varid, const char *name,
411 const char *newname)
412{
413    NCnc;
414    int status = NC_check_id(ncid, &nc);
415    if(status != NC_NOERR) return status;
416    return ncmpi_rename_att(nc->int_ncid,varid,name,newname);
417}
418
419static int
420NCP_del_att(int ncid, int varid, const char *name)
421{
422    NCnc;
423    int status = NC_check_id(ncid, &nc);
424    if(status != NC_NOERR) return status;
425    return ncmpi_del_att(nc->int_ncid,varid,name);
426}
427
428int
429NCP_get_att(
430 int ncid,
431 int varid,
432 const char *name,
433 void *ip,
434 nc_type memtype)
435{
436    NCnc;
437    int status;
438    nc_type xtype;
439
440    status = NC_check_id(ncid, &nc);
441    if(status != NC_NOERR) return status;
442
443    status = NCP_inq_att(ncid,varid,name,&xtype,NULL);
444
445    if(memtype == NC_NATmemtype = xtype;
446
447    switch (memtype) {
448    case NC_CHAR:
449        return ncmpi_get_att_text(nc->int_ncidvaridname, (char*)ip);
450    case NC_BYTE:
451        return ncmpi_get_att_schar(nc->int_ncidvaridname, (signed char*)ip);
452    case NC_SHORT:
453        return ncmpi_get_att_short(nc->int_ncidvaridname, (short*)ip);
454    case NC_INT:
455        return ncmpi_get_att_int(nc->int_ncidvaridname, (int*)ip);
456    case NC_FLOAT:
457        return ncmpi_get_att_float(nc->int_ncidvaridname, (float*)ip);
458    case NC_DOUBLE:
459        return ncmpi_get_att_double(nc->int_ncidvaridname, (double*)ip);
460    case NC_UBYTE:
461         return ncmpi_get_att_uchar(nc->int_ncidvaridname, (unsigned char*)ip);
462    case NC_USHORT:
463        return ncmpi_get_att_ushort(nc->int_ncidvaridname, (unsigned short*)ip);
464    case NC_UINT:
465        return ncmpi_get_att_uint(nc->int_ncidvaridname, (unsigned int*)ip);
466    case NC_INT64:
467        return ncmpi_get_att_longlong(nc->int_ncidvaridname, (long long*)ip);
468    case NC_UINT64:
469        return ncmpi_get_att_ulonglong(nc->int_ncidvaridname, (unsigned long long*)ip);
470    default:
471 break;
472    }
473    return NC_EBADTYPE;
474}
475
476int
477NCP_put_att(
478 int ncid,
479 int varid,
480 const char *name,
481 nc_type xtype,
482 size_t len,
483 const void *ip,
484 nc_type memtype)
485{
486    NCnc;
487    int status;
488    MPI_Offset mpilen;
489
490    if (!name || (strlen(name) > NC_MAX_NAME))
491 return NC_EBADNAME;
492
493    /* The length needs to be positive (cast needed for braindead
494       systems with signed size_t). */
495    if(((unsigned long) len) > X_INT_MAX)
496 return NC_EINVAL;
497
498    status = NC_check_id(ncid, &nc);
499    if(status != NC_NOERR) return status;
500
501    mpilen = len;
502
503    switch (memtype) {
504    case NC_CHAR:
505        return ncmpi_put_att_text(nc->int_ncidvaridnamempilen, (char*)ip);
506    case NC_BYTE:
507        return ncmpi_put_att_schar(nc->int_ncidvaridnamextypempilen, (signed char*)ip);
508    case NC_SHORT:
509        return ncmpi_put_att_short(nc->int_ncidvaridnamextypempilen, (short*)ip);
510    case NC_INT:
511        return ncmpi_put_att_int(nc->int_ncidvaridnamextypempilen, (int*)ip);
512    case NC_FLOAT:
513        return ncmpi_put_att_float(nc->int_ncidvaridnamextypempilen, (float*)ip);
514    case NC_DOUBLE:
515        return ncmpi_put_att_double(nc->int_ncidvaridnamextypempilen, (double*)ip);
516    case NC_UBYTE:
517         return ncmpi_put_att_uchar(nc->int_ncidvaridnamextypempilen, (unsigned char*)ip);
518    case NC_USHORT:
519        return ncmpi_put_att_ushort(nc->int_ncidvaridnamextypempilen, (unsigned short*)ip);
520    case NC_UINT:
521        return ncmpi_put_att_uint(nc->int_ncidvaridnamextypempilen, (unsigned int*)ip);
522    case NC_INT64:
523        return ncmpi_put_att_longlong(nc->int_ncidvaridnamextypempilen, (long long*)ip);
524    case NC_UINT64:
525        return ncmpi_put_att_ulonglong(nc->int_ncidvaridnamextypempilen, (unsigned long long*)ip);
526    default:
527 break;
528    }
529    return NC_EBADTYPE;
530}
531
532static int
533NCP_def_var(int ncid, const char *namenc_type xtype,
534     int ndims, const int *dimidsp, int *varidp)
535{
536    NCnc;
537    NCP_INFOnc5;
538    int status;
539
540    status = NC_check_id(ncid, &nc);
541    if(status != NC_NOERR) return status;
542    nc5 = NCP_DATA(nc);
543    assert(nc5);
544
545    status = ncmpi_def_var(nc->int_ncid,name,xtype,ndims,dimidsp,varidp);
546    return status;
547}
548
549static int
550NCP_inq_varid(int ncid, const char *name, int *varidp)
551{
552    NCnc;
553    int status = NC_check_id(ncid, &nc);
554    if(status != NC_NOERR) return status;
555    return ncmpi_inq_varid(nc->int_ncid,name,varidp);
556}
557
558static int
559NCP_rename_var(int ncid, int varid, const char *name)
560{
561    NCnc;
562    int status = NC_check_id(ncid, &nc);
563    if(status != NC_NOERR) return status;
564    return ncmpi_rename_var(nc->int_ncid,varid,name);
565}
566
567static int
568NCP_get_vara(int ncid,
569 int varid,
570 const size_t* startp,
571 const size_t* countp,
572 void* ip,
573 nc_type memtype)
574{
575    NCnc;
576    NCP_INFOnc5;
577    int status;
578    MPI_Offset mpi_start[NC_MAX_VAR_DIMS], mpi_count[NC_MAX_VAR_DIMS];
579    int d;
580    int rank = 0;
581
582    status = NC_check_id(ncid, &nc);
583    if(status != NC_NOERR) return status;
584
585    nc5 = NCP_DATA(nc);
586    assert(nc5);
587
588    /* get variable's rank */
589    statusncmpi_inq_varndims(nc->int_ncidvarid, &rank);
590    if(status) return status;
591
592    /* We must convert the start and count arrays to MPI_Offset type. */
593    for (d = 0; d < rankd++) {
594  mpi_start[d] = startp[d];
595  mpi_count[d] = countp[d];
596    }
597
598    if (memtype == NC_NAT) {
599        status = ncmpi_inq_vartype(nc->int_ncidvarid, &memtype);
600        if (status) return status;
601    }
602
603    if(nc5->pnetcdf_access_mode == NC_INDEPENDENT) {
604 switch(memtype) {
605 case NC_BYTE:
606     status=ncmpi_get_vara_schar(nc->int_ncidvaridmpi_startmpi_countip); break;
607 case NC_CHAR:
608     status=ncmpi_get_vara_text(nc->int_ncidvaridmpi_startmpi_countip); break;
609 case NC_SHORT:
610     status=ncmpi_get_vara_short(nc->int_ncidvaridmpi_startmpi_countip); break;
611 case NC_INT:
612     status=ncmpi_get_vara_int(nc->int_ncidvaridmpi_startmpi_countip); break;
613 case NC_FLOAT:
614     status=ncmpi_get_vara_float(nc->int_ncidvaridmpi_startmpi_countip); break;
615 case NC_DOUBLE:
616     status=ncmpi_get_vara_double(nc->int_ncidvaridmpi_startmpi_countip); break;
617 case NC_UBYTE:
618      status=ncmpi_get_vara_uchar(nc->int_ncidvaridmpi_startmpi_countip); break;
619 case NC_USHORT:
620     status=ncmpi_get_vara_ushort(nc->int_ncidvaridmpi_startmpi_countip); break;
621 case NC_UINT:
622     status=ncmpi_get_vara_uint(nc->int_ncidvaridmpi_startmpi_countip); break;
623 case NC_INT64:
624     status=ncmpi_get_vara_longlong(nc->int_ncidvaridmpi_startmpi_countip); break;
625 case NC_UINT64:
626     status=ncmpi_get_vara_ulonglong(nc->int_ncidvaridmpi_startmpi_countip); break;
627 default:
628     status = NC_EBADTYPE;
629 }
630      } else {
631 switch(memtype) {
632 case NC_BYTE:
633     status=ncmpi_get_vara_schar_all(nc->int_ncidvaridmpi_startmpi_countip); break;
634 case NC_CHAR:
635     status=ncmpi_get_vara_text_all(nc->int_ncidvaridmpi_startmpi_countip); break;
636 case NC_SHORT:
637     status=ncmpi_get_vara_short_all(nc->int_ncidvaridmpi_startmpi_countip); break;
638 case NC_INT:
639     status=ncmpi_get_vara_int_all(nc->int_ncidvaridmpi_startmpi_countip); break;
640 case NC_FLOAT:
641     status=ncmpi_get_vara_float_all(nc->int_ncidvaridmpi_startmpi_countip); break;
642 case NC_DOUBLE:
643     status=ncmpi_get_vara_double_all(nc->int_ncidvaridmpi_startmpi_countip); break;
644 case NC_UBYTE:
645     status=ncmpi_get_vara_uchar_all(nc->int_ncidvaridmpi_startmpi_countip); break;
646 case NC_USHORT:
647     status=ncmpi_get_vara_ushort_all(nc->int_ncidvaridmpi_startmpi_countip); break;
648 case NC_UINT:
649     status=ncmpi_get_vara_uint_all(nc->int_ncidvaridmpi_startmpi_countip); break;
650  case NC_INT64:
651     status=ncmpi_get_vara_longlong_all(nc->int_ncidvaridmpi_startmpi_countip); break;
652 case NC_UINT64:
653     status=ncmpi_get_vara_ulonglong_all(nc->int_ncidvaridmpi_startmpi_countip); break;
654 default:
655     status = NC_EBADTYPE;
656 }
657    }
658    return status;
659}
660
661static int
662NCP_put_vara(int ncid,
663 int varid,
664 const size_t* startp,
665 const size_t* countp,
666 const void*ip,
667 nc_type memtype)
668{
669    NCnc;
670    NCP_INFOnc5;
671    int status;
672    MPI_Offset mpi_start[NC_MAX_VAR_DIMS], mpi_count[NC_MAX_VAR_DIMS];
673    int d;
674    int rank;
675
676    status = NC_check_id(ncid, &nc);
677    if(status != NC_NOERR) return status;
678
679    nc5 = NCP_DATA(nc);
680    assert(nc5);
681
682    /* get variable's rank */
683    status = ncmpi_inq_varndims(nc->int_ncidvarid, &rank);
684    if(status) return status;
685
686    /* We must convert the start and count arrays to MPI_Offset type. */
687    for (d = 0; d < rankd++) {
688  mpi_start[d] = startp[d];
689  mpi_count[d] = countp[d];
690    }
691
692    if (memtype == NC_NAT) {
693        status = ncmpi_inq_vartype(nc->int_ncidvarid, &memtype);
694        if (status) return status;
695    }
696
697    if(nc5->pnetcdf_access_mode == NC_INDEPENDENT) {
698 switch(memtype) {
699 case NC_BYTE:
700     status = ncmpi_put_vara_schar(nc->int_ncidvaridmpi_startmpi_countip); break;
701 case NC_CHAR:
702     status = ncmpi_put_vara_text(nc->int_ncidvaridmpi_startmpi_countip); break;
703 case NC_SHORT:
704     status = ncmpi_put_vara_short(nc->int_ncidvaridmpi_startmpi_countip); break;
705 case NC_INT:
706     status = ncmpi_put_vara_int(nc->int_ncidvaridmpi_startmpi_countip); break;
707 case NC_FLOAT:
708     status = ncmpi_put_vara_float(nc->int_ncidvaridmpi_startmpi_countip); break;
709 case NC_DOUBLE:
710     status = ncmpi_put_vara_double(nc->int_ncidvaridmpi_startmpi_countip); break;
711 case NC_UBYTE:
712     status = ncmpi_put_vara_uchar(nc->int_ncidvaridmpi_startmpi_countip); break;
713 case NC_USHORT:
714     status = ncmpi_put_vara_ushort(nc->int_ncidvaridmpi_startmpi_countip); break;
715 case NC_UINT:
716     status = ncmpi_put_vara_uint(nc->int_ncidvaridmpi_startmpi_countip); break;
717 case NC_INT64:
718      status = ncmpi_put_vara_longlong(nc->int_ncidvaridmpi_startmpi_countip); break;
719 case NC_UINT64:
720     status = ncmpi_put_vara_ulonglong(nc->int_ncidvaridmpi_startmpi_countip); break;
721 default:
722     status = NC_EBADTYPE;
723 }
724      } else {
725 switch(memtype) {
726 case NC_BYTE:
727     status = ncmpi_put_vara_schar_all(nc->int_ncidvaridmpi_startmpi_countip); break;
728 case NC_CHAR:
729     status = ncmpi_put_vara_text_all(nc->int_ncidvaridmpi_startmpi_countip); break;
730 case NC_SHORT:
731     status = ncmpi_put_vara_short_all(nc->int_ncidvaridmpi_startmpi_countip); break;
732 case NC_INT:
733     status = ncmpi_put_vara_int_all(nc->int_ncidvaridmpi_startmpi_countip); break;
734 case NC_FLOAT:
735     status = ncmpi_put_vara_float_all(nc->int_ncidvaridmpi_startmpi_countip); break;
736 case NC_DOUBLE:
737     status = ncmpi_put_vara_double_all(nc->int_ncidvaridmpi_startmpi_countip); break;
738 case NC_UBYTE:
739     status = ncmpi_put_vara_uchar_all(nc->int_ncidvaridmpi_startmpi_countip); break;
740 case NC_USHORT:
741     status = ncmpi_put_vara_ushort_all(nc->int_ncidvaridmpi_startmpi_countip); break;
742 case NC_UINT:
743     status = ncmpi_put_vara_uint_all(nc->int_ncidvaridmpi_startmpi_countip); break;
744  case NC_INT64:
745     status = ncmpi_put_vara_longlong_all(nc->int_ncidvaridmpi_startmpi_countip); break;
746 case NC_UINT64:
747     status = ncmpi_put_vara_ulonglong_all(nc->int_ncidvaridmpi_startmpi_countip); break;
748 default:
749     status = NC_EBADTYPE;
750 }
751    }
752    return status;
753}
754
755static int
756NCP_get_vars(int ncid,
757 int varid,
758 const size_t* startp,
759 const size_t* countp,
760 const ptrdiff_tstridep,
761 void* ip,
762 nc_type memtype)
763{
764    NCnc;
765    NCP_INFOnc5;
766    int status;
767    MPI_Offset mpi_start[NC_MAX_VAR_DIMS], mpi_count[NC_MAX_VAR_DIMS], mpi_stride[NC_MAX_VAR_DIMS];
768    int d;
769    int rank = 0;
770
771    status = NC_check_id(ncid, &nc);
772    if(status != NC_NOERR) return status;
773
774    nc5 = NCP_DATA(nc);
775    assert(nc5);
776
777    /* get variable's rank */
778    statusncmpi_inq_varndims(nc->int_ncidvarid, &rank);
779    if(status) return status;
780
781    /* We must convert the start, count, and stride arrays to MPI_Offset type. */
782    for (d = 0; d < rankd++) {
783  mpi_start[d] = startp[d];
784  mpi_count[d] = countp[d];
785  mpi_stride[d] = stridep[d];
786    }
787
788    if (memtype == NC_NAT) {
789        status = ncmpi_inq_vartype(nc->int_ncidvarid, &memtype);
790        if (status) return status;
791    }
792
793    if(nc5->pnetcdf_access_mode == NC_INDEPENDENT) {
794 switch(memtype) {
795 case NC_BYTE:
796     status=ncmpi_get_vars_schar(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
797 case NC_CHAR:
798     status=ncmpi_get_vars_text(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
799 case NC_SHORT:
800     status=ncmpi_get_vars_short(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
801 case NC_INT:
802     status=ncmpi_get_vars_int(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
803 case NC_FLOAT:
804     status=ncmpi_get_vars_float(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
805 case NC_DOUBLE:
806     status=ncmpi_get_vars_double(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
807 case NC_UBYTE:
808     status=ncmpi_get_vars_uchar(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
809 case NC_USHORT:
810     status=ncmpi_get_vars_ushort(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
811 case NC_UINT:
812     status=ncmpi_get_vars_uint(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
813 case NC_INT64:
814     status=ncmpi_get_vars_longlong(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
815 case NC_UINT64:
816     status=ncmpi_get_vars_ulonglong(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
817 default:
818     status = NC_EBADTYPE;
819 }
820      } else {
821 switch(memtype) {
822 case NC_BYTE:
823     status=ncmpi_get_vars_schar_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
824 case NC_CHAR:
825     status=ncmpi_get_vars_text_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
826 case NC_SHORT:
827     status=ncmpi_get_vars_short_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
828 case NC_INT:
829     status=ncmpi_get_vars_int_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
830 case NC_FLOAT:
831     status=ncmpi_get_vars_float_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
832 case NC_DOUBLE:
833     status=ncmpi_get_vars_double_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
834 case NC_UBYTE:
835     status=ncmpi_get_vars_uchar_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
836 case NC_USHORT:
837     status=ncmpi_get_vars_ushort_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
838 case NC_UINT:
839     status=ncmpi_get_vars_uint_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
840 case NC_INT64:
841     status=ncmpi_get_vars_longlong_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
842 case NC_UINT64:
843     status=ncmpi_get_vars_ulonglong_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
844 default:
845     status = NC_EBADTYPE;
846 }
847    }
848    return status;
849}
850
851static int
852NCP_put_vars(int ncid,
853 int varid,
854 const size_t* startp,
855 const size_t* countp,
856 const ptrdiff_tstridep,
857 const void*ip,
858 nc_type memtype)
859{
860    NCnc;
861    NCP_INFOnc5;
862    int status;
863    MPI_Offset mpi_start[NC_MAX_VAR_DIMS], mpi_count[NC_MAX_VAR_DIMS], mpi_stride[NC_MAX_VAR_DIMS];
864    int d;
865    int rank;
866
867    status = NC_check_id(ncid, &nc);
868    if(status != NC_NOERR) return status;
869
870    nc5 = NCP_DATA(nc);
871    assert(nc5);
872
873    /* get variable's rank */
874    status = ncmpi_inq_varndims(nc->int_ncidvarid, &rank);
875    if(status) return status;
876
877    /* We must convert the start, count, and stride arrays to MPI_Offset type. */
878    for (d = 0; d < rankd++) {
879  mpi_start[d] = startp[d];
880  mpi_count[d] = countp[d];
881  mpi_stride[d] = stridep[d];
882    }
883
884    if (memtype == NC_NAT) {
885        status = ncmpi_inq_vartype(nc->int_ncidvarid, &memtype);
886        if (status) return status;
887    }
888
889    if(nc5->pnetcdf_access_mode == NC_INDEPENDENT) {
890 switch(memtype) {
891 case NC_BYTE:
892     status = ncmpi_put_vars_schar(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
893 case NC_CHAR:
894     status = ncmpi_put_vars_text(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
895 case NC_SHORT:
896     status = ncmpi_put_vars_short(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
897 case NC_INT:
898     status = ncmpi_put_vars_int(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
899 case NC_FLOAT:
900     status = ncmpi_put_vars_float(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
901 case NC_DOUBLE:
902     status = ncmpi_put_vars_double(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
903 case NC_UBYTE:
904     status = ncmpi_put_vars_uchar(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
905 case NC_USHORT:
906     status = ncmpi_put_vars_ushort(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
907 case NC_UINT:
908     status = ncmpi_put_vars_uint(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
909 case NC_INT64:
910     status = ncmpi_put_vars_longlong(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
911 case NC_UINT64:
912     status = ncmpi_put_vars_ulonglong(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
913 default:
914     status = NC_EBADTYPE;
915 }
916      } else {
917 switch(memtype) {
918 case NC_BYTE:
919     status = ncmpi_put_vars_schar_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
920 case NC_CHAR:
921     status = ncmpi_put_vars_text_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
922 case NC_SHORT:
923     status = ncmpi_put_vars_short_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
924 case NC_INT:
925     status = ncmpi_put_vars_int_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
926 case NC_FLOAT:
927     status = ncmpi_put_vars_float_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
928 case NC_DOUBLE:
929     status = ncmpi_put_vars_double_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
930 case NC_UBYTE:
931     status = ncmpi_put_vars_uchar_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
932 case NC_USHORT:
933     status = ncmpi_put_vars_ushort_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
934 case NC_UINT:
935     status = ncmpi_put_vars_uint_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
936 case NC_INT64:
937     status = ncmpi_put_vars_longlong_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
938 case NC_UINT64:
939     status = ncmpi_put_vars_ulonglong_all(nc->int_ncidvaridmpi_startmpi_countmpi_strideip); break;
940 default:
941     status = NC_EBADTYPE;
942 }
943    }
944    return status;
945}
946
947static int
948NCP_get_varm(int ncid,
949 int varid,
950 const size_t* startp,
951 const size_t* countp,
952 const ptrdiff_tstridep,
953 const ptrdiff_timapp,
954 void* ip,
955 nc_type memtype)
956{
957    NCnc;
958    NCP_INFOnc5;
959    int status;
960    MPI_Offset mpi_start[NC_MAX_VAR_DIMS], mpi_count[NC_MAX_VAR_DIMS], mpi_stride[NC_MAX_VAR_DIMS], mpi_imap[NC_MAX_VAR_DIMS];
961    int d;
962    int rank = 0;
963
964    status = NC_check_id(ncid, &nc);
965    if(status != NC_NOERR) return status;
966
967    nc5 = NCP_DATA(nc);
968    assert(nc5);
969
970    /* get variable's rank */
971    statusncmpi_inq_varndims(nc->int_ncidvarid, &rank);
972    if(status) return status;
973
974    /* We must convert the start, count, stride, and imap arrays to MPI_Offset type. */
975    for (d = 0; d < rankd++) {
976  mpi_start[d] = startp[d];
977  mpi_count[d] = countp[d];
978  mpi_stride[d] = stridep[d];
979  mpi_imap[d] = imapp[d];
980    }
981
982    if (memtype == NC_NAT) {
983        status = ncmpi_inq_vartype(nc->int_ncidvarid, &memtype);
984        if (status) return status;
985    }
986
987    if(nc5->pnetcdf_access_mode == NC_INDEPENDENT) {
988 switch(memtype) {
989 case NC_BYTE:
990     status=ncmpi_get_varm_schar(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
991 case NC_CHAR:
992     status=ncmpi_get_varm_text(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
993 case NC_SHORT:
994     status=ncmpi_get_varm_short(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
995 case NC_INT:
996     status=ncmpi_get_varm_int(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
997 case NC_FLOAT:
998     status=ncmpi_get_varm_float(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
999 case NC_DOUBLE:
1000     status=ncmpi_get_varm_double(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1001 case NC_UBYTE:
1002     status=ncmpi_get_varm_uchar(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1003 case NC_USHORT:
1004     status=ncmpi_get_varm_ushort(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1005 case NC_UINT:
1006     status=ncmpi_get_varm_uint(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1007 case NC_INT64:
1008     status=ncmpi_get_varm_longlong(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1009 case NC_UINT64:
1010     status=ncmpi_get_varm_ulonglong(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1011 default:
1012     status = NC_EBADTYPE;
1013 }
1014      } else {
1015 switch(memtype) {
1016 case NC_BYTE:
1017     status=ncmpi_get_varm_schar_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1018 case NC_CHAR:
1019     status=ncmpi_get_varm_text_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1020 case NC_SHORT:
1021     status=ncmpi_get_varm_short_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1022 case NC_INT:
1023     status=ncmpi_get_varm_int_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1024 case NC_FLOAT:
1025     status=ncmpi_get_varm_float_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1026 case NC_DOUBLE:
1027     status=ncmpi_get_varm_double_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1028 case NC_UBYTE:
1029     status=ncmpi_get_varm_uchar_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1030 case NC_USHORT:
1031     status=ncmpi_get_varm_ushort_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1032 case NC_UINT:
1033     status=ncmpi_get_varm_uint_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1034 case NC_INT64:
1035     status=ncmpi_get_varm_longlong_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1036 case NC_UINT64:
1037     status=ncmpi_get_varm_ulonglong_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1038 default:
1039     status = NC_EBADTYPE;
1040 }
1041    }
1042    return status;
1043}
1044
1045static int
1046NCP_put_varm(int ncid,
1047 int varid,
1048 const size_t* startp,
1049 const size_t* countp,
1050 const ptrdiff_tstridep,
1051 const ptrdiff_timapp,
1052 const void*ip,
1053 nc_type memtype)
1054{
1055    NCnc;
1056    NCP_INFOnc5;
1057    int status;
1058    MPI_Offset mpi_start[NC_MAX_VAR_DIMS], mpi_count[NC_MAX_VAR_DIMS], mpi_stride[NC_MAX_VAR_DIMS], mpi_imap[NC_MAX_VAR_DIMS];
1059    int d;
1060    int rank;
1061
1062    status = NC_check_id(ncid, &nc);
1063    if(status != NC_NOERR) return status;
1064
1065    nc5 = NCP_DATA(nc);
1066    assert(nc5);
1067
1068    /* get variable's rank */
1069    status = ncmpi_inq_varndims(nc->int_ncidvarid, &rank);
1070    if(status) return status;
1071
1072    /* We must convert the start, count, stride, and imap arrays to MPI_Offset type. */
1073    for (d = 0; d < rankd++) {
1074  mpi_start[d] = startp[d];
1075  mpi_count[d] = countp[d];
1076  mpi_stride[d] = stridep[d];
1077  mpi_imap[d] = imapp[d];
1078    }
1079
1080    if (memtype == NC_NAT) {
1081        status = ncmpi_inq_vartype(nc->int_ncidvarid, &memtype);
1082        if (status) return status;
1083    }
1084
1085    if(nc5->pnetcdf_access_mode == NC_INDEPENDENT) {
1086 switch(memtype) {
1087 case NC_BYTE:
1088     status = ncmpi_put_varm_schar(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1089 case NC_CHAR:
1090     status = ncmpi_put_varm_text(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1091 case NC_SHORT:
1092     status = ncmpi_put_varm_short(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1093 case NC_INT:
1094     status = ncmpi_put_varm_int(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1095 case NC_FLOAT:
1096     status = ncmpi_put_varm_float(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1097 case NC_DOUBLE:
1098     status = ncmpi_put_varm_double(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1099 case NC_UBYTE:
1100     status = ncmpi_put_varm_uchar(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1101 case NC_USHORT:
1102     status = ncmpi_put_varm_ushort(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1103 case NC_UINT:
1104     status = ncmpi_put_varm_uint(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1105 case NC_INT64:
1106     status = ncmpi_put_varm_longlong(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1107 case NC_UINT64:
1108     status = ncmpi_put_varm_ulonglong(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1109 default:
1110     status = NC_EBADTYPE;
1111 }
1112      } else {
1113 switch(memtype) {
1114 case NC_BYTE:
1115     status = ncmpi_put_varm_schar_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1116 case NC_CHAR:
1117     status = ncmpi_put_varm_text_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1118 case NC_SHORT:
1119     status = ncmpi_put_varm_short_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1120 case NC_INT:
1121     status = ncmpi_put_varm_int_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1122 case NC_FLOAT:
1123     status = ncmpi_put_varm_float_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1124 case NC_DOUBLE:
1125     status = ncmpi_put_varm_double_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1126 case NC_UBYTE:
1127     status = ncmpi_put_varm_uchar_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1128 case NC_USHORT:
1129     status = ncmpi_put_varm_ushort_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1130 case NC_UINT:
1131     status = ncmpi_put_varm_uint_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1132 case NC_INT64:
1133     status = ncmpi_put_varm_longlong_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1134 case NC_UINT64:
1135     status = ncmpi_put_varm_ulonglong_all(nc->int_ncidvaridmpi_startmpi_countmpi_stridempi_imapip); break;
1136 default:
1137     status = NC_EBADTYPE;
1138 }
1139    }
1140    return status;
1141}
1142
1143static int
1144NCP_inq_var_all(int ncid, int varid, char *namenc_type *xtypep,
1145               int *ndimsp, int *dimidsp, int *nattsp,
1146               int *shufflep, int *deflatep, int *deflate_levelp,
1147               int *fletcher32p, int *contiguousp, size_t *chunksizesp,
1148               int *no_fill, void *fill_valuep, int *endiannessp,
1149        int *options_maskp, int *pixels_per_blockp)
1150{
1151    int status;
1152    NCnc;
1153
1154    status = NC_check_id(ncid, &nc);
1155    if(status != NC_NOERR) return status;
1156
1157    status = ncmpi_inq_var(nc->int_ncidvaridnamextypepndimspdimidspnattsp);
1158    if(status) return status;
1159    if(shufflep) *shufflep = 0;
1160    if(deflatep) *deflatep = 0;
1161    if(fletcher32p) *fletcher32p = 0;
1162    if(contiguousp) *contiguousp = NC_CONTIGUOUS;
1163    if(no_fill) *no_fill = 1;
1164    if(endiannessp) return NC_ENOTNC4;
1165    if(options_maskp) return NC_ENOTNC4;
1166    return NC_NOERR;
1167}
1168
1169static int
1170NCP_var_par_access(int ncid, int varid, int par_access)
1171{
1172    NC *nc;
1173    NCP_INFOnc5;
1174    int status;
1175
1176    if (par_access != NC_INDEPENDENT && par_access != NC_COLLECTIVE)
1177 return NC_EINVAL;
1178
1179    status = NC_check_id(ncid, &nc);
1180    if(status != NC_NOERR) return status;
1181
1182    nc5 = NCP_DATA(nc);
1183    assert(nc5);
1184
1185    if(par_access == nc5->pnetcdf_access_mode)
1186 return NC_NOERR;
1187    nc5->pnetcdf_access_mode = par_access;
1188    if (par_access == NC_INDEPENDENT)
1189 return ncmpi_begin_indep_data(nc->int_ncid);
1190    else
1191 return ncmpi_end_indep_data(nc->int_ncid);
1192}
1193
1194#ifdef USE_NETCDF4
1195
1196static int
1197NCP_show_metadata(int ncid)
1198{
1199    return NC_NOERR;
1200}
1201
1202static int
1203NCP_inq_unlimdims(int ncid, int *ndimsp, int *unlimdimidsp)
1204{
1205    int retval;
1206    int unlimid;
1207
1208    if((retval = NCP_inq_unlimdim(ncid, &unlimid)))
1209        return retval;
1210    if(unlimid != -1) {
1211        if(ndimsp) *ndimsp = 1;
1212        if(unlimdimidsp)
1213            unlimdimidsp[0] = unlimid;
1214    } else
1215        if(ndimsp) *ndimsp = 0;
1216    return NC_NOERR;
1217}
1218
1219static int
1220NCP_inq_type_equal(int ncid1nc_type typeid1, int ncid2nc_type typeid2, int* equalp)
1221{
1222    /* Check input. */
1223    if(equalp == NULL) return NC_NOERR;
1224
1225    if (typeid1 <= NC_NAT || typeid2 <= NC_NAT)
1226       return NC_EINVAL;
1227
1228    *equalp = 0; /* assume */
1229
1230    /* If one is atomic, and the other user-defined, the types are not equal */
1231    if ((typeid1 <= NC_STRING && typeid2 > NC_STRING) ||
1232        (typeid2 <= NC_STRING && typeid1 > NC_STRING)) {
1233        if (equalp) *equalp = 0;
1234        return NC_NOERR;
1235    }
1236
1237    /* If both are atomic types, the answer is easy. */
1238    if (typeid1 <= ATOMICTYPEMAX5) {
1239        if (equalp) {
1240            if (typeid1 == typeid2)
1241                *equalp = 1;
1242            else
1243                *equalp = 0;
1244        }
1245        return NC_NOERR;
1246    }
1247    return NC_NOERR;
1248}
1249
1250static int
1251NCP_def_grp(int parent_ncid, const char *name, int *new_ncid)
1252{
1253    return NC_ENOTNC4;
1254}
1255
1256static int
1257NCP_rename_grp(int ncid, const char *name)
1258{
1259    return NC_ENOTNC4;
1260}
1261
1262static int
1263NCP_inq_ncid(int ncid, const char *name, int *grp_ncid)
1264{
1265    if(grp_ncid) *grp_ncid = ncid;
1266    return NC_NOERR;
1267}
1268
1269static int
1270NCP_inq_grps(int ncid, int *numgrps, int *ncids)
1271{
1272    if(numgrps)
1273       *numgrps = 0;
1274    return NC_NOERR;
1275}
1276
1277static int
1278NCP_inq_grpname(int ncid, char *name)
1279{
1280    if(name)
1281        strcpy(name, "/");
1282    return NC_NOERR;
1283}
1284
1285static int
1286NCP_inq_grpname_full(int ncid, size_t *lenp, char *full_name)
1287{
1288    if(full_name)
1289        strcpy(full_name, "/");
1290    if(lenp) *lenp = 1;
1291    return NC_NOERR;
1292}
1293
1294static int
1295NCP_inq_grp_parent(int ncid, int *parent_ncid)
1296{
1297    return NC_ENOGRP;
1298}
1299
1300static int
1301NCP_inq_grp_full_ncid(int ncid, const char *full_name, int *grp_ncid)
1302{
1303    return NC_ENOGRP;
1304}
1305
1306static int
1307NCP_inq_varids(int ncid, int *nvarsp, int *varids)
1308{
1309    int retval,v,nvars;
1310    /* This is, effectively, a netcdf-3 file, there is only one group, the root
1311        group, and its vars have ids 0 thru nvars - 1. */
1312    if((retval = NCP_inq(ncidNULL, &nvarsNULLNULL)))
1313        return retval;
1314    if(nvarsp) *nvarsp = nvars;
1315    if(varids)
1316        for (v = 0; v < nvarsv++)
1317            varids[v] = v;
1318    return NC_NOERR;
1319}
1320
1321static int
1322NCP_inq_dimids(int ncid, int *ndimsp, int *dimids, int include_parents)
1323{
1324    int retval,d,ndims;
1325    /* If this is like a netcdf-3 file, then the dimids are going to be 0
1326       thru ndims-1, so just provide them. */
1327    if((retval = NCP_inq(ncid, &ndims,  NULLNULLNULL)))
1328        return retval;
1329    if(ndimsp) *ndimsp = ndims;
1330    if(dimids)
1331        for (d = 0; d < ndimsd++)
1332            dimids[d] = d;
1333    return NC_NOERR;
1334}
1335
1336static int
1337NCP_inq_typeid(int ncid, const char *namenc_type *typeidp)
1338{
1339    int i;
1340    for (i = 0; i <= ATOMICTYPEMAX5i++)
1341        if(!strcmp(nameNC_atomictypename(i))) {
1342            if(typeidp) *typeidp = i;
1343                return NC_NOERR;
1344        }
1345    return NC_ENOTNC4;
1346}
1347
1348static int
1349NCP_inq_typeids(int ncid, int *ntypes, int *typeids)
1350{
1351    if(ntypes) *ntypes = 0;
1352    return NC_NOERR;
1353}
1354
1355static int
1356NCP_inq_user_type(int ncidnc_type typeid, char *name, size_t *size,
1357  nc_type *base_nc_typep, size_t *nfieldsp, int *classp)
1358{
1359    return NC_ENOTNC4;
1360}
1361
1362static int
1363NCP_def_compound(int ncid, size_t size, const char *namenc_type *typeidp)
1364{
1365    return NC_ENOTNC4;
1366}
1367
1368static int
1369NCP_insert_compound(int ncidnc_type typeid, const char *name, size_t offset,
1370                    nc_type field_typeid)
1371{
1372    return NC_ENOTNC4;
1373}
1374
1375static int
1376NCP_insert_array_compound(int ncidnc_type typeid, const char *name,
1377  size_t offsetnc_type field_typeid,
1378  int ndims, const int *dim_sizes)
1379{
1380    return NC_ENOTNC4;
1381}
1382
1383
1384static int
1385NCP_inq_compound_field(int ncidnc_type typeid, int fieldid, char *name,
1386       size_t *offsetpnc_type *field_typeidp, int *ndimsp,
1387       int *dim_sizesp)
1388{
1389    return NC_ENOTNC4;
1390}
1391
1392static int
1393NCP_inq_compound_fieldindex(int ncidnc_type typeid, const char *name, int *fieldidp)
1394{
1395    return NC_ENOTNC4;
1396}
1397
1398static int
1399NCP_def_opaque(int ncid, size_t datum_size, const char *namenc_typextypep)
1400{
1401    return NC_ENOTNC4;
1402}
1403
1404static int
1405NCP_def_vlen(int ncid, const char *namenc_type base_typeidnc_typextypep)
1406{
1407    return NC_ENOTNC4;
1408}
1409
1410static int
1411NCP_def_enum(int ncidnc_type base_typeid, const char *name,
1412     nc_type *typeidp)
1413{
1414    return NC_ENOTNC4;
1415}
1416
1417static int
1418NCP_inq_enum_ident(int ncidnc_type xtype, long long value, char *identifier)
1419{
1420    return NC_ENOTNC4;
1421}
1422
1423static int
1424NCP_inq_enum_member(int ncidnc_type typeid, int idx, char *identifier,
1425    void *value)
1426{
1427    return NC_ENOTNC4;
1428}
1429
1430static int
1431NCP_insert_enum(int ncidnc_type typeid, const char *identifier,
1432        const void *value)
1433{
1434    return NC_ENOTNC4;
1435}
1436
1437static int
1438NCP_put_vlen_element(int ncid, int typeid, void *vlen_element,
1439     size_t len, const void *data)
1440{
1441    return NC_ENOTNC4;
1442}
1443
1444static int
1445NCP_get_vlen_element(int ncid, int typeid, const void *vlen_element,
1446     size_t *len, void *data)
1447{
1448    return NC_ENOTNC4;
1449}
1450
1451static int
1452NCP_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
1453{
1454    return NC_ENOTNC4;
1455}
1456
1457static int
1458NCP_get_var_chunk_cache(int ncid, int varid, size_t *sizep, size_t *nelemsp, float *preemptionp)
1459{
1460    return NC_ENOTNC4;
1461}
1462
1463static int
1464NCP_def_var_deflate(int ncid, int varid, int shuffle, int deflate,
1465    int deflate_level)
1466{
1467    return NC_ENOTNC4;
1468}
1469
1470static int
1471NCP_def_var_fletcher32(int ncid, int varid, int fletcher32)
1472{
1473    return NC_ENOTNC4;
1474}
1475
1476static int
1477NCP_def_var_chunking(int ncid, int varid, int contiguous, const size_t *chunksizesp)
1478{
1479    return NC_ENOTNC4;
1480}
1481
1482static int
1483NCP_def_var_fill(int ncid, int varid, int no_fill, const void *fill_value)
1484{
1485    return NC_ENOTNC4;
1486}
1487
1488static int
1489NCP_def_var_endian(int ncid, int varid, int endianness)
1490{
1491    return NC_ENOTNC4;
1492}
1493
1494#endif /*USE_NETCDF4*/
1495
1496/**************************************************/
1497/* Pnetcdf Dispatch table */
1498
1499NC_Dispatch NCP_dispatcher = {
1500
1501NC_FORMATX_PNETCDF,
1502
1503NCP_create,
1504NCP_open,
1505
1506NCP_redef,
1507NCP__enddef,
1508NCP_sync,
1509NCP_abort,
1510NCP_close,
1511NCP_set_fill,
1512NCP_inq_base_pe,
1513NCP_set_base_pe,
1514NCP_inq_format,
1515NCP_inq_format_extended,
1516
1517NCP_inq,
1518NCP_inq_type,
1519
1520NCP_def_dim,
1521NCP_inq_dimid,
1522NCP_inq_dim,
1523NCP_inq_unlimdim,
1524NCP_rename_dim,
1525
1526NCP_inq_att,
1527NCP_inq_attid,
1528NCP_inq_attname,
1529NCP_rename_att,
1530NCP_del_att,
1531NCP_get_att,
1532NCP_put_att,
1533
1534NCP_def_var,
1535NCP_inq_varid,
1536NCP_rename_var,
1537NCP_get_vara,
1538NCP_put_vara,
1539NCP_get_vars,
1540NCP_put_vars,
1541NCP_get_varm,
1542NCP_put_varm,
1543
1544NCP_inq_var_all,
1545
1546NCP_var_par_access,
1547
1548#ifdef USE_NETCDF4
1549NCP_show_metadata,
1550NCP_inq_unlimdims,
1551
1552NCP_inq_ncid,
1553NCP_inq_grps,
1554NCP_inq_grpname,
1555NCP_inq_grpname_full,
1556NCP_inq_grp_parent,
1557NCP_inq_grp_full_ncid,
1558NCP_inq_varids,
1559NCP_inq_dimids,
1560NCP_inq_typeids,
1561NCP_inq_type_equal,
1562NCP_def_grp,
1563NCP_rename_grp,
1564NCP_inq_user_type,
1565NCP_inq_typeid,
1566
1567NCP_def_compound,
1568NCP_insert_compound,
1569NCP_insert_array_compound,
1570NCP_inq_compound_field,
1571NCP_inq_compound_fieldindex,
1572NCP_def_vlen,
1573NCP_put_vlen_element,
1574NCP_get_vlen_element,
1575NCP_def_enum,
1576NCP_insert_enum,
1577NCP_inq_enum_member,
1578NCP_inq_enum_ident,
1579NCP_def_opaque,
1580NCP_def_var_deflate,
1581NCP_def_var_fletcher32,
1582NCP_def_var_chunking,
1583NCP_def_var_fill,
1584NCP_def_var_endian,
1585NCP_set_var_chunk_cache,
1586NCP_get_var_chunk_cache,
1587#endif /*USE_NETCDF4*/
1588
1589};
1590
1591NC_DispatchNCP_dispatch_table = NULL; /* moved here from ddispatch.c */
1592
1593int
1594NCP_initialize(void)
1595{
1596    NCP_dispatch_table = &NCP_dispatcher;
1597    return NC_NOERR;
1598}
1599
1600int
1601NCP_finalize(void)
1602{
1603    return NC_NOERR;
1604}


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