Actual source code: f90_cwrap.c

petsc-3.8.4 2018-03-24
Report Typos and Errors
  1: #include <petsc/private/f90impl.h>

  3: /*************************************************************************/

  5: #if defined(PETSC_HAVE_FORTRAN_CAPS)
  6: #define f90array1dcreatescalar_           F90ARRAY1DCREATESCALAR
  7: #define f90array1daccessscalar_           F90ARRAY1DACCESSSCALAR
  8: #define f90array1ddestroyscalar_          F90ARRAY1DDESTROYSCALAR
  9: #define f90array1dcreatereal_             F90ARRAY1DCREATEREAL
 10: #define f90array1daccessreal_             F90ARRAY1DACCESSREAL
 11: #define f90array1ddestroyreal_            F90ARRAY1DDESTROYREAL
 12: #define f90array1dcreateint_              F90ARRAY1DCREATEINT
 13: #define f90array1daccessint_              F90ARRAY1DACCESSINT
 14: #define f90array1ddestroyint_             F90ARRAY1DDESTROYINT
 15: #define f90array1dcreatefortranaddr_      F90ARRAY1DCREATEFORTRANADDR
 16: #define f90array1daccessfortranaddr_      F90ARRAY1DACCESSFORTRANADDR
 17: #define f90array1ddestroyfortranaddr_     F90ARRAY1DDESTROYFORTRANADDR
 18: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
 19: #define f90array1dcreatescalar_           f90array1dcreatescalar
 20: #define f90array1daccessscalar_           f90array1daccessscalar
 21: #define f90array1ddestroyscalar_          f90array1ddestroyscalar
 22: #define f90array1dcreatereal_             f90array1dcreatereal
 23: #define f90array1daccessreal_             f90array1daccessreal
 24: #define f90array1ddestroyreal_            f90array1ddestroyreal
 25: #define f90array1dcreateint_              f90array1dcreateint
 26: #define f90array1daccessint_              f90array1daccessint
 27: #define f90array1ddestroyint_             f90array1ddestroyint
 28: #define f90array1dcreatefortranaddr_      f90array1dcreatefortranaddr
 29: #define f90array1daccessfortranaddr_      f90array1daccessfortranaddr
 30: #define f90array1ddestroyfortranaddr_     f90array1ddestroyfortranaddr
 31: #endif

 33: PETSC_EXTERN void PETSC_STDCALL f90array1dcreatescalar_(void *,PetscInt *,PetscInt *,F90Array1d * PETSC_F90_2PTR_PROTO_NOVAR);
 34: PETSC_EXTERN void PETSC_STDCALL f90array1daccessscalar_(F90Array1d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
 35: PETSC_EXTERN void PETSC_STDCALL f90array1ddestroyscalar_(F90Array1d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
 36: PETSC_EXTERN void PETSC_STDCALL f90array1dcreatereal_(void *,PetscInt *,PetscInt *,F90Array1d * PETSC_F90_2PTR_PROTO_NOVAR);
 37: PETSC_EXTERN void PETSC_STDCALL f90array1daccessreal_(F90Array1d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
 38: PETSC_EXTERN void PETSC_STDCALL f90array1ddestroyreal_(F90Array1d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
 39: PETSC_EXTERN void PETSC_STDCALL f90array1dcreateint_(void *,PetscInt *,PetscInt *,F90Array1d * PETSC_F90_2PTR_PROTO_NOVAR);
 40: PETSC_EXTERN void PETSC_STDCALL f90array1daccessint_(F90Array1d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
 41: PETSC_EXTERN void PETSC_STDCALL f90array1ddestroyint_(F90Array1d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
 42: PETSC_EXTERN void PETSC_STDCALL f90array1dcreatefortranaddr_(void *,PetscInt *,PetscInt *,F90Array1d * PETSC_F90_2PTR_PROTO_NOVAR);
 43: PETSC_EXTERN void PETSC_STDCALL f90array1daccessfortranaddr_(F90Array1d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
 44: PETSC_EXTERN void PETSC_STDCALL f90array1ddestroyfortranaddr_(F90Array1d *ptr PETSC_F90_2PTR_PROTO_NOVAR);

 46: PetscErrorCode F90Array1dCreate(void *array,PetscDataType type,PetscInt start,PetscInt len,F90Array1d *ptr PETSC_F90_2PTR_PROTO(ptrd))
 47: {
 49:   if (type == PETSC_SCALAR) {
 50:     if (!len) array = PETSC_NULL_SCALAR_Fortran;
 51:     f90array1dcreatescalar_(array,&start,&len,ptr PETSC_F90_2PTR_PARAM(ptrd));
 52:   } else if (type == PETSC_REAL) {
 53:     if (!len) array = PETSC_NULL_REAL_Fortran;
 54:     f90array1dcreatereal_(array,&start,&len,ptr PETSC_F90_2PTR_PARAM(ptrd));
 55:   } else if (type == PETSC_INT) {
 56:     if (!len) array = PETSC_NULL_INTEGER_Fortran;
 57:     f90array1dcreateint_(array,&start,&len,ptr PETSC_F90_2PTR_PARAM(ptrd));
 58:   } else if (type == PETSC_FORTRANADDR) {
 59:     f90array1dcreatefortranaddr_(array,&start,&len,ptr PETSC_F90_2PTR_PARAM(ptrd));
 60:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
 61:   return(0);
 62: }

 64: PetscErrorCode  F90Array1dAccess(F90Array1d *ptr,PetscDataType type,void **array PETSC_F90_2PTR_PROTO(ptrd))
 65: {
 67:   if (type == PETSC_SCALAR) {
 68:     f90array1daccessscalar_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
 69:     if (*array == PETSC_NULL_SCALAR_Fortran) *array = 0;
 70:   } else if (type == PETSC_REAL) {
 71:     f90array1daccessreal_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
 72:     if (*array == PETSC_NULL_REAL_Fortran) *array = 0;
 73:   } else if (type == PETSC_INT) {
 74:     f90array1daccessint_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
 75:     if (*array == PETSC_NULL_INTEGER_Fortran) *array = 0;
 76:   } else if (type == PETSC_FORTRANADDR) {
 77:     f90array1daccessfortranaddr_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
 78:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
 79:   return(0);
 80: }

 82: PetscErrorCode  F90Array1dDestroy(F90Array1d *ptr,PetscDataType type PETSC_F90_2PTR_PROTO(ptrd))
 83: {
 85:   if (type == PETSC_SCALAR) {
 86:     f90array1ddestroyscalar_(ptr PETSC_F90_2PTR_PARAM(ptrd));
 87:   } else if (type == PETSC_REAL) {
 88:     f90array1ddestroyreal_(ptr PETSC_F90_2PTR_PARAM(ptrd));
 89:   } else if (type == PETSC_INT) {
 90:     f90array1ddestroyint_(ptr PETSC_F90_2PTR_PARAM(ptrd));
 91:   } else if (type == PETSC_FORTRANADDR) {
 92:     f90array1ddestroyfortranaddr_(ptr PETSC_F90_2PTR_PARAM(ptrd));
 93:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
 94:   return(0);
 95: }

 97: /*************************************************************************/

 99: #if defined(PETSC_HAVE_FORTRAN_CAPS)
100: #define f90array2dcreatescalar_           F90ARRAY2DCREATESCALAR
101: #define f90array2daccessscalar_           F90ARRAY2DACCESSSCALAR
102: #define f90array2ddestroyscalar_          F90ARRAY2DDESTROYSCALAR
103: #define f90array2dcreatereal_             F90ARRAY2DCREATEREAL
104: #define f90array2daccessreal_             F90ARRAY2DACCESSREAL
105: #define f90array2ddestroyreal_            F90ARRAY2DDESTROYREAL
106: #define f90array2dcreateint_              F90ARRAY2DCREATEINT
107: #define f90array2daccessint_              F90ARRAY2DACCESSINT
108: #define f90array2ddestroyint_             F90ARRAY2DDESTROYINT
109: #define f90array2dcreatefortranaddr_      F90ARRAY2DCREATEFORTRANADDR
110: #define f90array2daccessfortranaddr_      F90ARRAY2DACCESSFORTRANADDR
111: #define f90array2ddestroyfortranaddr_     F90ARRAY2DDESTROYFORTRANADDR
112: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
113: #define f90array2dcreatescalar_           f90array2dcreatescalar
114: #define f90array2daccessscalar_           f90array2daccessscalar
115: #define f90array2ddestroyscalar_          f90array2ddestroyscalar
116: #define f90array2dcreatereal_             f90array2dcreatereal
117: #define f90array2daccessreal_             f90array2daccessreal
118: #define f90array2ddestroyreal_            f90array2ddestroyreal
119: #define f90array2dcreateint_              f90array2dcreateint
120: #define f90array2daccessint_              f90array2daccessint
121: #define f90array2ddestroyint_             f90array2ddestroyint
122: #define f90array2dcreatefortranaddr_      f90array2dcreatefortranaddr
123: #define f90array2daccessfortranaddr_      f90array2daccessfortranaddr
124: #define f90array2ddestroyfortranaddr_     f90array2ddestroyfortranaddr
125: #endif

127: PETSC_EXTERN void PETSC_STDCALL f90array2dcreatescalar_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array2d * PETSC_F90_2PTR_PROTO_NOVAR);
128: PETSC_EXTERN void PETSC_STDCALL f90array2daccessscalar_(F90Array2d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
129: PETSC_EXTERN void PETSC_STDCALL f90array2ddestroyscalar_(F90Array2d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
130: PETSC_EXTERN void PETSC_STDCALL f90array2dcreatereal_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array2d * PETSC_F90_2PTR_PROTO_NOVAR);
131: PETSC_EXTERN void PETSC_STDCALL f90array2daccessreal_(F90Array2d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
132: PETSC_EXTERN void PETSC_STDCALL f90array2ddestroyreal_(F90Array2d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
133: PETSC_EXTERN void PETSC_STDCALL f90array2dcreateint_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array2d * PETSC_F90_2PTR_PROTO_NOVAR);
134: PETSC_EXTERN void PETSC_STDCALL f90array2daccessint_(F90Array2d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
135: PETSC_EXTERN void PETSC_STDCALL f90array2ddestroyint_(F90Array2d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
136: PETSC_EXTERN void PETSC_STDCALL f90array2dcreatefortranaddr_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array2d * PETSC_F90_2PTR_PROTO_NOVAR);
137: PETSC_EXTERN void PETSC_STDCALL f90array2daccessfortranaddr_(F90Array2d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
138: PETSC_EXTERN void PETSC_STDCALL f90array2ddestroyfortranaddr_(F90Array2d *ptr PETSC_F90_2PTR_PROTO_NOVAR);

140: PetscErrorCode F90Array2dCreate(void *array,PetscDataType type,PetscInt start1,PetscInt len1,PetscInt start2,PetscInt len2,F90Array2d *ptr PETSC_F90_2PTR_PROTO(ptrd))
141: {
143:   if (type == PETSC_SCALAR) {
144:     f90array2dcreatescalar_(array,&start1,&len1,&start2,&len2,ptr PETSC_F90_2PTR_PARAM(ptrd));
145:   } else if (type == PETSC_REAL) {
146:     f90array2dcreatereal_(array,&start1,&len1,&start2,&len2,ptr PETSC_F90_2PTR_PARAM(ptrd));
147:   } else if (type == PETSC_INT) {
148:     f90array2dcreateint_(array,&start1,&len1,&start2,&len2,ptr PETSC_F90_2PTR_PARAM(ptrd));
149:   } else if (type == PETSC_FORTRANADDR) {
150:     f90array2dcreatefortranaddr_(array,&start1,&len1,&start2,&len2,ptr PETSC_F90_2PTR_PARAM(ptrd));
151:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
152:   return(0);
153: }

155: PetscErrorCode  F90Array2dAccess(F90Array2d *ptr,PetscDataType type,void **array PETSC_F90_2PTR_PROTO(ptrd))
156: {
158:   if (type == PETSC_SCALAR) {
159:     f90array2daccessscalar_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
160:   } else if (type == PETSC_REAL) {
161:     f90array2daccessreal_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
162:   } else if (type == PETSC_INT) {
163:     f90array2daccessint_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
164:   } else if (type == PETSC_FORTRANADDR) {
165:     f90array2daccessfortranaddr_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
166:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
167:   return(0);
168: }

170: PetscErrorCode  F90Array2dDestroy(F90Array2d *ptr,PetscDataType type PETSC_F90_2PTR_PROTO(ptrd))
171: {
173:   if (type == PETSC_SCALAR) {
174:     f90array2ddestroyscalar_(ptr PETSC_F90_2PTR_PARAM(ptrd));
175:   } else if (type == PETSC_REAL) {
176:     f90array2ddestroyreal_(ptr PETSC_F90_2PTR_PARAM(ptrd));
177:   } else if (type == PETSC_INT) {
178:     f90array2ddestroyint_(ptr PETSC_F90_2PTR_PARAM(ptrd));
179:   } else if (type == PETSC_FORTRANADDR) {
180:     f90array2ddestroyfortranaddr_(ptr PETSC_F90_2PTR_PARAM(ptrd));
181:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
182:   return(0);
183: }

185: /*************************************************************************/

187: #if defined(PETSC_HAVE_FORTRAN_CAPS)
188: #define f90array3dcreatescalar_           F90ARRAY3DCREATESCALAR
189: #define f90array3daccessscalar_           F90ARRAY3DACCESSSCALAR
190: #define f90array3ddestroyscalar_          F90ARRAY3DDESTROYSCALAR
191: #define f90array3dcreatereal_             F90ARRAY3DCREATEREAL
192: #define f90array3daccessreal_             F90ARRAY3DACCESSREAL
193: #define f90array3ddestroyreal_            F90ARRAY3DDESTROYREAL
194: #define f90array3dcreateint_              F90ARRAY3DCREATEINT
195: #define f90array3daccessint_              F90ARRAY3DACCESSINT
196: #define f90array3ddestroyint_             F90ARRAY3DDESTROYINT
197: #define f90array3dcreatefortranaddr_      F90ARRAY3DCREATEFORTRANADDR
198: #define f90array3daccessfortranaddr_      F90ARRAY3DACCESSFORTRANADDR
199: #define f90array3ddestroyfortranaddr_     F90ARRAY3DDESTROYFORTRANADDR
200: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
201: #define f90array3dcreatescalar_           f90array3dcreatescalar
202: #define f90array3daccessscalar_           f90array3daccessscalar
203: #define f90array3ddestroyscalar_          f90array3ddestroyscalar
204: #define f90array3dcreatereal_             f90array3dcreatereal
205: #define f90array3daccessreal_             f90array3daccessreal
206: #define f90array3ddestroyreal_            f90array3ddestroyreal
207: #define f90array3dcreateint_              f90array3dcreateint
208: #define f90array3daccessint_              f90array3daccessint
209: #define f90array3ddestroyint_             f90array3ddestroyint
210: #define f90array3dcreatefortranaddr_      f90array3dcreatefortranaddr
211: #define f90array3daccessfortranaddr_      f90array3daccessfortranaddr
212: #define f90array3ddestroyfortranaddr_     f90array3ddestroyfortranaddr
213: #endif

215: PETSC_EXTERN void PETSC_STDCALL f90array3dcreatescalar_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array3d * PETSC_F90_2PTR_PROTO_NOVAR);
216: PETSC_EXTERN void PETSC_STDCALL f90array3daccessscalar_(F90Array3d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
217: PETSC_EXTERN void PETSC_STDCALL f90array3ddestroyscalar_(F90Array3d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
218: PETSC_EXTERN void PETSC_STDCALL f90array3dcreatereal_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array3d * PETSC_F90_2PTR_PROTO_NOVAR);
219: PETSC_EXTERN void PETSC_STDCALL f90array3daccessreal_(F90Array3d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
220: PETSC_EXTERN void PETSC_STDCALL f90array3ddestroyreal_(F90Array3d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
221: PETSC_EXTERN void PETSC_STDCALL f90array3dcreateint_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array3d * PETSC_F90_2PTR_PROTO_NOVAR);
222: PETSC_EXTERN void PETSC_STDCALL f90array3daccessint_(F90Array3d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
223: PETSC_EXTERN void PETSC_STDCALL f90array3ddestroyint_(F90Array3d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
224: PETSC_EXTERN void PETSC_STDCALL f90array3dcreatefortranaddr_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,F90Array3d * PETSC_F90_2PTR_PROTO_NOVAR);
225: PETSC_EXTERN void PETSC_STDCALL f90array3daccessfortranaddr_(F90Array3d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
226: PETSC_EXTERN void PETSC_STDCALL f90array3ddestroyfortranaddr_(F90Array3d *ptr PETSC_F90_2PTR_PROTO_NOVAR);

228: PetscErrorCode F90Array3dCreate(void *array,PetscDataType type,PetscInt start1,PetscInt len1,PetscInt start2,PetscInt len2,PetscInt start3,PetscInt len3,F90Array3d *ptr PETSC_F90_2PTR_PROTO(ptrd))
229: {
231:   if (type == PETSC_SCALAR) {
232:     f90array3dcreatescalar_(array,&start1,&len1,&start2,&len2,&start3,&len3,ptr PETSC_F90_2PTR_PARAM(ptrd));
233:   } else if (type == PETSC_REAL) {
234:     f90array3dcreatereal_(array,&start1,&len1,&start2,&len2,&start3,&len3,ptr PETSC_F90_2PTR_PARAM(ptrd));
235:   } else if (type == PETSC_INT) {
236:     f90array3dcreateint_(array,&start1,&len1,&start2,&len2,&start3,&len3,ptr PETSC_F90_2PTR_PARAM(ptrd));
237:   } else if (type == PETSC_FORTRANADDR) {
238:     f90array3dcreatefortranaddr_(array,&start1,&len1,&start2,&len2,&start3,&len3,ptr PETSC_F90_2PTR_PARAM(ptrd));
239:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
240:   return(0);
241: }

243: PetscErrorCode  F90Array3dAccess(F90Array3d *ptr,PetscDataType type,void **array PETSC_F90_2PTR_PROTO(ptrd))
244: {
246:   if (type == PETSC_SCALAR) {
247:     f90array3daccessscalar_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
248:   } else if (type == PETSC_REAL) {
249:     f90array3daccessreal_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
250:   } else if (type == PETSC_INT) {
251:     f90array3daccessint_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
252:   } else if (type == PETSC_FORTRANADDR) {
253:     f90array3daccessfortranaddr_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
254:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
255:   return(0);
256: }

258: PetscErrorCode  F90Array3dDestroy(F90Array3d *ptr,PetscDataType type PETSC_F90_2PTR_PROTO(ptrd))
259: {
261:   if (type == PETSC_SCALAR) {
262:     f90array3ddestroyscalar_(ptr PETSC_F90_2PTR_PARAM(ptrd));
263:   } else if (type == PETSC_REAL) {
264:     f90array3ddestroyreal_(ptr PETSC_F90_2PTR_PARAM(ptrd));
265:   } else if (type == PETSC_INT) {
266:     f90array3ddestroyint_(ptr PETSC_F90_2PTR_PARAM(ptrd));
267:   } else if (type == PETSC_FORTRANADDR) {
268:     f90array3ddestroyfortranaddr_(ptr PETSC_F90_2PTR_PARAM(ptrd));
269:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
270:   return(0);
271: }

273: /*************************************************************************/
274: #if defined(PETSC_HAVE_FORTRAN_CAPS)
275: #define f90array4dcreatescalar_           F90ARRAY4DCREATESCALAR
276: #define f90array4daccessscalar_           F90ARRAY4DACCESSSCALAR
277: #define f90array4ddestroyscalar_          F90ARRAY4DDESTROYSCALAR
278: #define f90array4dcreatereal_             F90ARRAY4DCREATEREAL
279: #define f90array4daccessreal_             F90ARRAY4DACCESSREAL
280: #define f90array4ddestroyreal_            F90ARRAY4DDESTROYREAL
281: #define f90array4dcreateint_              F90ARRAY4DCREATEINT
282: #define f90array4daccessint_              F90ARRAY4DACCESSINT
283: #define f90array4ddestroyint_             F90ARRAY4DDESTROYINT
284: #define f90array4dcreatefortranaddr_      F90ARRAY4DCREATEFORTRANADDR
285: #define f90array4daccessfortranaddr_      F90ARRAY4DACCESSFORTRANADDR
286: #define f90array4ddestroyfortranaddr_     F90ARRAY4DDESTROYFORTRANADDR
287: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
288: #define f90array4dcreatescalar_           f90array4dcreatescalar
289: #define f90array4daccessscalar_           f90array4daccessscalar
290: #define f90array4ddestroyscalar_          f90array4ddestroyscalar
291: #define f90array4dcreatereal_             f90array4dcreatereal
292: #define f90array4daccessreal_             f90array4daccessreal
293: #define f90array4ddestroyreal_            f90array4ddestroyreal
294: #define f90array4dcreateint_              f90array4dcreateint
295: #define f90array4daccessint_              f90array4daccessint
296: #define f90array4ddestroyint_             f90array4ddestroyint
297: #define f90array4dcreatefortranaddr_      f90array4dcreatefortranaddr
298: #define f90array4daccessfortranaddr_      f90array4daccessfortranaddr
299: #define f90array4ddestroyfortranaddr_     f90array4ddestroyfortranaddr
300: #endif

302: PETSC_EXTERN void PETSC_STDCALL f90array4dcreatescalar_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt*,PetscInt*,F90Array4d * PETSC_F90_2PTR_PROTO_NOVAR);
303: PETSC_EXTERN void PETSC_STDCALL f90array4daccessscalar_(F90Array4d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
304: PETSC_EXTERN void PETSC_STDCALL f90array4ddestroyscalar_(F90Array4d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
305: PETSC_EXTERN void PETSC_STDCALL f90array4dcreatereal_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt*,PetscInt*,F90Array4d * PETSC_F90_2PTR_PROTO_NOVAR);
306: PETSC_EXTERN void PETSC_STDCALL f90array4daccessreal_(F90Array4d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
307: PETSC_EXTERN void PETSC_STDCALL f90array4ddestroyreal_(F90Array4d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
308: PETSC_EXTERN void PETSC_STDCALL f90array4dcreateint_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt*,PetscInt*,F90Array4d * PETSC_F90_2PTR_PROTO_NOVAR);
309: PETSC_EXTERN void PETSC_STDCALL f90array4daccessint_(F90Array4d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
310: PETSC_EXTERN void PETSC_STDCALL f90array4ddestroyint_(F90Array4d *ptr PETSC_F90_2PTR_PROTO_NOVAR);
311: PETSC_EXTERN void PETSC_STDCALL f90array4dcreatefortranaddr_(void *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt *,PetscInt*,PetscInt*,F90Array4d * PETSC_F90_2PTR_PROTO_NOVAR);
312: PETSC_EXTERN void PETSC_STDCALL f90array4daccessfortranaddr_(F90Array4d*,void** PETSC_F90_2PTR_PROTO_NOVAR);
313: PETSC_EXTERN void PETSC_STDCALL f90array4ddestroyfortranaddr_(F90Array4d *ptr PETSC_F90_2PTR_PROTO_NOVAR);

315: PetscErrorCode F90Array4dCreate(void *array,PetscDataType type,PetscInt start1,PetscInt len1,PetscInt start2,PetscInt len2,PetscInt start3,PetscInt len3,PetscInt start4,PetscInt len4,F90Array4d *ptr PETSC_F90_2PTR_PROTO(ptrd))
316: {
318:   if (type == PETSC_SCALAR) {
319:     f90array4dcreatescalar_(array,&start1,&len1,&start2,&len2,&start3,&len3,&start4,&len4,ptr PETSC_F90_2PTR_PARAM(ptrd));
320:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
321:   return(0);
322: }

324: PetscErrorCode  F90Array4dAccess(F90Array4d *ptr,PetscDataType type,void **array PETSC_F90_2PTR_PROTO(ptrd))
325: {
327:   if (type == PETSC_SCALAR) {
328:     f90array4daccessscalar_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
329:   } else if (type == PETSC_REAL) {
330:     f90array4daccessreal_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
331:   } else if (type == PETSC_INT) {
332:     f90array4daccessint_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
333:   } else if (type == PETSC_FORTRANADDR) {
334:     f90array4daccessfortranaddr_(ptr,array PETSC_F90_2PTR_PARAM(ptrd));
335:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
336:   return(0);
337: }

339: PetscErrorCode  F90Array4dDestroy(F90Array4d *ptr,PetscDataType type PETSC_F90_2PTR_PROTO(ptrd))
340: {
342:   if (type == PETSC_SCALAR) {
343:     f90array4ddestroyscalar_(ptr PETSC_F90_2PTR_PARAM(ptrd));
344:   } else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"unsupported PetscDataType: %d",(PetscInt)type);
345:   return(0);
346: }

348: /*************************************************************************/
349: #if defined(PETSC_HAVE_FORTRAN_CAPS)
350: #define f90array1dgetaddrscalar_            F90ARRAY1DGETADDRSCALAR
351: #define f90array1dgetaddrreal_              F90ARRAY1DGETADDRREAL
352: #define f90array1dgetaddrint_               F90ARRAY1DGETADDRINT
353: #define f90array1dgetaddrfortranaddr_       F90ARRAY1DGETADDRFORTRANADDR
354: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
355: #define f90array1dgetaddrscalar_            f90array1dgetaddrscalar
356: #define f90array1dgetaddrreal_              f90array1dgetaddrreal
357: #define f90array1dgetaddrint_               f90array1dgetaddrint
358: #define f90array1dgetaddrfortranaddr_       f90array1dgetaddrfortranaddr
359: #endif

361: PETSC_EXTERN void PETSC_STDCALL f90array1dgetaddrscalar_(void *array, PetscFortranAddr *address)
362: {
363:   *address = (PetscFortranAddr)array;
364: }
365: PETSC_EXTERN void PETSC_STDCALL f90array1dgetaddrreal_(void *array, PetscFortranAddr *address)
366: {
367:   *address = (PetscFortranAddr)array;
368: }
369: PETSC_EXTERN void PETSC_STDCALL f90array1dgetaddrint_(void *array, PetscFortranAddr *address)
370: {
371:   *address = (PetscFortranAddr)array;
372: }
373: PETSC_EXTERN void PETSC_STDCALL f90array1dgetaddrfortranaddr_(void *array, PetscFortranAddr *address)
374: {
375:   *address = (PetscFortranAddr)array;
376: }

378: /*************************************************************************/
379: #if defined(PETSC_HAVE_FORTRAN_CAPS)
380: #define f90array2dgetaddrscalar_            F90ARRAY2DGETADDRSCALAR
381: #define f90array2dgetaddrreal_              F90ARRAY2DGETADDRREAL
382: #define f90array2dgetaddrint_               F90ARRAY2DGETADDRINT
383: #define f90array2dgetaddrfortranaddr_       F90ARRAY2DGETADDRFORTRANADDR
384: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
385: #define f90array2dgetaddrscalar_            f90array2dgetaddrscalar
386: #define f90array2dgetaddrreal_              f90array2dgetaddrreal
387: #define f90array2dgetaddrint_               f90array2dgetaddrint
388: #define f90array2dgetaddrfortranaddr_       f90array2dgetaddrfortranaddr
389: #endif

391: PETSC_EXTERN void PETSC_STDCALL f90array2dgetaddrscalar_(void *array, PetscFortranAddr *address)
392: {
393:   *address = (PetscFortranAddr)array;
394: }
395: PETSC_EXTERN void PETSC_STDCALL f90array2dgetaddrreal_(void *array, PetscFortranAddr *address)
396: {
397:   *address = (PetscFortranAddr)array;
398: }
399: PETSC_EXTERN void PETSC_STDCALL f90array2dgetaddrint_(void *array, PetscFortranAddr *address)
400: {
401:   *address = (PetscFortranAddr)array;
402: }
403: PETSC_EXTERN void PETSC_STDCALL f90array2dgetaddrfortranaddr_(void *array, PetscFortranAddr *address)
404: {
405:   *address = (PetscFortranAddr)array;
406: }

408: /*************************************************************************/
409: #if defined(PETSC_HAVE_FORTRAN_CAPS)
410: #define f90array3dgetaddrscalar_            F90ARRAY3DGETADDRSCALAR
411: #define f90array3dgetaddrreal_              F90ARRAY3DGETADDRREAL
412: #define f90array3dgetaddrint_               F90ARRAY3DGETADDRINT
413: #define f90array3dgetaddrfortranaddr_       F90ARRAY3DGETADDRFORTRANADDR
414: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
415: #define f90array3dgetaddrscalar_            f90array3dgetaddrscalar
416: #define f90array3dgetaddrreal_              f90array3dgetaddrreal
417: #define f90array3dgetaddrint_               f90array3dgetaddrint
418: #define f90array3dgetaddrfortranaddr_       f90array3dgetaddrfortranaddr
419: #endif

421: PETSC_EXTERN void PETSC_STDCALL f90array3dgetaddrscalar_(void *array, PetscFortranAddr *address)
422: {
423:   *address = (PetscFortranAddr)array;
424: }
425: PETSC_EXTERN void PETSC_STDCALL f90array3dgetaddrreal_(void *array, PetscFortranAddr *address)
426: {
427:   *address = (PetscFortranAddr)array;
428: }
429: PETSC_EXTERN void PETSC_STDCALL f90array3dgetaddrint_(void *array, PetscFortranAddr *address)
430: {
431:   *address = (PetscFortranAddr)array;
432: }
433: PETSC_EXTERN void PETSC_STDCALL f90array3dgetaddrfortranaddr_(void *array, PetscFortranAddr *address)
434: {
435:   *address = (PetscFortranAddr)array;
436: }

438: /*************************************************************************/
439: #if defined(PETSC_HAVE_FORTRAN_CAPS)
440: #define f90array4dgetaddrscalar_            F90ARRAY4DGETADDRSCALAR
441: #define f90array4dgetaddrreal_              F90ARRAY4DGETADDRREAL
442: #define f90array4dgetaddrint_               F90ARRAY4DGETADDRINT
443: #define f90array4dgetaddrfortranaddr_       F90ARRAY4DGETADDRFORTRANADDR
444: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
445: #define f90array4dgetaddrscalar_            f90array4dgetaddrscalar
446: #define f90array4dgetaddrreal_              f90array4dgetaddrreal
447: #define f90array4dgetaddrint_               f90array4dgetaddrint
448: #define f90array4dgetaddrfortranaddr_       f90array4dgetaddrfortranaddr
449: #endif

451: PETSC_EXTERN void PETSC_STDCALL f90array4dgetaddrscalar_(void *array, PetscFortranAddr *address)
452: {
453:   *address = (PetscFortranAddr)array;
454: }
455: PETSC_EXTERN void PETSC_STDCALL f90array4dgetaddrreal_(void *array, PetscFortranAddr *address)
456: {
457:   *address = (PetscFortranAddr)array;
458: }
459: PETSC_EXTERN void PETSC_STDCALL f90array4dgetaddrint_(void *array, PetscFortranAddr *address)
460: {
461:   *address = (PetscFortranAddr)array;
462: }
463: PETSC_EXTERN void PETSC_STDCALL f90array4dgetaddrfortranaddr_(void *array, PetscFortranAddr *address)
464: {
465:   *address = (PetscFortranAddr)array;
466: }