Skip to content

Instantly share code, notes, and snippets.

@jsquyres

jsquyres/mpi31-r1835-chap-appLang.diff

Last active August 29, 2015 14:14
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save jsquyres/0c4fd1de830ec33edc42 to your computer and use it in GitHub Desktop.
Save jsquyres/0c4fd1de830ec33edc42 to your computer and use it in GitHub Desktop.
Download ZIP
MPI 3.1 r1835
Raw
mpi31-r1835-chap-appLang.diff
Index: chap-appLang/appLang-Const.tex
===================================================================
--- chap-appLang/appLang-Const.tex (revision 1834)
+++ chap-appLang/appLang-Const.tex (revision 1835)
@@ -1159,7 +1159,7 @@
The user-function argument to \ffunc{MPI\_Op\_create}\mpifuncindex{MPI\_OP\_CREATE} should be declared
according to:
-\mpifnewsubbind{MPI\_User\_function(invec, inoutvec, len, datatype) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: invec, inoutvec \\ INTEGER :: len \\ TYPE(MPI\_Datatype) :: datatype}
+\mpifnewsubbind{MPI\_User\_function(invec, inoutvec, len, datatype) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: invec, inoutvec \\ INTEGER :: len \\ TYPE(MPI\_Datatype) :: datatype}
%
The copy and delete function arguments to \ffunc{MPI\_Comm\_create\_keyval}\mpifuncindex{MPI\_COMM\_CREATE\_KEYVAL} should be
@@ -1166,8 +1166,8 @@
declared according to:
%
-\mpifnewsubbind{MPI\_Comm\_copy\_attr\_function(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Comm) :: oldcomm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
-\mpifnewsubbind{MPI\_Comm\_delete\_attr\_function(comm, comm\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
+\mpifnewsubbind{MPI\_Comm\_copy\_attr\_function(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Comm) :: oldcomm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
+\mpifnewsubbind{MPI\_Comm\_delete\_attr\_function(comm, comm\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
%
The copy and delete function arguments to \ffunc{MPI\_Win\_create\_keyval}\mpifuncindex{MPI\_WIN\_CREATE\_KEYVAL} should be
@@ -1174,8 +1174,8 @@
declared according to:
%
-\mpifnewsubbind{MPI\_Win\_copy\_attr\_function(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Win) :: oldwin \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
-\mpifnewsubbind{MPI\_Win\_delete\_attr\_function(win, win\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
+\mpifnewsubbind{MPI\_Win\_copy\_attr\_function(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Win) :: oldwin \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
+\mpifnewsubbind{MPI\_Win\_delete\_attr\_function(win, win\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
%
The copy and delete function arguments to \ffunc{MPI\_Type\_create\_keyval}\mpifuncindex{MPI\_TYPE\_CREATE\_KEYVAL} should be
@@ -1182,8 +1182,8 @@
declared according to:
%
-\mpifnewsubbind{MPI\_Type\_copy\_attr\_function(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Datatype) :: oldtype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
-\mpifnewsubbind{MPI\_Type\_delete\_attr\_function(datatype, type\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
+\mpifnewsubbind{MPI\_Type\_copy\_attr\_function(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Datatype) :: oldtype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
+\mpifnewsubbind{MPI\_Type\_delete\_attr\_function(datatype, type\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
%
The handler-function argument to \ffunc{MPI\_Comm\_create\_errhandler}\mpifuncindex{MPI\_COMM\_CREATE\_ERRHANDLER}
@@ -1190,7 +1190,7 @@
should be declared like this:
%
-\mpifnewsubbind{MPI\_Comm\_errhandler\_function(comm, error\_code) BIND(C) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: error\_code }
+\mpifnewsubbind{MPI\_Comm\_errhandler\_function(comm, error\_code) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: error\_code }
%
The handler-function argument to \ffunc{MPI\_Win\_create\_errhandler}\mpifuncindex{MPI\_WIN\_CREATE\_ERRHANDLER}
@@ -1197,7 +1197,7 @@
should be declared like this:
%
-\mpifnewsubbind{MPI\_Win\_errhandler\_function(win, error\_code) BIND(C) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: error\_code }
+\mpifnewsubbind{MPI\_Win\_errhandler\_function(win, error\_code) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: error\_code }
%
The handler-function argument to \ffunc{MPI\_File\_create\_errhandler}\mpifuncindex{MPI\_FILE\_CREATE\_ERRHANDLER}
@@ -1204,7 +1204,7 @@
should be declared like this:
%
-\mpifnewsubbind{MPI\_File\_errhandler\_function(file, error\_code) BIND(C) \fargs TYPE(MPI\_File) :: file \\ INTEGER :: error\_code }
+\mpifnewsubbind{MPI\_File\_errhandler\_function(file, error\_code) \fargs TYPE(MPI\_File) :: file \\ INTEGER :: error\_code }
%
The query, free, and cancel function arguments to \ffunc{MPI\_Grequest\_start}\mpifuncindex{MPI\_GREQUEST\_START}
@@ -1211,9 +1211,9 @@
should be declared according to:
%
-\mpifnewsubbind{MPI\_Grequest\_query\_function(extra\_state, status, ierror) BIND(C) \fargs TYPE(MPI\_Status) :: status \\ INTEGER :: ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state }
-\mpifnewsubbind{MPI\_Grequest\_free\_function(extra\_state, ierror) BIND(C) \fargs INTEGER :: ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state }
-\mpifnewsubbind{MPI\_Grequest\_cancel\_function(extra\_state, complete, ierror) BIND(C) \fargs INTEGER :: ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ LOGICAL :: complete }
+\mpifnewsubbind{MPI\_Grequest\_query\_function(extra\_state, status, ierror) \fargs TYPE(MPI\_Status) :: status \\ INTEGER :: ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state }
+\mpifnewsubbind{MPI\_Grequest\_free\_function(extra\_state, ierror) \fargs INTEGER :: ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state }
+\mpifnewsubbind{MPI\_Grequest\_cancel\_function(extra\_state, complete, ierror) \fargs INTEGER :: ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ LOGICAL :: complete }
%
The extent and conversion function arguments to \ffunc{MPI\_Register\_datarep}\mpifuncindex{MPI\_REGISTER\_DATAREP}
@@ -1220,9 +1220,9 @@
should be declared according to:
%
-\mpifnewsubbind{MPI\_Datarep\_extent\_function(datatype, extent, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extent, extra\_state \\ INTEGER :: ierror }
+\mpifnewsubbind{MPI\_Datarep\_extent\_function(datatype, extent, extra\_state, ierror) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extent, extra\_state \\ INTEGER :: ierror }
-\mpifnewsubbind{MPI\_Datarep\_conversion\_function(userbuf, datatype, count, filebuf, position, extra\_state, ierror) BIND(C)\fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: userbuf, filebuf \\ TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: count, ierror \\ INTEGER(KIND=MPI\_OFFSET\_KIND) :: position \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state}
+\mpifnewsubbind{MPI\_Datarep\_conversion\_function(userbuf, datatype, count, filebuf, position, extra\_state, ierror)\fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: userbuf, filebuf \\ TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: count, ierror \\ INTEGER(KIND=MPI\_OFFSET\_KIND) :: position \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state}
\subsubsection{Fortran Bindings with mpif.h or the mpi Module}
Raw
mpi31-r1835-chap-binding.diff
Index: chap-binding/binding-2.tex
===================================================================
--- chap-binding/binding-2.tex (revision 1834)
+++ chap-binding/binding-2.tex (revision 1835)
@@ -648,7 +648,7 @@
With the Fortran \code{mpi} module or \code{mpif.h} include file,
if \const{MPI\_SUBARRAYS\_SUPPORTED} equals \ftype{.TRUE.}:
- The Fortran binding must use BIND(C) interfaces with
+ The Fortran binding must use interfaces with
an interface name identical to the language independent name,
e.g., \mpifunc{MPI\_SEND}.
The linker name is a combination of the C name and an
@@ -1316,7 +1316,7 @@
\begin{funcdef}{MPI\_F\_SYNC\_REG(buf)}
\funcarg{\INOUT}{buf}{initial address of buffer (choice)}
\end{funcdef}
-\mpifnewbind{MPI\_F\_sync\_reg(buf) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf}
+\mpifnewbind{MPI\_F\_sync\_reg(buf) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf}
\mpifbind{MPI\_F\_SYNC\_REG(buf)\fargs <type> buf(*)}
This routine has no executable statements. It must be compiled in the \MPI/ library
@@ -1471,7 +1471,7 @@
\funcarg{\OUT}{newtype}{the requested \MPI/ datatype (handle)}
\end{funcdef}
\mpibind{MPI\_Type\_create\_f90\_real(int~p, int~r, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_create\_f90\_real(p, r, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: p, r \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_f90\_real(p, r, newtype, ierror) \fargs INTEGER, INTENT(IN) :: p, r \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_F90\_REAL(P, R, NEWTYPE, IERROR)\fargs INTEGER P, R, NEWTYPE, IERROR}
This function returns a predefined \MPI/ datatype that matches a \ftype{REAL} variable
@@ -1500,7 +1500,7 @@
\end{funcdef}
\mpibind{MPI\_Type\_create\_f90\_complex(int~p, int~r, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_create\_f90\_complex(p, r, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: p, r \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_f90\_complex(p, r, newtype, ierror) \fargs INTEGER, INTENT(IN) :: p, r \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_F90\_COMPLEX(P, R, NEWTYPE, IERROR)\fargs INTEGER P, R, NEWTYPE, IERROR}
This function returns a predefined \MPI/ datatype that matches a \ftype{COMPLEX} variable
@@ -1523,7 +1523,7 @@
\funcarg{\OUT}{newtype}{the requested \MPI/ datatype (handle)}
\end{funcdef}
\mpibind{MPI\_Type\_create\_f90\_integer(int~r, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_create\_f90\_integer(r, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: r \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_f90\_integer(r, newtype, ierror) \fargs INTEGER, INTENT(IN) :: r \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_F90\_INTEGER(R, NEWTYPE, IERROR)\fargs INTEGER R, NEWTYPE, IERROR}
This function returns a predefined \MPI/ datatype that matches a \ftype{INTEGER} variable
@@ -1731,7 +1731,7 @@
\funcarg{\OUT}{size}{size of machine representation of that type (integer)}
\end{funcdef}
-\mpifnewbind{MPI\_Sizeof(x, size, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..) :: x \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Sizeof(x, size, ierror) \fargs TYPE(*), DIMENSION(..) :: x \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SIZEOF(X, SIZE, IERROR) \fargs <type> X\\INTEGER SIZE, IERROR }
This function returns the size in bytes of the machine representation of
@@ -1757,7 +1757,7 @@
\end{funcdef}
\mpibind{MPI\_Type\_match\_size(int~typeclass, int~size, MPI\_Datatype~*datatype)}
-\mpifnewbind{MPI\_Type\_match\_size(typeclass, size, datatype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: typeclass, size \\ TYPE(MPI\_Datatype), INTENT(OUT) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_match\_size(typeclass, size, datatype, ierror) \fargs INTEGER, INTENT(IN) :: typeclass, size \\ TYPE(MPI\_Datatype), INTENT(OUT) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_MATCH\_SIZE(TYPECLASS, SIZE, DATATYPE, IERROR) \fargs INTEGER TYPECLASS, SIZE, DATATYPE, IERROR}
\mpiarg{typeclass} is one of \const{MPI\_TYPECLASS\_REAL},
@@ -2340,7 +2340,7 @@
%%SUBST:\.\.\.:1,1,ierr
%%ENDHEADER
\begin{verbatim}
- type, BIND(C) :: mytype
+ type, :: mytype
integer :: i
real :: x
double precision :: d
@@ -3772,7 +3772,7 @@
\funcarg{\OUT}{f08\_status}{status object declared as named type}
\end{funcdef}
\mpibind{MPI\_Status\_f2f08(MPI\_Fint~*f\_status, MPI\_F08\_status *f08\_status)}
-\mpifnewbind{MPI\_Status\_f2f08(f\_status, f08\_status, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: f\_status(MPI\_STATUS\_SIZE) \\ TYPE(MPI\_Status), INTENT(OUT) :: f08\_status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror }
+\mpifnewbind{MPI\_Status\_f2f08(f\_status, f08\_status, ierror) \fargs INTEGER, INTENT(IN) :: f\_status(MPI\_STATUS\_SIZE) \\ TYPE(MPI\_Status), INTENT(OUT) :: f08\_status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror }
\mpifbind{MPI\_STATUS\_F2F08(F\_STATUS, F08\_STATUS, IERROR)\fargs INTEGER :: F\_STATUS(MPI\_STATUS\_SIZE) \\ TYPE(MPI\_Status) :: F08\_STATUS \\ INTEGER IERROR}
This routine converts a Fortran \ftype{INTEGER}, \ftype{DIMENSION(MPI\_STATUS\_SIZE)} status array
@@ -3783,7 +3783,7 @@
\funcarg{\OUT}{f\_status}{status object declared as array}
\end{funcdef}
\mpibind{MPI\_Status\_f082f(MPI\_F08\_status *f08\_status, MPI\_Fint~*f\_status)}
-\mpifnewbind{MPI\_Status\_f082f(f08\_status, f\_status, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(IN) :: f08\_status \\ INTEGER, INTENT(OUT) :: f\_status(MPI\_STATUS\_SIZE) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Status\_f082f(f08\_status, f\_status, ierror) \fargs TYPE(MPI\_Status), INTENT(IN) :: f08\_status \\ INTEGER, INTENT(OUT) :: f\_status(MPI\_STATUS\_SIZE) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_STATUS\_F082F(F08\_STATUS, F\_STATUS, IERROR)\fargs TYPE(MPI\_Status) :: F08\_STATUS \\ INTEGER :: F\_STATUS(MPI\_STATUS\_SIZE) \\ INTEGER IERROR}
This routine converts a Fortran \code{mpi\_f08} \ftype{TYPE(MPI\_Status)}\cdeclindex{MPI\_Status}
Raw
mpi31-r1835-chap-coll.diff
Index: chap-coll/coll.tex
===================================================================
--- chap-coll/coll.tex (revision 1834)
+++ chap-coll/coll.tex (revision 1835)
@@ -400,7 +400,7 @@
\mpibind{MPI\_Barrier(MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Barrier(comm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Barrier(comm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_BARRIER(COMM, IERROR) \fargs INTEGER COMM, IERROR}
\mpicppemptybind{MPI::Comm::Barrier() const~=~0}{void}
@@ -432,7 +432,7 @@
\mpibind{MPI\_Bcast(void*~buffer, int~count, MPI\_Datatype~datatype, int~root, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Bcast(buffer, count, datatype, root, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..) :: buffer \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Bcast(buffer, count, datatype, root, comm, ierror) \fargs TYPE(*), DIMENSION(..) :: buffer \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_BCAST(BUFFER, COUNT, DATATYPE, ROOT, COMM, IERROR) \fargs <type> BUFFER(*) \\ INTEGER COUNT, DATATYPE, ROOT, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Bcast(void*~buffer, int~count, const~MPI::Datatype\&~datatype, int~root) const~=~0}{void}
@@ -525,7 +525,7 @@
\mpibind{MPI\_Gather(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm) }
-\mpifnewbind{MPI\_Gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Gather(const void*~sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, void*~recvbuf, int~recvcount, const~MPI::Datatype\&~recvtype, int~root) const~=~0}{void}
@@ -630,7 +630,7 @@
\mpibind{MPI\_Gatherv(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, const int~recvcounts[], const int~displs[], MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm) }
-\mpifnewbind{MPI\_Gatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcounts(*), displs(*), root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Gatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcounts(*), displs(*), root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GATHERV(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNTS, DISPLS, RECVTYPE, ROOT, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNTS(*), DISPLS(*), RECVTYPE, ROOT, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Gatherv(const void*~sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, void*~recvbuf, const~int~recvcounts[], const~int~displs[], const~MPI::Datatype\&~recvtype, int~root) const~=~0}{void}
@@ -1140,7 +1140,7 @@
\mpibind{MPI\_Scatter(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SCATTER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Scatter(const void*~sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, void*~recvbuf, int~recvcount, const~MPI::Datatype\&~recvtype, int~root) const~=~0}{void}
@@ -1243,7 +1243,7 @@
\mpibind{MPI\_Scatterv(const void*~sendbuf, const int~sendcounts[], const int~displs[], MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), displs(*), recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), displs(*), recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SCATTERV(SENDBUF, SENDCOUNTS, DISPLS, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNTS(*), DISPLS(*), SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Scatterv(const void*~sendbuf, const~int~sendcounts[], const~int~displs[], const~MPI::Datatype\&~sendtype, void*~recvbuf, int~recvcount, const~MPI::Datatype\&~recvtype, int~root) const~=~0}{void}
@@ -1475,7 +1475,7 @@
\mpibind{MPI\_Allgather(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ALLGATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Allgather(const void*~sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, void*~recvbuf, int~recvcount, const~MPI::Datatype\&~recvtype) const~=~0}{void}
@@ -1563,7 +1563,7 @@
\mpibind{MPI\_Allgatherv(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, const int~recvcounts[], const int~displs[], MPI\_Datatype~recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ALLGATHERV(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNTS, DISPLS, RECVTYPE, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNTS(*), DISPLS(*), RECVTYPE, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Allgatherv(const void*~sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, void*~recvbuf, const~int~recvcounts[], const~int~displs[], const~MPI::Datatype\&~recvtype) const~=~0}{void}
@@ -1664,7 +1664,7 @@
\mpibind{MPI\_Alltoall(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Alltoall(const void*~sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, void*~recvbuf, int~recvcount, const~MPI::Datatype\&~recvtype) const~=~0}{void}
@@ -1765,7 +1765,7 @@
\mpibind{MPI\_Alltoallv(const void*~sendbuf, const int~sendcounts[], const int~sdispls[], MPI\_Datatype~sendtype, void*~recvbuf, const int~recvcounts[], const int~rdispls[], MPI\_Datatype~recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Alltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Alltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ALLTOALLV(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPE, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPE, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPE, RECVCOUNTS(*), RDISPLS(*), RECVTYPE, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Alltoallv(const void*~sendbuf, const~int~sendcounts[], const~int~sdispls[], const~MPI::Datatype\&~sendtype, void*~recvbuf, const~int~recvcounts[], const~int~rdispls[], const~MPI::Datatype\&~recvtype) const~=~0}{void}
@@ -1876,7 +1876,7 @@
\mpibind{MPI\_Alltoallw(const void*~sendbuf, const int~sendcounts[], const int~sdispls[], const MPI\_Datatype~sendtypes[], void*~recvbuf, const int~recvcounts[], const int~rdispls[], const MPI\_Datatype~recvtypes[], MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtypes(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtypes(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ALLTOALLW(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPES, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPES, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPES(*), RECVCOUNTS(*), RDISPLS(*), RECVTYPES(*), COMM, IERROR}
\mpicppemptybind{MPI::Comm::Alltoallw(const void* sendbuf, const int sendcounts[], const int sdispls[], const MPI::Datatype sendtypes[], void* recvbuf, const int recvcounts[], const int rdispls[], const MPI::Datatype recvtypes[]) const~=~0}{void}
@@ -1978,7 +1978,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Reduce(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, int~root, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_REDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, ROOT, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER COUNT, DATATYPE, OP, ROOT, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Reduce(const void*~sendbuf, void*~recvbuf, int~count, const~MPI::Datatype\&~datatype, const~MPI::Op\&~op, int~root) const~=~0}{void}
@@ -2597,7 +2597,7 @@
\cdeclmainindex{MPI\_Op}%
\mpibind{MPI\_Op\_create(MPI\_User\_function*~user\_fn, int~commute, MPI\_Op*~op)}
-\mpifnewbind{MPI\_Op\_create(user\_fn, commute, op, ierror) BIND(C) \fargs PROCEDURE(MPI\_User\_function) :: user\_fn \\ LOGICAL, INTENT(IN) :: commute \\ TYPE(MPI\_Op), INTENT(OUT) :: op \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Op\_create(user\_fn, commute, op, ierror) \fargs PROCEDURE(MPI\_User\_function) :: user\_fn \\ LOGICAL, INTENT(IN) :: commute \\ TYPE(MPI\_Op), INTENT(OUT) :: op \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_OP\_CREATE( USER\_FN, COMMUTE, OP, IERROR) \fargs EXTERNAL USER\_FN\\ LOGICAL COMMUTE \\ INTEGER OP, IERROR}
\mpicppemptybind{MPI::Op::Init(MPI::User\_function*~user\_fn, bool~commute)}{void}
@@ -2630,7 +2630,7 @@
The Fortran declarations of the user-defined function \mpiarg{user\_fn} appear
below.
-\mpifnewsubbind{MPI\_User\_function(invec, inoutvec, len, datatype) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: invec, inoutvec \\ INTEGER :: len \\ TYPE(MPI\_Datatype) :: datatype}
+\mpifnewsubbind{MPI\_User\_function(invec, inoutvec, len, datatype) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: invec, inoutvec \\ INTEGER :: len \\ TYPE(MPI\_Datatype) :: datatype}
\mpifsubbind{USER\_FUNCTION(INVEC, INOUTVEC, LEN, DATATYPE) \fargs <type> INVEC(LEN), INOUTVEC(LEN) \\ INTEGER LEN, DATATYPE}
The \mpiarg{datatype} argument
@@ -2778,7 +2778,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Op\_free(MPI\_Op~*op)}
-\mpifnewbind{MPI\_Op\_free(op, ierror) BIND(C) \fargs TYPE(MPI\_Op), INTENT(INOUT) :: op \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Op\_free(op, ierror) \fargs TYPE(MPI\_Op), INTENT(INOUT) :: op \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_OP\_FREE(OP, IERROR) \fargs INTEGER OP, IERROR}
\mpicppemptybind{MPI::Op::Free()}{void}
@@ -2867,7 +2867,7 @@
%%LANG: Fortran
%%ENDHEADER
\begin{verbatim}
- subroutine my_user_function( invec, inoutvec, len, type ) bind(c)
+ subroutine my_user_function( invec, inoutvec, len, type )
use, intrinsic :: iso_c_binding, only : c_ptr, c_f_pointer
use mpi_f08
type(c_ptr), value :: invec, inoutvec
@@ -2911,7 +2911,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Allreduce(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Allreduce(sendbuf, recvbuf, count, datatype, op, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Allreduce(sendbuf, recvbuf, count, datatype, op, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ALLREDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER COUNT, DATATYPE, OP, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Allreduce(const void*~sendbuf, void*~recvbuf, int~count, const MPI::Datatype\&~datatype, const~MPI::Op\&~op) const~=~0}{void}
@@ -2999,7 +2999,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Reduce\_local(const void*~inbuf, void*~inoutbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op)}
-\mpifnewbind{MPI\_Reduce\_local(inbuf, inoutbuf, count, datatype, op, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: inoutbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Reduce\_local(inbuf, inoutbuf, count, datatype, op, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: inoutbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_REDUCE\_LOCAL(INBUF, INOUTBUF, COUNT, DATATYPE, OP, IERROR) \fargs <type> INBUF(*), INOUTBUF(*) \\ INTEGER COUNT, DATATYPE, OP, IERROR}
\mpicppemptybind{MPI::Op::Reduce\_local(const void*~inbuf, void*~inoutbuf, int~count, const MPI::Datatype\&~datatype) const}{void}
@@ -3021,7 +3021,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Op\_commutative(MPI\_Op~op, int~*commute)}
-\mpifnewbind{MPI\_Op\_commutative(op, commute, ierror) BIND(C) \fargs TYPE(MPI\_Op), INTENT(IN) :: op \\ LOGICAL, INTENT(OUT) :: commute \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Op\_commutative(op, commute, ierror) \fargs TYPE(MPI\_Op), INTENT(IN) :: op \\ LOGICAL, INTENT(OUT) :: commute \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_OP\_COMMUTATIVE(OP, COMMUTE, IERROR) \fargs LOGICAL COMMUTE \\ INTEGER OP, IERROR}
\mpicppemptybind{MPI::Op::Is\_commutative() const}{bool}
@@ -3052,7 +3052,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Reduce\_scatter\_block(const void*~sendbuf, void*~recvbuf, int~recvcount, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Reduce\_scatter\_block(sendbuf, recvbuf, recvcount, datatype, op, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Reduce\_scatter\_block(sendbuf, recvbuf, recvcount, datatype, op, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_REDUCE\_SCATTER\_BLOCK(SENDBUF, RECVBUF, RECVCOUNT, DATATYPE, OP, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER RECVCOUNT, DATATYPE, OP, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Reduce\_scatter\_block(const void*~sendbuf, void*~recvbuf, int~recvcount, const~MPI::Datatype\&~datatype, const~MPI::Op\&~op) const~=~0}{void}
@@ -3120,7 +3120,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Reduce\_scatter(const void*~sendbuf, void*~recvbuf, const int~recvcounts[], MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Reduce\_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: recvcounts(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Reduce\_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: recvcounts(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_REDUCE\_SCATTER(SENDBUF, RECVBUF, RECVCOUNTS, DATATYPE, OP, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER RECVCOUNTS(*), DATATYPE, OP, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Reduce\_scatter(const void*~sendbuf, void*~recvbuf, int~recvcounts[], const~MPI::Datatype\&~datatype, const~MPI::Op\&~op) const~=~0}{void}
@@ -3200,7 +3200,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Scan(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Scan(sendbuf, recvbuf, count, datatype, op, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Scan(sendbuf, recvbuf, count, datatype, op, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SCAN(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER COUNT, DATATYPE, OP, COMM, IERROR}
\mpicppemptybind{MPI::Intracomm::Scan(const void*~sendbuf, void*~recvbuf, int~count, const MPI::Datatype\&~datatype, const~MPI::Op\&~op) const}{void}
@@ -3242,7 +3242,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Exscan(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm) }
-\mpifnewbind{MPI\_Exscan(sendbuf, recvbuf, count, datatype, op, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Exscan(sendbuf, recvbuf, count, datatype, op, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_EXSCAN(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, IERROR) \fargs<type> SENDBUF(*), RECVBUF(*) \\INTEGER COUNT, DATATYPE, OP, COMM, IERROR }
\mpicppemptybind{MPI::Intracomm::Exscan(const void* sendbuf, void* recvbuf, int count, const MPI::Datatype\& datatype, const MPI::Op\& op) const}{void}
@@ -3551,7 +3551,7 @@
\mpibind{MPI\_Ibarrier(MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ibarrier(comm, request, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ibarrier(comm, request, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IBARRIER(COMM, REQUEST, IERROR) \fargs INTEGER COMM, REQUEST, IERROR}
\mpifunc{MPI\_IBARRIER} is a nonblocking version of
@@ -3590,7 +3590,7 @@
\mpibind{MPI\_Ibcast(void*~buffer, int~count, MPI\_Datatype~datatype, int~root, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ibcast(buffer, count, datatype, root, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buffer \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ibcast(buffer, count, datatype, root, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buffer \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IBCAST(BUFFER, COUNT, DATATYPE, ROOT, COMM, REQUEST, IERROR) \fargs <type> BUFFER(*) \\ INTEGER COUNT, DATATYPE, ROOT, COMM, REQUEST, IERROR}
@@ -3652,7 +3652,7 @@
\mpibind{MPI\_Igather(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm, MPI\_Request~*request) }
-\mpifnewbind{MPI\_Igather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Igather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IGATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, REQUEST, IERROR}
@@ -3686,7 +3686,7 @@
\mpibind{MPI\_Igatherv(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, const int~recvcounts[], const int~displs[], MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm, MPI\_Request~*request) }
-\mpifnewbind{MPI\_Igatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, root \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Igatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, root \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IGATHERV(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNTS, DISPLS, RECVTYPE, ROOT, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNTS(*), DISPLS(*), RECVTYPE, ROOT, COMM, REQUEST, IERROR}
@@ -3717,7 +3717,7 @@
\mpibind{MPI\_Iscatter(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Iscatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iscatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ISCATTER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, REQUEST, IERROR}
This call starts a nonblocking variant of \mpifunc{MPI\_SCATTER} (see
@@ -3747,7 +3747,7 @@
\mpibind{MPI\_Iscatterv(const void*~sendbuf, const int~sendcounts[], const int~displs[], MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, int~root, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Iscatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), displs(*) \\ INTEGER, INTENT(IN) :: recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iscatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), displs(*) \\ INTEGER, INTENT(IN) :: recvcount, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ISCATTERV(SENDBUF, SENDCOUNTS, DISPLS, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, ROOT, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNTS(*), DISPLS(*), SENDTYPE, RECVCOUNT, RECVTYPE, ROOT, COMM, REQUEST, IERROR}
@@ -3776,7 +3776,7 @@
\mpibind{MPI\_Iallgather(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Iallgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iallgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IALLGATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR}
@@ -3806,7 +3806,7 @@
\mpibind{MPI\_Iallgatherv(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, const int~recvcounts[], const int~displs[], MPI\_Datatype~recvtype, MPI\_Comm~comm, MPI\_Request* request)}
-\mpifnewbind{MPI\_Iallgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iallgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IALLGATHERV(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNTS, DISPLS, RECVTYPE, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNTS(*), DISPLS(*), RECVTYPE, COMM, REQUEST, IERROR}
@@ -3835,7 +3835,7 @@
\mpibind{MPI\_Ialltoall(const void*~sendbuf, int~sendcount, MPI\_Datatype~sendtype, void*~recvbuf, int~recvcount, MPI\_Datatype~recvtype, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ialltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ialltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR}
@@ -3869,7 +3869,7 @@
\mpibind{MPI\_Ialltoallv(const void*~sendbuf, const int~sendcounts[], const int~sdispls[], MPI\_Datatype~sendtype, void*~recvbuf, const int~recvcounts[], const int~rdispls[], MPI\_Datatype~recvtype, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ialltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ialltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IALLTOALLV(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPE, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPE, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPE, RECVCOUNTS(*), RDISPLS(*), RECVTYPE, COMM, REQUEST, IERROR}
This call starts a nonblocking variant of \mpifunc{MPI\_ALLTOALLV} (see
@@ -3904,7 +3904,7 @@
\mpibind{MPI\_Ialltoallw(const void*~sendbuf, const int~sendcounts[], const int~sdispls[], const MPI\_Datatype~sendtypes[], void*~recvbuf, const int~recvcounts[], const int~rdispls[], const MPI\_Datatype~recvtypes[], MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ialltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN), ASYNCHRONOUS :: sendtypes(*), recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ialltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN), ASYNCHRONOUS :: sendtypes(*), recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IALLTOALLW(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPES, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPES, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPES(*), RECVCOUNTS(*), RDISPLS(*), RECVTYPES(*), COMM, REQUEST, IERROR}
@@ -3932,7 +3932,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Ireduce(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, int~root, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ireduce(sendbuf, recvbuf, count, datatype, op, root, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ireduce(sendbuf, recvbuf, count, datatype, op, root, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count, root \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IREDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, ROOT, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER COUNT, DATATYPE, OP, ROOT, COMM, REQUEST, IERROR}
@@ -3978,7 +3978,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Iallreduce(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Iallreduce(sendbuf, recvbuf, count, datatype, op, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iallreduce(sendbuf, recvbuf, count, datatype, op, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IALLREDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER COUNT, DATATYPE, OP, COMM, REQUEST, IERROR}
@@ -4006,7 +4006,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Ireduce\_scatter\_block(const void*~sendbuf, void*~recvbuf, int~recvcount, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ireduce\_scatter\_block(sendbuf, recvbuf, recvcount, datatype, op, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ireduce\_scatter\_block(sendbuf, recvbuf, recvcount, datatype, op, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IREDUCE\_SCATTER\_BLOCK(SENDBUF, RECVBUF, RECVCOUNT, DATATYPE, OP, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER RECVCOUNT, DATATYPE, OP, COMM, REQUEST, IERROR}
@@ -4035,7 +4035,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Ireduce\_scatter(const void*~sendbuf, void*~recvbuf, const int~recvcounts[], MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ireduce\_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ireduce\_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IREDUCE\_SCATTER(SENDBUF, RECVBUF, RECVCOUNTS, DATATYPE, OP, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER RECVCOUNTS(*), DATATYPE, OP, COMM, REQUEST, IERROR}
@@ -4061,7 +4061,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Iscan(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Iscan(sendbuf, recvbuf, count, datatype, op, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iscan(sendbuf, recvbuf, count, datatype, op, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ISCAN(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, REQUEST, IERROR) \fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER COUNT, DATATYPE, OP, COMM, REQUEST, IERROR}
This call starts a nonblocking variant of \mpifunc{MPI\_SCAN} (see
@@ -4086,7 +4086,7 @@
\cdeclindex{MPI\_Op}%
\mpibind{MPI\_Iexscan(const void*~sendbuf, void*~recvbuf, int~count, MPI\_Datatype~datatype, MPI\_Op~op, MPI\_Comm~comm, MPI\_Request~*request) }
-\mpifnewbind{MPI\_Iexscan(sendbuf, recvbuf, count, datatype, op, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iexscan(sendbuf, recvbuf, count, datatype, op, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IEXSCAN(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, REQUEST, IERROR) \fargs<type> SENDBUF(*), RECVBUF(*) \\INTEGER COUNT, DATATYPE, OP, COMM, REQUEST, IERROR }
This call starts a nonblocking variant of \mpifunc{MPI\_EXSCAN} (see
Raw
mpi31-r1835-chap-context.diff
Index: chap-context/context.tex
===================================================================
--- chap-context/context.tex (revision 1834)
+++ chap-context/context.tex (revision 1835)
@@ -339,7 +339,7 @@
\cdeclmainindex{MPI\_Group}%
\mpibind{MPI\_Group\_size(MPI\_Group~group, int~*size)}
-\mpifnewbind{MPI\_Group\_size(group, size, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_size(group, size, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_SIZE(GROUP, SIZE, IERROR)\fargs INTEGER GROUP, SIZE, IERROR}
\mpicppemptybind{MPI::Group::Get\_size() const}{int}
@@ -354,7 +354,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_rank(MPI\_Group~group, int~*rank)}
-\mpifnewbind{MPI\_Group\_rank(group, rank, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(OUT) :: rank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_rank(group, rank, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(OUT) :: rank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_RANK(GROUP, RANK, IERROR)\fargs INTEGER GROUP, RANK, IERROR}
\mpicppemptybind{MPI::Group::Get\_rank() const}{int}
@@ -373,7 +373,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_translate\_ranks(MPI\_Group~group1, int~n, const int~ranks1[], MPI\_Group~group2, int~ranks2[])}
-\mpifnewbind{MPI\_Group\_translate\_ranks(group1, n, ranks1, group2, ranks2, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ INTEGER, INTENT(IN) :: n, ranks1(n) \\ INTEGER, INTENT(OUT) :: ranks2(n) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_translate\_ranks(group1, n, ranks1, group2, ranks2, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ INTEGER, INTENT(IN) :: n, ranks1(n) \\ INTEGER, INTENT(OUT) :: ranks2(n) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_TRANSLATE\_RANKS(GROUP1, N, RANKS1, GROUP2, RANKS2, IERROR)\fargs INTEGER GROUP1, N, RANKS1(*), GROUP2, RANKS2(*), IERROR}
\mpicppemptybind{MPI::Group::Translate\_ranks (const~MPI::Group\&~group1, int~n, const~int~ranks1[], const~MPI::Group\&~group2, int~ranks2[])}{static void}
@@ -395,7 +395,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_compare(MPI\_Group~group1,MPI\_Group~group2,~int~*result)}
-\mpifnewbind{MPI\_Group\_compare(group1, group2, result, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ INTEGER, INTENT(OUT) :: result \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_compare(group1, group2, result, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ INTEGER, INTENT(OUT) :: result \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_COMPARE(GROUP1, GROUP2, RESULT, IERROR)\fargs INTEGER GROUP1, GROUP2, RESULT, IERROR}
\mpicppemptybind{MPI::Group::Compare(const~MPI::Group\&~group1, const~MPI::Group\&~group2)}{static int}
@@ -444,7 +444,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Comm\_group(MPI\_Comm~comm, MPI\_Group~*group)}
-\mpifnewbind{MPI\_Comm\_group(comm, group, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_group(comm, group, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_GROUP(COMM, GROUP, IERROR)\fargs INTEGER COMM, GROUP, IERROR}
\mpicppemptybind{MPI::Comm::Get\_group() const}{MPI::Group}
@@ -461,7 +461,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_union(MPI\_Group~group1, MPI\_Group~group2, MPI\_Group~*newgroup)}
-\mpifnewbind{MPI\_Group\_union(group1, group2, newgroup, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_union(group1, group2, newgroup, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_UNION(GROUP1, GROUP2, NEWGROUP, IERROR)\fargs INTEGER GROUP1, GROUP2, NEWGROUP, IERROR}
\mpicppemptybind{MPI::Group::Union(const~MPI::Group\&~group1, const~MPI::Group\&~group2)}{static MPI::Group}
@@ -474,7 +474,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_intersection(MPI\_Group~group1, MPI\_Group~group2, MPI\_Group~*newgroup)}
-\mpifnewbind{MPI\_Group\_intersection(group1, group2, newgroup, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_intersection(group1, group2, newgroup, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_INTERSECTION(GROUP1, GROUP2, NEWGROUP, IERROR)\fargs INTEGER GROUP1, GROUP2, NEWGROUP, IERROR}
\mpicppemptybind{MPI::Group::Intersect(const~MPI::Group\&~group1, const~MPI::Group\&~group2)}{static MPI::Group}
@@ -487,7 +487,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_difference(MPI\_Group~group1, MPI\_Group~group2, MPI\_Group~*newgroup)}
-\mpifnewbind{MPI\_Group\_difference(group1, group2, newgroup, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_difference(group1, group2, newgroup, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group1, group2 \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_DIFFERENCE(GROUP1, GROUP2, NEWGROUP, IERROR)\fargs INTEGER GROUP1, GROUP2, NEWGROUP, IERROR}
\mpicppemptybind{MPI::Group::Difference(const~MPI::Group\&~group1, const~MPI::Group\&~group2)}{static MPI::Group}
@@ -519,7 +519,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_incl(MPI\_Group~group, int~n, const int~ranks[], MPI\_Group~*newgroup)}
-\mpifnewbind{MPI\_Group\_incl(group, n, ranks, newgroup, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranks(n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_incl(group, n, ranks, newgroup, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranks(n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_INCL(GROUP, N, RANKS, NEWGROUP, IERROR)\fargs INTEGER GROUP, N, RANKS(*), NEWGROUP, IERROR}
\mpicppemptybind{MPI::Group::Incl(int~n, const~int~ranks[]) const}{MPI::Group}
@@ -545,7 +545,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_excl(MPI\_Group~group, int~n, const int~ranks[], MPI\_Group~*newgroup)}
-\mpifnewbind{MPI\_Group\_excl(group, n, ranks, newgroup, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranks(n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_excl(group, n, ranks, newgroup, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranks(n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_EXCL(GROUP, N, RANKS, NEWGROUP, IERROR)\fargs INTEGER GROUP, N, RANKS(*), NEWGROUP, IERROR}
\mpicppemptybind{MPI::Group::Excl(int~n, const~int~ranks[]) const}{MPI::Group}
@@ -573,7 +573,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_range\_incl(MPI\_Group~group, int~n, int~ranges[][3], MPI\_Group~*newgroup)}
-\mpifnewbind{MPI\_Group\_range\_incl(group, n, ranges, newgroup, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranges(3,n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_range\_incl(group, n, ranges, newgroup, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranges(3,n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_RANGE\_INCL(GROUP, N, RANGES, NEWGROUP, IERROR)\fargs INTEGER GROUP, N, RANGES(3,*), NEWGROUP, IERROR}
\mpicppemptybind{MPI::Group::Range\_incl(int~n, const~int~ranges[][3]) const}{MPI::Group}
@@ -621,7 +621,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_range\_excl(MPI\_Group~group, int~n, int~ranges[][3], MPI\_Group~*newgroup)}
-\mpifnewbind{MPI\_Group\_range\_excl(group, n, ranges, newgroup, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranges(3,n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_range\_excl(group, n, ranges, newgroup, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: n, ranges(3,n) \\ TYPE(MPI\_Group), INTENT(OUT) :: newgroup \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_RANGE\_EXCL(GROUP, N, RANGES, NEWGROUP, IERROR)\fargs INTEGER GROUP, N, RANGES(3,*), NEWGROUP, IERROR}
\mpicppemptybind{MPI::Group::Range\_excl(int~n, const~int~ranges[][3]) const}{MPI::Group}
@@ -660,7 +660,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Group\_free(MPI\_Group~*group)}
-\mpifnewbind{MPI\_Group\_free(group, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(INOUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Group\_free(group, ierror) \fargs TYPE(MPI\_Group), INTENT(INOUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GROUP\_FREE(GROUP, IERROR)\fargs INTEGER GROUP, IERROR}
\mpicppemptybind{MPI::Group::Free()}{void}
@@ -708,7 +708,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_size(MPI\_Comm~comm, int~*size)}
-\mpifnewbind{MPI\_Comm\_size(comm, size, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_size(comm, size, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SIZE(COMM, SIZE, IERROR)\fargs INTEGER COMM, SIZE, IERROR}
\mpicppemptybind{MPI::Comm::Get\_size() const}{int}
@@ -744,7 +744,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_rank(MPI\_Comm~comm, int~*rank)}
-\mpifnewbind{MPI\_Comm\_rank(comm, rank, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: rank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_rank(comm, rank, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: rank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_RANK(COMM, RANK, IERROR)\fargs INTEGER COMM, RANK, IERROR}
\mpicppemptybind{MPI::Comm::Get\_rank() const}{int}
@@ -777,7 +777,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_compare(MPI\_Comm~comm1, MPI\_Comm~comm2,~int~*result)}
-\mpifnewbind{MPI\_Comm\_compare(comm1, comm2, result, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm1, comm2 \\ INTEGER, INTENT(OUT) :: result \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_compare(comm1, comm2, result, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm1, comm2 \\ INTEGER, INTENT(OUT) :: result \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_COMPARE(COMM1, COMM2, RESULT, IERROR)\fargs INTEGER COMM1, COMM2, RESULT, IERROR}
\mpicppemptybind{MPI::Comm::Compare(const~MPI::Comm\&~comm1, const~MPI::Comm\&~comm2)}{static int}
@@ -841,7 +841,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_dup(MPI\_Comm~comm, MPI\_Comm~*newcomm)}
-\mpifnewbind{MPI\_Comm\_dup(comm, newcomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_dup(comm, newcomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_DUP(COMM, NEWCOMM, IERROR)\fargs INTEGER COMM, NEWCOMM, IERROR}
\mpicppemptybind{MPI::Intracomm::Dup() const}{MPI::Intracomm}
\mpicppemptybind{MPI::Intercomm::Dup() const}{MPI::Intercomm}
@@ -898,7 +898,7 @@
\cdeclindex{MPI\_Comm}
\mpibind{MPI\_Comm\_dup\_with\_info(MPI\_Comm comm, MPI\_Info info, MPI\_Comm *newcomm)}
-\mpifnewbind{MPI\_Comm\_dup\_with\_info(comm, info, newcomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Info), INTENT(IN) :: info\\TYPE(MPI\_Comm), INTENT(OUT) :: newcomm\\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_dup\_with\_info(comm, info, newcomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Info), INTENT(IN) :: info\\TYPE(MPI\_Comm), INTENT(OUT) :: newcomm\\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_DUP\_WITH\_INFO(COMM, INFO, NEWCOMM, IERROR)\fargs INTEGER COMM, INFO, NEWCOMM, IERROR}
@@ -926,7 +926,7 @@
\cdeclindex{MPI\_Comm}
\mpibind{MPI\_Comm\_idup(MPI\_Comm comm, MPI\_Comm~*newcomm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Comm\_idup(comm, newcomm, request, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_idup(comm, newcomm, request, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_IDUP(COMM, NEWCOMM, REQUEST, IERROR)\fargs INTEGER COMM, NEWCOMM, REQUEST, IERROR}
@@ -959,7 +959,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Comm\_create(MPI\_Comm~comm, MPI\_Group~group, MPI\_Comm~*newcomm)}
-\mpifnewbind{MPI\_Comm\_create(comm, group, newcomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Group), INTENT(IN) :: group \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_create(comm, group, newcomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Group), INTENT(IN) :: group \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_CREATE(COMM, GROUP, NEWCOMM, IERROR)\fargs INTEGER COMM, GROUP, NEWCOMM, IERROR}
\mpicppemptybind{MPI::Intercomm::Create(const MPI::Group\&~group) const}{MPI::Intercomm}
@@ -1186,7 +1186,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_split(MPI\_Comm~comm, int~color, int~key, MPI\_Comm~*newcomm)}
-\mpifnewbind{MPI\_Comm\_split(comm, color, key, newcomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: color, key \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_split(comm, color, key, newcomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: color, key \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SPLIT(COMM, COLOR, KEY, NEWCOMM, IERROR)\fargs INTEGER COMM, COLOR, KEY, NEWCOMM, IERROR}
\mpicppemptybind{MPI::Intercomm::Split(int color, int key) const}{MPI::Intercomm}
@@ -1348,7 +1348,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_split\_type(MPI\_Comm~comm, int~split\_type, int~key, MPI\_Info~info, MPI\_Comm~*newcomm)}
-\mpifnewbind{MPI\_Comm\_split\_type(comm, split\_type, key, info, newcomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: split\_type, key \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_split\_type(comm, split\_type, key, info, newcomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: split\_type, key \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SPLIT\_TYPE(COMM, SPLIT\_TYPE, KEY, INFO, NEWCOMM, IERROR)\fargs INTEGER COMM, SPLIT\_TYPE, KEY, INFO, NEWCOMM, IERROR}
\noindent This function partitions the group associated with
@@ -1390,7 +1390,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_free(MPI\_Comm~*comm)}
-\mpifnewbind{MPI\_Comm\_free(comm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(INOUT) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_free(comm, ierror) \fargs TYPE(MPI\_Comm), INTENT(INOUT) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_FREE(COMM, IERROR)\fargs INTEGER COMM, IERROR}
\mpicppemptybind{MPI::Comm::Free()}{void}
@@ -1457,7 +1457,7 @@
\cdeclmainindex{MPI\_Comm}
\mpibind{MPI\_Comm\_set\_info(MPI\_Comm comm, MPI\_Info info)}
-\mpifnewbind{MPI\_Comm\_set\_info(MPI\_Comm comm, MPI\_Info info) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(INOUT) :: comm\\TYPE(MPI\_Info), INTENT(IN) :: info\\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_set\_info(MPI\_Comm comm, MPI\_Info info) \fargs TYPE(MPI\_Comm), INTENT(INOUT) :: comm\\TYPE(MPI\_Info), INTENT(IN) :: info\\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SET\_INFO(COMM, INFO, IERROR)\fargs INTEGER COMM, INFO, IERROR}
@@ -1484,7 +1484,7 @@
\cdeclmainindex{MPI\_Comm}
\mpibind{MPI\_Comm\_get\_info(MPI\_Comm~comm, MPI\_Info~*info\_used)}
-\mpifnewbind{MPI\_Comm\_get\_info(comm, info\_used, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\\TYPE(MPI\_Info), INTENT(OUT) :: info\_used\\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_get\_info(comm, info\_used, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\\TYPE(MPI\_Info), INTENT(OUT) :: info\_used\\INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_GET\_INFO(COMM, INFO\_USED, IERROR)\fargs INTEGER COMM, INFO\_USED, IERROR}
@@ -2110,7 +2110,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_test\_inter(MPI\_Comm~comm, int~*flag)}
-\mpifnewbind{MPI\_Comm\_test\_inter(comm, flag, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_test\_inter(comm, flag, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_TEST\_INTER(COMM, FLAG, IERROR)\fargs INTEGER COMM, IERROR\\ LOGICAL FLAG}
\mpicppemptybind{MPI::Comm::Is\_inter() const}{bool}
@@ -2160,7 +2160,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_remote\_size(MPI\_Comm~comm, int~*size)}
-\mpifnewbind{MPI\_Comm\_remote\_size(comm, size, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_remote\_size(comm, size, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_REMOTE\_SIZE(COMM, SIZE, IERROR)\fargs INTEGER COMM, SIZE, IERROR}
\mpicppemptybind{MPI::Intercomm::Get\_remote\_size() const}{int}
@@ -2174,7 +2174,7 @@
\cdeclindex{MPI\_Group}%
\mpibind{MPI\_Comm\_remote\_group(MPI\_Comm~comm, MPI\_Group~*group)}
-\mpifnewbind{MPI\_Comm\_remote\_group(comm, group, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_remote\_group(comm, group, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_REMOTE\_GROUP(COMM, GROUP, IERROR)\fargs INTEGER COMM, GROUP, IERROR}
\mpicppemptybind{MPI::Intercomm::Get\_remote\_group() const}{MPI::Group}
@@ -2251,7 +2251,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Intercomm\_create(MPI\_Comm~local\_comm, int~local\_leader, MPI\_Comm~peer\_comm, int~remote\_leader, int~tag, MPI\_Comm~*newintercomm)}
-\mpifnewbind{MPI\_Intercomm\_create(local\_comm, local\_leader, peer\_comm, remote\_leader, tag, newintercomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: local\_comm, peer\_comm \\ INTEGER, INTENT(IN) :: local\_leader, remote\_leader, tag \\ TYPE(MPI\_Comm), INTENT(OUT) :: newintercomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Intercomm\_create(local\_comm, local\_leader, peer\_comm, remote\_leader, tag, newintercomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: local\_comm, peer\_comm \\ INTEGER, INTENT(IN) :: local\_leader, remote\_leader, tag \\ TYPE(MPI\_Comm), INTENT(OUT) :: newintercomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INTERCOMM\_CREATE(LOCAL\_COMM, LOCAL\_LEADER, PEER\_COMM, REMOTE\_LEADER, TAG, NEWINTERCOMM, IERROR)\fargs INTEGER LOCAL\_COMM, LOCAL\_LEADER, PEER\_COMM, REMOTE\_LEADER, TAG, NEWINTERCOMM, IERROR}
\mpicppemptybind{MPI::Intracomm::Create\_intercomm(int~local\_leader, const MPI::Comm\&~peer\_comm, int~remote\_leader, int~tag) const}{MPI::Intercomm}
@@ -2271,7 +2271,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Intercomm\_merge(MPI\_Comm~intercomm, int~high, MPI\_Comm~*newintracomm)}
-\mpifnewbind{MPI\_Intercomm\_merge(intercomm, high, newintracomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: intercomm \\ LOGICAL, INTENT(IN) :: high \\ TYPE(MPI\_Comm), INTENT(OUT) :: newintracomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Intercomm\_merge(intercomm, high, newintracomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: intercomm \\ LOGICAL, INTENT(IN) :: high \\ TYPE(MPI\_Comm), INTENT(OUT) :: newintracomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INTERCOMM\_MERGE(INTERCOMM, HIGH, NEWINTRACOMM, IERROR)\fargs INTEGER INTERCOMM, NEWINTRACOMM, IERROR \\ LOGICAL HIGH}
\mpicppemptybind{MPI::Intercomm::Merge(bool~high) const}{MPI::Intracomm}
@@ -2623,7 +2623,7 @@
\mpibind{MPI\_Comm\_create\_keyval(MPI\_Comm\_copy\_attr\_function~*comm\_copy\_attr\_fn, MPI\_Comm\_delete\_attr\_function~*comm\_delete\_attr\_fn, int~*comm\_keyval, void~*extra\_state)}
-\mpifnewbind{MPI\_Comm\_create\_keyval(comm\_copy\_attr\_fn, comm\_delete\_attr\_fn, comm\_keyval, extra\_state, ierror) BIND(C) \fargs PROCEDURE(MPI\_Comm\_copy\_attr\_function) :: comm\_copy\_attr\_fn \\ PROCEDURE(MPI\_Comm\_delete\_attr\_function) :: comm\_delete\_attr\_fn \\ INTEGER, INTENT(OUT) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_create\_keyval(comm\_copy\_attr\_fn, comm\_delete\_attr\_fn, comm\_keyval, extra\_state, ierror) \fargs PROCEDURE(MPI\_Comm\_copy\_attr\_function) :: comm\_copy\_attr\_fn \\ PROCEDURE(MPI\_Comm\_delete\_attr\_function) :: comm\_delete\_attr\_fn \\ INTEGER, INTENT(OUT) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_CREATE\_KEYVAL(COMM\_COPY\_ATTR\_FN, COMM\_DELETE\_ATTR\_FN, COMM\_KEYVAL, EXTRA\_STATE, IERROR)\fargs EXTERNAL COMM\_COPY\_ATTR\_FN, COMM\_DELETE\_ATTR\_FN\\INTEGER COMM\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE}
\mpicppemptybind{MPI::Comm::Create\_keyval(MPI::Comm::Copy\_attr\_function* comm\_copy\_attr\_fn, MPI::Comm::Delete\_attr\_function*~comm\_delete\_attr\_fn, void*~extra\_state)}{static int}
@@ -2651,12 +2651,12 @@
\noindent
With the \code{mpi\_f08} module, the Fortran callback functions are:
-\mpifnewsubbind{MPI\_Comm\_copy\_attr\_function(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Comm) :: oldcomm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
+\mpifnewsubbind{MPI\_Comm\_copy\_attr\_function(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Comm) :: oldcomm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
\noindent
and
-\mpifnewsubbind{MPI\_Comm\_delete\_attr\_function(comm, comm\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
+\mpifnewsubbind{MPI\_Comm\_delete\_attr\_function(comm, comm\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: comm\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
\noindent
With the \code{mpi} module and \code{mpif.h}, the Fortran callback functions are:
@@ -2714,10 +2714,10 @@
% C binding for MPI_COMM_DUP_FN
\mpibind{MPI\_COMM\_DUP\_FN(MPI\_Comm~oldcomm, int~comm\_keyval, void~*extra\_state, void~*attribute\_val\_in, void~*attribute\_val\_out, int~*flag)}
% Fortran binding for MPI_COMM_NULL_COPY_FN
-\mpifnewbind{MPI\_COMM\_NULL\_COPY\_FN(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: oldcomm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_COMM\_NULL\_COPY\_FN(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: oldcomm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_NULL\_COPY\_FN(OLDCOMM, COMM\_KEYVAL, EXTRA\_STATE, ATTRIBUTE\_VAL\_IN, ATTRIBUTE\_VAL\_OUT, FLAG, IERROR)\fargs INTEGER OLDCOMM, COMM\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE, ATTRIBUTE\_VAL\_IN,\\ \ \ \ \ ATTRIBUTE\_VAL\_OUT\\LOGICAL FLAG}
% Fortran binding for MPI_COMM_DUP_FN
-\mpifnewbind{MPI\_COMM\_DUP\_FN(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: oldcomm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_COMM\_DUP\_FN(oldcomm, comm\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: oldcomm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_DUP\_FN(OLDCOMM, COMM\_KEYVAL, EXTRA\_STATE, ATTRIBUTE\_VAL\_IN, ATTRIBUTE\_VAL\_OUT, FLAG, IERROR)\fargs INTEGER OLDCOMM, COMM\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE, ATTRIBUTE\_VAL\_IN,\\ \ \ \ \ ATTRIBUTE\_VAL\_OUT\\LOGICAL FLAG}
% C++ binding for MPI_COMM_NULL_COPY_FN
%%-74.l-- \mpicppemptybind{MPI\_COMM\_NULL\_COPY\_FN(const~MPI::Comm\&~oldcomm, int~comm\_keyval, void*~extra\_state, void*~attribute\_val\_in, void*~attribute\_val\_out, bool\&~flag)}{int}
@@ -2779,7 +2779,7 @@
% C binding for MPI_COMM_NULL_DELETE_FN
\mpibind{MPI\_COMM\_NULL\_DELETE\_FN(MPI\_Comm comm, int comm\_keyval, void *attribute\_val, void *extra\_state)}
% Fortran binding for MPI_COMM_NULL_DELETE_FN
-\mpifnewbind{MPI\_COMM\_NULL\_DELETE\_FN(comm, comm\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val, extra\_state \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_COMM\_NULL\_DELETE\_FN(comm, comm\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val, extra\_state \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_NULL\_DELETE\_FN(COMM, COMM\_KEYVAL, ATTRIBUTE\_VAL, EXTRA\_STATE, IERROR)\fargs INTEGER COMM, COMM\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL, EXTRA\_STATE}
% C++ binding for MPI_COMM_NULL_DELETE_FN
%%-74.l-- \mpicppemptybind{MPI\_COMM\_NULL\_DELETE\_FN(MPI::Comm\&~comm, int~comm\_keyval, void*~attribute\_val, void*~extra\_state)}{int}
@@ -2826,7 +2826,7 @@
\mpibind{MPI\_Comm\_free\_keyval(int *comm\_keyval)}
-\mpifnewbind{MPI\_Comm\_free\_keyval(comm\_keyval, ierror) BIND(C) \fargs INTEGER, INTENT(INOUT) :: comm\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_free\_keyval(comm\_keyval, ierror) \fargs INTEGER, INTENT(INOUT) :: comm\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_FREE\_KEYVAL(COMM\_KEYVAL, IERROR)\fargs INTEGER COMM\_KEYVAL, IERROR}
\mpicppemptybind{MPI::Comm::Free\_keyval(int\& comm\_keyval)}{static void}
@@ -2851,7 +2851,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_set\_attr(MPI\_Comm comm, int comm\_keyval, void *attribute\_val)}
-\mpifnewbind{MPI\_Comm\_set\_attr(comm, comm\_keyval, attribute\_val, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_set\_attr(comm, comm\_keyval, attribute\_val, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SET\_ATTR(COMM, COMM\_KEYVAL, ATTRIBUTE\_VAL, IERROR)\fargs INTEGER COMM, COMM\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL}
\mpicppemptybind{MPI::Comm::Set\_attr(int comm\_keyval, const void* attribute\_val) const}{void}
@@ -2880,7 +2880,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_get\_attr(MPI\_Comm comm, int comm\_keyval, void *attribute\_val, int *flag)}
-\mpifnewbind{MPI\_Comm\_get\_attr(comm, comm\_keyval, attribute\_val, flag, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_get\_attr(comm, comm\_keyval, attribute\_val, flag, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_GET\_ATTR(COMM, COMM\_KEYVAL, ATTRIBUTE\_VAL, FLAG, IERROR)\fargs INTEGER COMM, COMM\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL\\LOGICAL FLAG}
\mpicppemptybind{MPI::Comm::Get\_attr(int comm\_keyval, void* attribute\_val) const}{bool}
@@ -2923,7 +2923,7 @@
\cdeclindex{MPI\_Comm}%
\mpibind{MPI\_Comm\_delete\_attr(MPI\_Comm comm, int comm\_keyval)}
-\mpifnewbind{MPI\_Comm\_delete\_attr(comm, comm\_keyval, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_delete\_attr(comm, comm\_keyval, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: comm\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_DELETE\_ATTR(COMM, COMM\_KEYVAL, IERROR)\fargs INTEGER COMM, COMM\_KEYVAL, IERROR}
\mpicppemptybind{MPI::Comm::Delete\_attr(int comm\_keyval)}{void}
@@ -2956,7 +2956,7 @@
\mpibind{MPI\_Win\_create\_keyval(MPI\_Win\_copy\_attr\_function~*win\_copy\_attr\_fn, MPI\_Win\_delete\_attr\_function~*win\_delete\_attr\_fn, int~*win\_keyval, void~*extra\_state)}
-\mpifnewbind{MPI\_Win\_create\_keyval(win\_copy\_attr\_fn, win\_delete\_attr\_fn, win\_keyval, extra\_state, ierror) BIND(C) \fargs PROCEDURE(MPI\_Win\_copy\_attr\_function) :: win\_copy\_attr\_fn \\ PROCEDURE(MPI\_Win\_delete\_attr\_function) :: win\_delete\_attr\_fn \\ INTEGER, INTENT(OUT) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_create\_keyval(win\_copy\_attr\_fn, win\_delete\_attr\_fn, win\_keyval, extra\_state, ierror) \fargs PROCEDURE(MPI\_Win\_copy\_attr\_function) :: win\_copy\_attr\_fn \\ PROCEDURE(MPI\_Win\_delete\_attr\_function) :: win\_delete\_attr\_fn \\ INTEGER, INTENT(OUT) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_CREATE\_KEYVAL(WIN\_COPY\_ATTR\_FN, WIN\_DELETE\_ATTR\_FN, WIN\_KEYVAL, EXTRA\_STATE, IERROR)\fargs EXTERNAL WIN\_COPY\_ATTR\_FN, WIN\_DELETE\_ATTR\_FN\\INTEGER WIN\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE}
\mpicppemptybind{MPI::Win::Create\_keyval(MPI::Win::Copy\_attr\_function* win\_copy\_attr\_fn, MPI::Win::Delete\_attr\_function*~win\_delete\_attr\_fn, void*~extra\_state)}{static int}
@@ -2987,10 +2987,10 @@
% C binding for MPI_WIN_DUP_FN
\mpibind{MPI\_WIN\_DUP\_FN(MPI\_Win~oldwin, int~win\_keyval, void~*extra\_state, void~*attribute\_val\_in, void~*attribute\_val\_out, int~*flag)}
% Fortran binding for MPI_WIN_NULL_COPY_FN
-\mpifnewbind{MPI\_WIN\_NULL\_COPY\_FN(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: oldwin, win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_WIN\_NULL\_COPY\_FN(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs INTEGER, INTENT(IN) :: oldwin, win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_NULL\_COPY\_FN(OLDWIN, WIN\_KEYVAL, EXTRA\_STATE, ATTRIBUTE\_VAL\_IN, ATTRIBUTE\_VAL\_OUT, FLAG, IERROR)\fargs INTEGER OLDWIN, WIN\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE, ATTRIBUTE\_VAL\_IN,\\ \ \ \ \ ATTRIBUTE\_VAL\_OUT\\LOGICAL FLAG}
% Fortran binding for MPI_WIN_DUP_FN
-\mpifnewbind{MPI\_WIN\_DUP\_FN(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: oldwin, win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_WIN\_DUP\_FN(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs INTEGER, INTENT(IN) :: oldwin, win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_DUP\_FN(OLDWIN, WIN\_KEYVAL, EXTRA\_STATE, ATTRIBUTE\_VAL\_IN, ATTRIBUTE\_VAL\_OUT, FLAG, IERROR)\fargs INTEGER OLDWIN, WIN\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE, ATTRIBUTE\_VAL\_IN,\\ \ \ \ \ ATTRIBUTE\_VAL\_OUT\\LOGICAL FLAG}
% C++ binding for MPI_WIN_NULL_COPY_FN
%%-74.l-- \mpicppemptybind{MPI\_WIN\_NULL\_COPY\_FN(const~MPI::Win\&~oldwin, int~win\_keyval, void*~extra\_state, void*~attribute\_val\_in, void*~attribute\_val\_out, bool\&~flag)}{int}
@@ -3014,7 +3014,7 @@
% C binding for MPI_WIN_NULL_DELETE_FN
\mpibind{MPI\_WIN\_NULL\_DELETE\_FN(MPI\_Win win, int win\_keyval, void *attribute\_val, void *extra\_state)}
% Fortran binding for MPI_WIN_NULL_DELETE_FN
-\mpifnewbind{MPI\_WIN\_NULL\_DELETE\_FN(win, win\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val, extra\_state \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_WIN\_NULL\_DELETE\_FN(win, win\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val, extra\_state \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_NULL\_DELETE\_FN(WIN, WIN\_KEYVAL, ATTRIBUTE\_VAL, EXTRA\_STATE, IERROR)\fargs INTEGER WIN, WIN\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL, EXTRA\_STATE}
% C++ binding for MPI_WIN_NULL_DELETE_FN
%%-74.l-- \mpicppemptybind{MPI\_WIN\_NULL\_DELETE\_FN(MPI::Win\&~win, int~win\_keyval, void*~attribute\_val, void*~extra\_state)}{int}
@@ -3036,12 +3036,12 @@
\noindent
With the \code{mpi\_f08} module, the Fortran callback functions are:
-\mpifnewsubbind{MPI\_Win\_copy\_attr\_function(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Win) :: oldwin \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
+\mpifnewsubbind{MPI\_Win\_copy\_attr\_function(oldwin, win\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Win) :: oldwin \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
\noindent
and
-\mpifnewsubbind{MPI\_Win\_delete\_attr\_function(win, win\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
+\mpifnewsubbind{MPI\_Win\_delete\_attr\_function(win, win\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: win\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
\noindent
With the \code{mpi} module and \code{mpif.h}, the Fortran callback functions are:
@@ -3063,7 +3063,7 @@
\mpibind{MPI\_Win\_free\_keyval(int *win\_keyval)}
-\mpifnewbind{MPI\_Win\_free\_keyval(win\_keyval, ierror) BIND(C) \fargs INTEGER, INTENT(INOUT) :: win\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_free\_keyval(win\_keyval, ierror) \fargs INTEGER, INTENT(INOUT) :: win\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_FREE\_KEYVAL(WIN\_KEYVAL, IERROR)\fargs INTEGER WIN\_KEYVAL, IERROR}
\mpicppemptybind{MPI::Win::Free\_keyval(int\& win\_keyval)}{static void}
@@ -3077,7 +3077,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_set\_attr(MPI\_Win win, int win\_keyval, void *attribute\_val)}
-\mpifnewbind{MPI\_Win\_set\_attr(win, win\_keyval, attribute\_val, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_set\_attr(win, win\_keyval, attribute\_val, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_SET\_ATTR(WIN, WIN\_KEYVAL, ATTRIBUTE\_VAL, IERROR)\fargs INTEGER WIN, WIN\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL}
\mpicppemptybind{MPI::Win::Set\_attr(int win\_keyval, const void* attribute\_val)}{void}
@@ -3094,7 +3094,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_get\_attr(MPI\_Win~win, int~win\_keyval, void~*attribute\_val, int~*flag)}
-\mpifnewbind{MPI\_Win\_get\_attr(win, win\_keyval, attribute\_val, flag, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_get\_attr(win, win\_keyval, attribute\_val, flag, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_GET\_ATTR(WIN, WIN\_KEYVAL, ATTRIBUTE\_VAL, FLAG, IERROR)\fargs INTEGER WIN, WIN\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL\\LOGICAL FLAG}
% \mpicppemptybind{MPI::Win::Get\_attr(const~MPI::Win\&~win, int~win\_keyval, void*~attribute\_val) const}{bool}
@@ -3108,7 +3108,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_delete\_attr(MPI\_Win win, int win\_keyval)}
-\mpifnewbind{MPI\_Win\_delete\_attr(win, win\_keyval, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_delete\_attr(win, win\_keyval, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: win\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_DELETE\_ATTR(WIN, WIN\_KEYVAL, IERROR)\fargs INTEGER WIN, WIN\_KEYVAL, IERROR}
\mpicppemptybind{MPI::Win::Delete\_attr(int win\_keyval)}{void}
@@ -3128,7 +3128,7 @@
\mpibind{MPI\_Type\_create\_keyval(MPI\_Type\_copy\_attr\_function~*type\_copy\_attr\_fn, MPI\_Type\_delete\_attr\_function~*type\_delete\_attr\_fn, int~*type\_keyval, void~*extra\_state)}
-\mpifnewbind{MPI\_Type\_create\_keyval(type\_copy\_attr\_fn, type\_delete\_attr\_fn, type\_keyval, extra\_state, ierror) BIND(C) \fargs PROCEDURE(MPI\_Type\_copy\_attr\_function) :: type\_copy\_attr\_fn \\ PROCEDURE(MPI\_Type\_delete\_attr\_function) :: type\_delete\_attr\_fn \\ INTEGER, INTENT(OUT) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_keyval(type\_copy\_attr\_fn, type\_delete\_attr\_fn, type\_keyval, extra\_state, ierror) \fargs PROCEDURE(MPI\_Type\_copy\_attr\_function) :: type\_copy\_attr\_fn \\ PROCEDURE(MPI\_Type\_delete\_attr\_function) :: type\_delete\_attr\_fn \\ INTEGER, INTENT(OUT) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_KEYVAL(TYPE\_COPY\_ATTR\_FN, TYPE\_DELETE\_ATTR\_FN, TYPE\_KEYVAL, EXTRA\_STATE, IERROR)\fargs EXTERNAL TYPE\_COPY\_ATTR\_FN, TYPE\_DELETE\_ATTR\_FN\\INTEGER TYPE\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE}
\mpicppemptybind{MPI::Datatype::Create\_keyval(MPI::Datatype::Copy\_attr\_function* type\_copy\_attr\_fn, MPI::Datatype::Delete\_attr\_function* type\_delete\_attr\_fn, void*~extra\_state)}{static int}
@@ -3159,10 +3159,10 @@
% C binding for MPI_TYPE_DUP_FN
\mpibind{MPI\_TYPE\_DUP\_FN(MPI\_Datatype~oldtype, int~type\_keyval, void~*extra\_state, void~*attribute\_val\_in, void~*attribute\_val\_out, int~*flag)}
% Fortran binding for MPI_TYPE_NULL_COPY_FN
-\mpifnewbind{MPI\_TYPE\_NULL\_COPY\_FN(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_TYPE\_NULL\_COPY\_FN(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_NULL\_COPY\_FN(OLDTYPE, TYPE\_KEYVAL, EXTRA\_STATE, ATTRIBUTE\_VAL\_IN, ATTRIBUTE\_VAL\_OUT, FLAG, IERROR)\fargs INTEGER OLDTYPE, TYPE\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE, ATTRIBUTE\_VAL\_IN,\\ \ \ \ \ ATTRIBUTE\_VAL\_OUT\\LOGICAL FLAG}
% Fortran binding for MPI_TYPE_DUP_FN
-\mpifnewbind{MPI\_TYPE\_DUP\_FN(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_TYPE\_DUP\_FN(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state, attribute\_val\_in \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val\_out \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_DUP\_FN(OLDTYPE, TYPE\_KEYVAL, EXTRA\_STATE, ATTRIBUTE\_VAL\_IN, ATTRIBUTE\_VAL\_OUT, FLAG, IERROR)\fargs INTEGER OLDTYPE, TYPE\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE, ATTRIBUTE\_VAL\_IN,\\ \ \ \ \ ATTRIBUTE\_VAL\_OUT\\LOGICAL FLAG}
% C++ binding for MPI_TYPE_NULL_COPY_FN
%%-74.l-- \mpicppemptybind{MPI\_TYPE\_NULL\_COPY\_FN(const~MPI::Datatype\&~oldtype, int~type\_keyval, void*~extra\_state, void*~attribute\_val\_in, void*~attribute\_val\_out, bool\&~flag)}{int}
@@ -3185,7 +3185,7 @@
% C binding for MPI_TYPE_NULL_DELETE_FN
\mpibind{MPI\_TYPE\_NULL\_DELETE\_FN(MPI\_Datatype datatype, int type\_keyval, void *attribute\_val, void *extra\_state)}
% Fortran binding for MPI_TYPE_NULL_DELETE_FN
-\mpifnewbind{MPI\_TYPE\_NULL\_DELETE\_FN(datatype, type\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val, extra\_state \\ INTEGER, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_TYPE\_NULL\_DELETE\_FN(datatype, type\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val, extra\_state \\ INTEGER, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_NULL\_DELETE\_FN(DATATYPE, TYPE\_KEYVAL, ATTRIBUTE\_VAL, EXTRA\_STATE, IERROR)\fargs INTEGER DATATYPE, TYPE\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL, EXTRA\_STATE}
% C++ binding for MPI_TYPE_NULL_DELETE_FN
%%-74.l-- \mpicppemptybind{MPI\_TYPE\_NULL\_DELETE\_FN(MPI::Datatype\&~{data}type, int~type\_keyval, void*~attribute\_val, void*~extra\_state)}{int}
@@ -3205,12 +3205,12 @@
\noindent
With the \code{mpi\_f08} module, the Fortran callback functions are:
-\mpifnewsubbind{MPI\_Type\_copy\_attr\_function(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) BIND(C) \fargs TYPE(MPI\_Datatype) :: oldtype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
+\mpifnewsubbind{MPI\_Type\_copy\_attr\_function(oldtype, type\_keyval, extra\_state, attribute\_val\_in, attribute\_val\_out, flag, ierror) \fargs TYPE(MPI\_Datatype) :: oldtype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state, attribute\_val\_in, attribute\_val\_out \\ LOGICAL :: flag }
\noindent
and
-\mpifnewsubbind{MPI\_Type\_delete\_attr\_function(datatype, type\_keyval, attribute\_val, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
+\mpifnewsubbind{MPI\_Type\_delete\_attr\_function(datatype, type\_keyval, attribute\_val, extra\_state, ierror) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: type\_keyval, ierror \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: attribute\_val, extra\_state }
\noindent
With the \code{mpi} module and \code{mpif.h}, the Fortran callback functions are:
@@ -3232,7 +3232,7 @@
\mpibind{MPI\_Type\_free\_keyval(int *type\_keyval)}
-\mpifnewbind{MPI\_Type\_free\_keyval(type\_keyval, ierror) BIND(C) \fargs INTEGER, INTENT(INOUT) :: type\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_free\_keyval(type\_keyval, ierror) \fargs INTEGER, INTENT(INOUT) :: type\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_FREE\_KEYVAL(TYPE\_KEYVAL, IERROR)\fargs INTEGER TYPE\_KEYVAL, IERROR}
\mpicppemptybind{MPI::Datatype::Free\_keyval(int\& type\_keyval)}{static void}
@@ -3245,7 +3245,7 @@
\mpibind{MPI\_Type\_set\_attr(MPI\_Datatype~datatype, int~type\_keyval, void~*attribute\_val)}
-\mpifnewbind{MPI\_Type\_set\_attr(datatype, type\_keyval, attribute\_val, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_set\_attr(datatype, type\_keyval, attribute\_val, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: attribute\_val \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_SET\_ATTR(DATATYPE, TYPE\_KEYVAL, ATTRIBUTE\_VAL, IERROR)\fargs INTEGER DATATYPE, TYPE\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL}
\mpicppemptybind{MPI::Datatype::Set\_attr(int type\_keyval, const void* attribute\_val)}{void}
@@ -3261,7 +3261,7 @@
\mpibind{MPI\_Type\_get\_attr(MPI\_Datatype datatype, int type\_keyval, void *attribute\_val, int *flag)}
-\mpifnewbind{MPI\_Type\_get\_attr(datatype, type\_keyval, attribute\_val, flag, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_attr(datatype, type\_keyval, attribute\_val, flag, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: attribute\_val \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_ATTR(DATATYPE, TYPE\_KEYVAL, ATTRIBUTE\_VAL, FLAG, IERROR)\fargs INTEGER DATATYPE, TYPE\_KEYVAL, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ATTRIBUTE\_VAL\\LOGICAL FLAG}
\mpicppemptybind{MPI::Datatype::Get\_attr(int type\_keyval, void* attribute\_val) const}{bool}
@@ -3273,7 +3273,7 @@
\mpibind{MPI\_Type\_delete\_attr(MPI\_Datatype datatype, int type\_keyval)}
-\mpifnewbind{MPI\_Type\_delete\_attr(datatype, type\_keyval, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_delete\_attr(datatype, type\_keyval, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: type\_keyval \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_DELETE\_ATTR(DATATYPE, TYPE\_KEYVAL, IERROR)\fargs INTEGER DATATYPE, TYPE\_KEYVAL, IERROR}
\mpicppemptybind{MPI::Datatype::Delete\_attr(int type\_keyval)}{void}
@@ -3440,7 +3440,7 @@
\mpibind{MPI\_Comm\_set\_name(MPI\_Comm comm, const char *comm\_name)}
-\mpifnewbind{MPI\_Comm\_set\_name(comm, comm\_name, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ CHARACTER(LEN=*), INTENT(IN) :: comm\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_set\_name(comm, comm\_name, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ CHARACTER(LEN=*), INTENT(IN) :: comm\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SET\_NAME(COMM, COMM\_NAME, IERROR) \fargs INTEGER COMM, IERROR\\ CHARACTER*(*) COMM\_NAME}
\mpicppemptybind{MPI::Comm::Set\_name(const char* comm\_name)}{void}
@@ -3498,7 +3498,7 @@
\mpibind{MPI\_Comm\_get\_name(MPI\_Comm comm, char *comm\_name, int *resultlen)}
-\mpifnewbind{MPI\_Comm\_get\_name(comm, comm\_name, resultlen, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ CHARACTER(LEN=MPI\_MAX\_OBJECT\_NAME), INTENT(OUT) :: comm\_name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_get\_name(comm, comm\_name, resultlen, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ CHARACTER(LEN=MPI\_MAX\_OBJECT\_NAME), INTENT(OUT) :: comm\_name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_GET\_NAME(COMM, COMM\_NAME, RESULTLEN, IERROR) \fargs INTEGER COMM, RESULTLEN, IERROR\\ CHARACTER*(*) COMM\_NAME}
\mpicppemptybind{MPI::Comm::Get\_name(char* comm\_name, int\& resultlen) const}{void}
@@ -3581,7 +3581,7 @@
\mpibind{MPI\_Type\_set\_name(MPI\_Datatype datatype, const char *type\_name)}
-\mpifnewbind{MPI\_Type\_set\_name(datatype, type\_name, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ CHARACTER(LEN=*), INTENT(IN) :: type\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_set\_name(datatype, type\_name, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ CHARACTER(LEN=*), INTENT(IN) :: type\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_SET\_NAME(DATATYPE, TYPE\_NAME, IERROR) \fargs INTEGER DATATYPE, IERROR\\ CHARACTER*(*) TYPE\_NAME}
\mpicppemptybind{MPI::Datatype::Set\_name(const char* type\_name)}{void}
@@ -3595,7 +3595,7 @@
\mpibind{MPI\_Type\_get\_name(MPI\_Datatype datatype, char *type\_name, int *resultlen)}
-\mpifnewbind{MPI\_Type\_get\_name(datatype, type\_name, resultlen, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ CHARACTER(LEN=MPI\_MAX\_OBJECT\_NAME), INTENT(OUT) :: type\_name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_name(datatype, type\_name, resultlen, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ CHARACTER(LEN=MPI\_MAX\_OBJECT\_NAME), INTENT(OUT) :: type\_name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_NAME(DATATYPE, TYPE\_NAME, RESULTLEN, IERROR) \fargs INTEGER DATATYPE, RESULTLEN, IERROR\\ CHARACTER*(*) TYPE\_NAME}
\mpicppemptybind{MPI::Datatype::Get\_name(char* type\_name, int\& resultlen) const}{void}
@@ -3615,7 +3615,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_set\_name(MPI\_Win win, const char *win\_name)}
-\mpifnewbind{MPI\_Win\_set\_name(win, win\_name, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ CHARACTER(LEN=*), INTENT(IN) :: win\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_set\_name(win, win\_name, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ CHARACTER(LEN=*), INTENT(IN) :: win\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_SET\_NAME(WIN, WIN\_NAME, IERROR) \fargs INTEGER WIN, IERROR\\ CHARACTER*(*) WIN\_NAME}
\mpicppemptybind{MPI::Win::Set\_name(const char* win\_name)}{void}
@@ -3630,7 +3630,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_get\_name(MPI\_Win win, char *win\_name, int *resultlen)}
-\mpifnewbind{MPI\_Win\_get\_name(win, win\_name, resultlen, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ CHARACTER(LEN=MPI\_MAX\_OBJECT\_NAME), INTENT(OUT) :: win\_name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_get\_name(win, win\_name, resultlen, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ CHARACTER(LEN=MPI\_MAX\_OBJECT\_NAME), INTENT(OUT) :: win\_name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_GET\_NAME(WIN, WIN\_NAME, RESULTLEN, IERROR) \fargs INTEGER WIN, RESULTLEN, IERROR\\ CHARACTER*(*) WIN\_NAME}
\mpicppemptybind{MPI::Win::Get\_name(char* win\_name, int\& resultlen) const}{void}
Raw
mpi31-r1835-chap-datatypes.diff
Index: chap-datatypes/datatypes.tex
===================================================================
--- chap-datatypes/datatypes.tex (revision 1834)
+++ chap-datatypes/datatypes.tex (revision 1835)
@@ -213,7 +213,7 @@
\cdeclmainindex{MPI\_Datatype}%
\mpibind{MPI\_Type\_contiguous(int~count, MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_contiguous(count, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_contiguous(count, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CONTIGUOUS(COUNT, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER COUNT, OLDTYPE, NEWTYPE, IERROR}
\mpicppemptybind{MPI::Datatype::Create\_contiguous(int~count) const}{MPI::Datatype}
@@ -282,7 +282,7 @@
\mpibind{MPI\_Type\_vector(int~count, int~blocklength, int~stride, MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_vector(count, blocklength, stride, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, blocklength, stride \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_vector(count, blocklength, stride, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count, blocklength, stride \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_VECTOR(COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR}
\mpicppemptybind{MPI::Datatype::Create\_vector(int~count, int~blocklength, int~stride) const}{MPI::Datatype}
@@ -404,7 +404,7 @@
\mpibind{MPI\_Type\_create\_hvector(int~count, int~blocklength, MPI\_Aint~stride, MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
% \mpifbind{MPI\_TYPE\_CREATE\_HVECTOR(COUNT, BLOCKLENGTH, STIDE, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER COUNT, BLOCKLENGTH, OLDTYPE, NEWTYPE, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) STRIDE}
-\mpifnewbind{MPI\_Type\_create\_hvector(count, blocklength, stride, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, blocklength \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: stride \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_hvector(count, blocklength, stride, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count, blocklength \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: stride \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_HVECTOR(COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER COUNT, BLOCKLENGTH, OLDTYPE, NEWTYPE, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) STRIDE}
\mpicppemptybind{MPI::Datatype::Create\_hvector(int count, int blocklength, MPI::Aint stride) const}{MPI::Datatype}
@@ -482,7 +482,7 @@
\mpibind{MPI\_Type\_indexed(int~count, const int~array\_of\_blocklengths[], const int~array\_of\_displacements[], MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_indexed(count, array\_of\_blocklengths, array\_of\_displacements, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, array\_of\_blocklengths(count), array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_indexed(count, array\_of\_blocklengths, array\_of\_displacements, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count, array\_of\_blocklengths(count), array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_INDEXED(COUNT, ARRAY\_OF\_BLOCKLENGTHS, ARRAY\_OF\_DISPLACEMENTS, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER COUNT, ARRAY\_OF\_BLOCKLENGTHS(*), ARRAY\_OF\_DISPLACEMENTS(*), OLDTYPE, NEWTYPE, IERROR}
\mpicppemptybind{MPI::Datatype::Create\_indexed(int~count, const~int~array\_of\_blocklengths[], const~int~array\_of\_displacements[]) const}{MPI::Datatype}
@@ -583,7 +583,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Type\_create\_hindexed(int~count, const int~array\_of\_blocklengths[], const MPI\_Aint~array\_of\_displacements[], MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_create\_hindexed(count, array\_of\_blocklengths, array\_of\_displacements, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, array\_of\_blocklengths(count) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_hindexed(count, array\_of\_blocklengths, array\_of\_displacements, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count, array\_of\_blocklengths(count) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_HINDEXED(COUNT, ARRAY\_OF\_BLOCKLENGTHS, ARRAY\_OF\_DISPLACEMENTS, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER COUNT, ARRAY\_OF\_BLOCKLENGTHS(*), OLDTYPE, NEWTYPE, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ARRAY\_OF\_DISPLACEMENTS(*)}
\mpicppemptybind{MPI::Datatype::Create\_hindexed(int count, const~int~array\_of\_blocklengths[], const~MPI::Aint~array\_of\_displacements[]) const}{MPI::Datatype}
@@ -649,7 +649,7 @@
\mpibind{MPI\_Type\_create\_indexed\_block(int~count, int~blocklength, const int~array\_of\_displacements[], MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_create\_indexed\_block(count, blocklength, array\_of\_displacements, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, blocklength, array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_indexed\_block(count, blocklength, array\_of\_displacements, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count, blocklength, array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_INDEXED\_BLOCK(COUNT, BLOCKLENGTH, ARRAY\_OF\_DISPLACEMENTS, OLDTYPE, NEWTYPE, IERROR) \fargs INTEGER COUNT, BLOCKLENGTH, ARRAY\_OF\_DISPLACEMENTS(*), OLDTYPE, NEWTYPE, IERROR}
@@ -676,7 +676,7 @@
\mpibind{MPI\_Type\_create\_hindexed\_block(int~count, int~blocklength, const MPI\_Aint~array\_of\_displacements[], MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_create\_hindexed\_block(count, blocklength, array\_of\_displacements, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, blocklength \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_hindexed\_block(count, blocklength, array\_of\_displacements, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count, blocklength \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_HINDEXED\_BLOCK(COUNT, BLOCKLENGTH, ARRAY\_OF\_DISPLACEMENTS, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER COUNT, BLOCKLENGTH, OLDTYPE, NEWTYPE, IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ARRAY\_OF\_DISPLACEMENTS(*)}
\paragraph*{Struct}
@@ -706,7 +706,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Type\_create\_struct(int~count, const int~array\_of\_blocklengths[], const MPI\_Aint~array\_of\_displacements[], const MPI\_Datatype~array\_of\_types[], MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_create\_struct(count, array\_of\_blocklengths, array\_of\_displacements, array\_of\_types, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, array\_of\_blocklengths(count) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: array\_of\_types(count) \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_struct(count, array\_of\_blocklengths, array\_of\_displacements, array\_of\_types, newtype, ierror) \fargs INTEGER, INTENT(IN) :: count, array\_of\_blocklengths(count) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: array\_of\_displacements(count) \\ TYPE(MPI\_Datatype), INTENT(IN) :: array\_of\_types(count) \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_STRUCT(COUNT, ARRAY\_OF\_BLOCKLENGTHS, ARRAY\_OF\_DISPLACEMENTS, ARRAY\_OF\_TYPES, NEWTYPE, IERROR)\fargs INTEGER COUNT, ARRAY\_OF\_BLOCKLENGTHS(*), ARRAY\_OF\_TYPES(*), NEWTYPE, IERROR\\ INTEGER(KIND=MPI\_ADDRESS\_KIND) ARRAY\_OF\_DISPLACEMENTS(*)}
\mpicppemptybind{MPI::Datatype::Create\_struct(int count, const~int~array\_of\_blocklengths[], const~MPI::Aint array\_of\_displacements[], const~MPI::Datatype~array\_of\_types[])}{static MPI::Datatype}
@@ -812,7 +812,7 @@
% JMS-apr
\mpibind{MPI\_Type\_create\_subarray(int ndims, const int~array\_of\_sizes[], const int~array\_of\_subsizes[], const int~array\_of\_starts[], int order, MPI\_Datatype oldtype, MPI\_Datatype~*newtype)}
% JMS-apr
-\mpifnewbind{MPI\_Type\_create\_subarray(ndims, array\_of\_sizes, array\_of\_subsizes, array\_of\_starts, order, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: ndims, array\_of\_sizes(ndims), array\_of\_subsizes(ndims), array\_of\_starts(ndims), order \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_subarray(ndims, array\_of\_sizes, array\_of\_subsizes, array\_of\_starts, order, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: ndims, array\_of\_sizes(ndims), array\_of\_subsizes(ndims), array\_of\_starts(ndims), order \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_SUBARRAY(NDIMS, ARRAY\_OF\_SIZES, ARRAY\_OF\_SUBSIZES, ARRAY\_OF\_STARTS, ORDER, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER NDIMS, ARRAY\_OF\_SIZES(*), ARRAY\_OF\_SUBSIZES(*), ARRAY\_OF\_STARTS(*), ORDER, OLDTYPE, NEWTYPE, IERROR}
% JMS-apr
\mpicppemptybind{MPI::Datatype::Create\_subarray(int~ndims, const~int~array\_of\_sizes[], const~int~array\_of\_subsizes[], const~int~array\_of\_starts[], int~order) const}{MPI::Datatype}
@@ -1000,7 +1000,7 @@
% JMS-apr
\mpibind{MPI\_Type\_create\_darray(int~size, int~rank, int~ndims, const int~array\_of\_gsizes[], const int~array\_of\_distribs[], const int array\_of\_dargs[], const int array\_of\_psizes[], int order, MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
% JMS-apr
-\mpifnewbind{MPI\_Type\_create\_darray(size, rank, ndims, array\_of\_gsizes, array\_of\_distribs, array\_of\_dargs, array\_of\_psizes, order, oldtype, newtype, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: size, rank, ndims, array\_of\_gsizes(ndims), array\_of\_distribs(ndims), array\_of\_dargs(ndims), array\_of\_psizes(ndims), order \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_darray(size, rank, ndims, array\_of\_gsizes, array\_of\_distribs, array\_of\_dargs, array\_of\_psizes, order, oldtype, newtype, ierror) \fargs INTEGER, INTENT(IN) :: size, rank, ndims, array\_of\_gsizes(ndims), array\_of\_distribs(ndims), array\_of\_dargs(ndims), array\_of\_psizes(ndims), order \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_DARRAY(SIZE, RANK, NDIMS, ARRAY\_OF\_GSIZES, ARRAY\_OF\_DISTRIBS, ARRAY\_OF\_DARGS, ARRAY\_OF\_PSIZES, ORDER, OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER SIZE, RANK, NDIMS, ARRAY\_OF\_GSIZES(*), ARRAY\_OF\_DISTRIBS(*), ARRAY\_OF\_DARGS(*), ARRAY\_OF\_PSIZES(*), ORDER, OLDTYPE, NEWTYPE, IERROR}
% JMS-apr
\mpicppemptybind{MPI::Datatype::Create\_darray(int~size, int~rank, int~ndims, const~int~array\_of\_gsizes[], const~int~array\_of\_distribs[], const~int~array\_of\_dargs[], const~int~array\_of\_psizes[], int~order) const}{MPI::Datatype}
@@ -1324,7 +1324,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Get\_address(const void~*location, MPI\_Aint~*address)}
-\mpifnewbind{MPI\_Get\_address(location, address, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: location \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: address \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_address(location, address, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: location \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: address \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_ADDRESS(LOCATION, ADDRESS, IERROR)\fargs <type> LOCATION(*) \\ INTEGER IERROR\\INTEGER(KIND=MPI\_ADDRESS\_KIND) ADDRESS}
\mpicppemptybind{MPI::Get\_address(void* location)}{MPI::Aint}
@@ -1419,7 +1419,7 @@
\mpibind{MPI\_Type\_size(MPI\_Datatype~datatype, int~*size)}
-\mpifnewbind{MPI\_Type\_size(datatype, size, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_size(datatype, size, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_SIZE(DATATYPE, SIZE, IERROR)\fargs INTEGER DATATYPE, SIZE, IERROR}
\mpicppemptybind{MPI::Datatype::Get\_size() const}{int}
@@ -1430,7 +1430,7 @@
\mpibind{MPI\_Type\_size\_x(MPI\_Datatype~datatype, MPI\_Count~*size)}
-\mpifnewbind{MPI\_Type\_size\_x(datatype, size, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_COUNT\_KIND), INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_size\_x(datatype, size, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_COUNT\_KIND), INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_SIZE\_X(DATATYPE, SIZE, IERROR)\fargs INTEGER DATATYPE, IERROR\\ INTEGER(KIND = MPI\_COUNT\_KIND) SIZE}
\mpifunc{MPI\_TYPE\_SIZE} and \mpifunc{MPI\_TYPE\_SIZE\_X} set the value of \mpiarg{size} to the total size, in bytes, of the entries in
@@ -1569,7 +1569,7 @@
%%LANG: FORTRAN08
%%ENDHEADER
\begin{verbatim}
- TYPE, BIND(C) :: my_data
+ TYPE, :: my_data
REAL, DIMENSION(3) :: x
! there may be a gap of the size of one REAL
! if the alignment of a DOUBLE PRECISION is
@@ -1585,7 +1585,7 @@
%%LANG: FORTRAN08
%%ENDHEADER
\begin{verbatim}
- TYPE, BIND(C) :: my_data
+ TYPE, :: my_data
REAL, DIMENSION(3) :: x
REAL :: gap1
DOUBLE PRECISION :: p
@@ -1621,7 +1621,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Type\_get\_extent(MPI\_Datatype datatype, MPI\_Aint~*lb, MPI\_Aint~*extent)}
-\mpifnewbind{MPI\_Type\_get\_extent(datatype, lb, extent, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: lb, extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_extent(datatype, lb, extent, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: lb, extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_EXTENT(DATATYPE, LB, EXTENT, IERROR)\fargs INTEGER DATATYPE, IERROR\\INTEGER(KIND = MPI\_ADDRESS\_KIND) LB, EXTENT}
@@ -1635,7 +1635,7 @@
\mpibind{MPI\_Type\_get\_extent\_x(MPI\_Datatype datatype, MPI\_Count~*lb, MPI\_Count~*extent)}
-\mpifnewbind{MPI\_Type\_get\_extent\_x(datatype, lb, extent, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(OUT) :: lb, extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_extent\_x(datatype, lb, extent, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(OUT) :: lb, extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_EXTENT\_X(DATATYPE, LB, EXTENT, IERROR)\fargs INTEGER DATATYPE, IERROR\\INTEGER(KIND = MPI\_COUNT\_KIND) LB, EXTENT}
Returns the lower bound and the extent of
@@ -1663,7 +1663,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Type\_create\_resized(MPI\_Datatype oldtype, MPI\_Aint lb, MPI\_Aint extent, MPI\_Datatype *newtype)}
-\mpifnewbind{MPI\_Type\_create\_resized(oldtype, lb, extent, newtype, ierror) BIND(C) \fargs INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: lb, extent \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_create\_resized(oldtype, lb, extent, newtype, ierror) \fargs INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: lb, extent \\ TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_CREATE\_RESIZED(OLDTYPE, LB, EXTENT, NEWTYPE, IERROR)\fargs INTEGER OLDTYPE, NEWTYPE, IERROR\\ INTEGER(KIND=MPI\_ADDRESS\_KIND) LB, EXTENT}
\mpicppemptybind{MPI::Datatype::Create\_resized(const~MPI::Aint~lb, const~MPI::Aint~extent) const}{MPI::Datatype}
@@ -1704,7 +1704,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Type\_get\_true\_extent(MPI\_Datatype datatype, MPI\_Aint *true\_lb, MPI\_Aint *true\_extent)}
-\mpifnewbind{MPI\_Type\_get\_true\_extent(datatype, true\_lb, true\_extent, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: true\_lb, true\_extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_true\_extent(datatype, true\_lb, true\_extent, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: true\_lb, true\_extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_TRUE\_EXTENT(DATATYPE, TRUE\_LB, TRUE\_EXTENT, IERROR)\fargs INTEGER DATATYPE, IERROR\\ INTEGER(KIND = MPI\_ADDRESS\_KIND) TRUE\_LB, TRUE\_EXTENT}
@@ -1719,7 +1719,7 @@
\mpibind{MPI\_Type\_get\_true\_extent\_x(MPI\_Datatype datatype, MPI\_Count *true\_lb, MPI\_Count *true\_extent)}
-\mpifnewbind{MPI\_Type\_get\_true\_extent\_x(datatype, true\_lb, true\_extent, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(OUT) :: true\_lb, true\_extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_true\_extent\_x(datatype, true\_lb, true\_extent, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(OUT) :: true\_lb, true\_extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_TRUE\_EXTENT\_X(DATATYPE, TRUE\_LB, TRUE\_EXTENT, IERROR)\fargs INTEGER DATATYPE, IERROR\\ INTEGER(KIND = MPI\_COUNT\_KIND) TRUE\_LB, TRUE\_EXTENT}
@@ -1775,7 +1775,7 @@
\mpibind{MPI\_Type\_commit(MPI\_Datatype~*datatype)}
-\mpifnewbind{MPI\_Type\_commit(datatype, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(INOUT) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_commit(datatype, ierror) \fargs TYPE(MPI\_Datatype), INTENT(INOUT) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_COMMIT(DATATYPE, IERROR)\fargs INTEGER DATATYPE, IERROR}
\mpicppemptybind{MPI::Datatype::Commit()}{void}
@@ -1831,7 +1831,7 @@
\mpibind{MPI\_Type\_free(MPI\_Datatype~*datatype)}
-\mpifnewbind{MPI\_Type\_free(datatype, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(INOUT) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_free(datatype, ierror) \fargs TYPE(MPI\_Datatype), INTENT(INOUT) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_FREE(DATATYPE, IERROR)\fargs INTEGER DATATYPE, IERROR}
\mpicppemptybind{MPI::Datatype::Free()}{void}
@@ -1864,7 +1864,7 @@
\mpibind{MPI\_Type\_dup(MPI\_Datatype~oldtype, MPI\_Datatype~*newtype)}
-\mpifnewbind{MPI\_Type\_dup(oldtype, newtype, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_dup(oldtype, newtype, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: oldtype \\ TYPE(MPI\_Datatype), INTENT(OUT) :: newtype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_DUP(OLDTYPE, NEWTYPE, IERROR)\fargs INTEGER OLDTYPE, NEWTYPE, IERROR}
\mpicppemptybind{MPI::Datatype::Dup() const}{MPI::Datatype}
@@ -2012,7 +2012,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Get\_elements(const MPI\_Status~*status, MPI\_Datatype~datatype, int~*count)}
-\mpifnewbind{MPI\_Get\_elements(status, datatype, count, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_elements(status, datatype, count, ierror) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_ELEMENTS(STATUS, DATATYPE, COUNT, IERROR)\fargs INTEGER STATUS(MPI\_STATUS\_SIZE), DATATYPE, COUNT, IERROR}
\mpicppemptybind{MPI::Status::Get\_elements(const~MPI::Datatype\&~datatype) const}{int}
@@ -2027,7 +2027,7 @@
\mpibind{MPI\_Get\_elements\_x(const MPI\_Status~*status, MPI\_Datatype~datatype, MPI\_Count~*count)}
%\mpibind{MPI\_Get\_elements\_x({const }MPI\_Status~*status, MPI\_Datatype~datatype, MPI\_Count~*count)}
-\mpifnewbind{MPI\_Get\_elements\_x(status, datatype, count, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(OUT) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_elements\_x(status, datatype, count, ierror) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(OUT) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_ELEMENTS\_X(STATUS, DATATYPE, COUNT, IERROR)\fargs INTEGER STATUS(MPI\_STATUS\_SIZE), DATATYPE, IERROR\\INTEGER(KIND=MPI\_COUNT\_KIND) COUNT}
The \mpiarg{datatype} argument should match the argument provided by the
@@ -2238,7 +2238,7 @@
\mpibind{MPI\_Type\_get\_envelope(MPI\_Datatype~datatype, int~*num\_integers, int~*num\_addresses, int~*num\_datatypes, int~*combiner)}
-\mpifnewbind{MPI\_Type\_get\_envelope(datatype, num\_integers, num\_addresses, num\_datatypes, combiner, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: num\_integers, num\_addresses, num\_datatypes, combiner \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_envelope(datatype, num\_integers, num\_addresses, num\_datatypes, combiner, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: num\_integers, num\_addresses, num\_datatypes, combiner \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_ENVELOPE(DATATYPE, NUM\_INTEGERS, NUM\_ADDRESSES, NUM\_DATATYPES, COMBINER, IERROR)\fargs INTEGER DATATYPE, NUM\_INTEGERS, NUM\_ADDRESSES, NUM\_DATATYPES, COMBINER, IERROR}
\mpicppemptybind{MPI::Datatype::Get\_envelope(int\&~num\_integers, int\&~num\_addresses, int\&~num\_datatypes, int\&~combiner) const}{void}
@@ -2325,7 +2325,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Type\_get\_contents(MPI\_Datatype~datatype, int~max\_integers, int~max\_addresses, int~max\_datatypes, int~array\_of\_integers[], MPI\_Aint~array\_of\_addresses[], MPI\_Datatype~array\_of\_datatypes[])}
-\mpifnewbind{MPI\_Type\_get\_contents(datatype, max\_integers, max\_addresses, max\_datatypes, array\_of\_integers, array\_of\_addresses, array\_of\_datatypes, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: max\_integers, max\_addresses, max\_datatypes \\ INTEGER, INTENT(OUT) :: array\_of\_integers(max\_integers) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: array\_of\_addresses(max\_addresses) \\ TYPE(MPI\_Datatype), INTENT(OUT) :: array\_of\_datatypes(max\_datatypes) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Type\_get\_contents(datatype, max\_integers, max\_addresses, max\_datatypes, array\_of\_integers, array\_of\_addresses, array\_of\_datatypes, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: max\_integers, max\_addresses, max\_datatypes \\ INTEGER, INTENT(OUT) :: array\_of\_integers(max\_integers) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: array\_of\_addresses(max\_addresses) \\ TYPE(MPI\_Datatype), INTENT(OUT) :: array\_of\_datatypes(max\_datatypes) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TYPE\_GET\_CONTENTS(DATATYPE, MAX\_INTEGERS, MAX\_ADDRESSES, MAX\_DATATYPES, ARRAY\_OF\_INTEGERS, ARRAY\_OF\_ADDRESSES, ARRAY\_OF\_DATATYPES, IERROR)\fargs INTEGER DATATYPE, MAX\_INTEGERS, MAX\_ADDRESSES, MAX\_DATATYPES, ARRAY\_OF\_INTEGERS(*), ARRAY\_OF\_DATATYPES(*), IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) ARRAY\_OF\_ADDRESSES(*)}
\mpicppemptybind{MPI::Datatype::Get\_contents(int~max\_integers, int~max\_addresses, int~max\_datatypes, int~array\_of\_integers[], MPI::Aint~array\_of\_addresses[], MPI::Datatype~array\_of\_datatypes[]) const}{void}
@@ -3320,7 +3320,7 @@
\mpibind{MPI\_Pack(const void*~inbuf, int~incount, MPI\_Datatype~datatype, void~*outbuf, int~outsize, int~*position, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Pack(inbuf, incount, datatype, outbuf, outsize, position, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER, INTENT(IN) :: incount, outsize \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(INOUT) :: position \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Pack(inbuf, incount, datatype, outbuf, outsize, position, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER, INTENT(IN) :: incount, outsize \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(INOUT) :: position \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_PACK(INBUF, INCOUNT, DATATYPE, OUTBUF, OUTSIZE, POSITION, COMM, IERROR)\fargs <type> INBUF(*), OUTBUF(*)\\ INTEGER INCOUNT, DATATYPE, OUTSIZE, POSITION, COMM, IERROR}
\mpicppemptybind{MPI::Datatype::Pack(const void*~inbuf, int~incount, void~*outbuf, int~outsize, int\&~position, const~MPI::Comm~\&comm) const}{void}
@@ -3358,7 +3358,7 @@
\mpibind{MPI\_Unpack(const void*~inbuf, int~insize, int~*position, void~*outbuf, int~outcount, MPI\_Datatype~datatype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Unpack(inbuf, insize, position, outbuf, outcount, datatype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER, INTENT(IN) :: insize, outcount \\ INTEGER, INTENT(INOUT) :: position \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Unpack(inbuf, insize, position, outbuf, outcount, datatype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER, INTENT(IN) :: insize, outcount \\ INTEGER, INTENT(INOUT) :: position \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_UNPACK(INBUF, INSIZE, POSITION, OUTBUF, OUTCOUNT, DATATYPE, COMM, IERROR)\fargs <type> INBUF(*), OUTBUF(*) \\ INTEGER INSIZE, POSITION, OUTCOUNT, DATATYPE, COMM, IERROR}
\mpicppemptybind{MPI::Datatype::Unpack(const void*~inbuf, int~insize, void~*outbuf, int~outcount, int\&~position, const~MPI::Comm\&~comm) const}{void}
@@ -3473,7 +3473,7 @@
\mpibind{MPI\_Pack\_size(int~incount, MPI\_Datatype~datatype, MPI\_Comm~comm, int~*size)}
-\mpifnewbind{MPI\_Pack\_size(incount, datatype, comm, size, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Pack\_size(incount, datatype, comm, size, ierror) \fargs INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_PACK\_SIZE(INCOUNT, DATATYPE, COMM, SIZE, IERROR)\fargs INTEGER INCOUNT, DATATYPE, COMM, SIZE, IERROR}
\mpicppemptybind{MPI::Datatype::Pack\_size(int~incount, const MPI::Comm\&~comm) const}{int}
@@ -3719,7 +3719,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Pack\_external(const char~datarep[], const void *inbuf, int incount, MPI\_Datatype~datatype, void~*outbuf, MPI\_Aint~outsize, MPI\_Aint~*position)}
-\mpifnewbind{MPI\_Pack\_external(datarep, inbuf, incount, datatype, outbuf, outsize, position, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: datarep \\ TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: outsize \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(INOUT) :: position \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Pack\_external(datarep, inbuf, incount, datatype, outbuf, outsize, position, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: datarep \\ TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: outsize \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(INOUT) :: position \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_PACK\_EXTERNAL(DATAREP, INBUF, INCOUNT, DATATYPE, OUTBUF, OUTSIZE, POSITION, IERROR)\fargs INTEGER INCOUNT, DATATYPE, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) OUTSIZE, POSITION \\CHARACTER*(*) DATAREP \\ <type> INBUF(*), OUTBUF(*)}
\mpicppemptybind{MPI::Datatype::Pack\_external(const~char*~datarep, const void*~inbuf, int~incount, void*~outbuf, MPI::Aint~outsize, MPI::Aint\&~position) const}{void}
@@ -3737,7 +3737,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Unpack\_external(const char~datarep[], const void *inbuf, MPI\_Aint~insize, MPI\_Aint~*position, void~*outbuf, int~outcount, MPI\_Datatype~datatype)}
-\mpifnewbind{MPI\_Unpack\_external(datarep, inbuf, insize, position, outbuf, outcount, datatype, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: datarep \\ TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: insize \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(INOUT) :: position \\ INTEGER, INTENT(IN) :: outcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Unpack\_external(datarep, inbuf, insize, position, outbuf, outcount, datatype, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: datarep \\ TYPE(*), DIMENSION(..), INTENT(IN) :: inbuf \\ TYPE(*), DIMENSION(..) :: outbuf \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: insize \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(INOUT) :: position \\ INTEGER, INTENT(IN) :: outcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_UNPACK\_EXTERNAL(DATAREP, INBUF, INSIZE, POSITION, OUTBUF, OUTCOUNT, DATATYPE, IERROR)\fargs INTEGER OUTCOUNT, DATATYPE, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) INSIZE, POSITION \\ CHARACTER*(*) DATAREP \\ <type> INBUF(*), OUTBUF(*)}
\mpicppemptybind{MPI::Datatype::Unpack\_external(const~char*~datarep, const~void*~inbuf, MPI::Aint~insize, MPI::Aint\&~position, void*~outbuf, int~outcount) const }{void}
@@ -3752,7 +3752,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Pack\_external\_size(const char~datarep[], int~incount, MPI\_Datatype~datatype, MPI\_Aint~*size)}
-\mpifnewbind{MPI\_Pack\_external\_size(datarep, incount, datatype, size, ierror) BIND(C) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: incount \\ CHARACTER(LEN=*), INTENT(IN) :: datarep \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Pack\_external\_size(datarep, incount, datatype, size, ierror) \fargs TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: incount \\ CHARACTER(LEN=*), INTENT(IN) :: datarep \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_PACK\_EXTERNAL\_SIZE(DATAREP, INCOUNT, DATATYPE, SIZE, IERROR)\fargs INTEGER INCOUNT, DATATYPE, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) SIZE \\ CHARACTER*(*) DATAREP }
\mpicppemptybind{MPI::Datatype::Pack\_external\_size(const~char*~datarep, int~incount) const}{MPI::Aint}
Raw
mpi31-r1835-chap-dynamic.diff
Index: chap-dynamic/dynamic-2.tex
===================================================================
--- chap-dynamic/dynamic-2.tex (revision 1834)
+++ chap-dynamic/dynamic-2.tex (revision 1835)
@@ -304,7 +304,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Comm\_spawn(const char~*command, char~*argv[], int~maxprocs, MPI\_Info info, int~root, MPI\_Comm~comm, MPI\_Comm~*intercomm, int~array\_of\_errcodes[])}
-\mpifnewbind{MPI\_Comm\_spawn(command, argv, maxprocs, info, root, comm, intercomm, array\_of\_errcodes, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: command, argv(*) \\ INTEGER, INTENT(IN) :: maxprocs, root \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: intercomm \\ INTEGER :: array\_of\_errcodes(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_spawn(command, argv, maxprocs, info, root, comm, intercomm, array\_of\_errcodes, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: command, argv(*) \\ INTEGER, INTENT(IN) :: maxprocs, root \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: intercomm \\ INTEGER :: array\_of\_errcodes(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SPAWN(COMMAND, ARGV, MAXPROCS, INFO, ROOT, COMM, INTERCOMM, ARRAY\_OF\_ERRCODES, IERROR)\fargs CHARACTER*(*) COMMAND, ARGV(*) \\INTEGER INFO, MAXPROCS, ROOT, COMM, INTERCOMM, ARRAY\_OF\_ERRCODES(*), IERROR}
\mpicppemptybind{MPI::Intracomm::Spawn(const~char*~command, const~char*~argv[], int~maxprocs, const~MPI::Info\&~info, int~root, int~array\_of\_errcodes[]) const}{MPI::Intercomm}
\mpicppemptybind{MPI::Intracomm::Spawn(const~char*~command, const~char*~argv[], int~maxprocs, const~MPI::Info\&~info, int~root) const}{MPI::Intercomm}
@@ -596,7 +596,7 @@
\funcarg{\OUT}{parent}{the parent communicator (handle)}
\end{funcdef}
\mpibind{MPI\_Comm\_get\_parent(MPI\_Comm~*parent)}
-\mpifnewbind{MPI\_Comm\_get\_parent(parent, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(OUT) :: parent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_get\_parent(parent, ierror) \fargs TYPE(MPI\_Comm), INTENT(OUT) :: parent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_GET\_PARENT(PARENT, IERROR) \fargs INTEGER PARENT, IERROR}
\mpicppemptybind{MPI::Comm::Get\_parent()}{static MPI::Intercomm}
@@ -665,7 +665,7 @@
\end{funcdef2}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Comm\_spawn\_multiple(int~count, char~*array\_of\_commands[], char~**array\_of\_argv[], const int~array\_of\_maxprocs[], const MPI\_Info~array\_of\_info[], int~root, MPI\_Comm~comm, MPI\_Comm~*intercomm, int~array\_of\_errcodes[])}
-\mpifnewbind{MPI\_Comm\_spawn\_multiple(count, array\_of\_commands, array\_of\_argv, array\_of\_maxprocs, array\_of\_info, root, comm, intercomm, array\_of\_errcodes, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count, array\_of\_maxprocs(*), root \\ CHARACTER(LEN=*), INTENT(IN) :: array\_of\_commands(*) \\ CHARACTER(LEN=*), INTENT(IN) :: array\_of\_argv(count, *) \\ TYPE(MPI\_Info), INTENT(IN) :: array\_of\_info(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: intercomm \\ INTEGER :: array\_of\_errcodes(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_spawn\_multiple(count, array\_of\_commands, array\_of\_argv, array\_of\_maxprocs, array\_of\_info, root, comm, intercomm, array\_of\_errcodes, ierror) \fargs INTEGER, INTENT(IN) :: count, array\_of\_maxprocs(*), root \\ CHARACTER(LEN=*), INTENT(IN) :: array\_of\_commands(*) \\ CHARACTER(LEN=*), INTENT(IN) :: array\_of\_argv(count, *) \\ TYPE(MPI\_Info), INTENT(IN) :: array\_of\_info(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: intercomm \\ INTEGER :: array\_of\_errcodes(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SPAWN\_MULTIPLE(COUNT, ARRAY\_OF\_COMMANDS, ARRAY\_OF\_ARGV, ARRAY\_OF\_MAXPROCS, ARRAY\_OF\_INFO, ROOT, COMM, INTERCOMM, ARRAY\_OF\_ERRCODES, IERROR)\fargs INTEGER COUNT, ARRAY\_OF\_INFO(*), ARRAY\_OF\_MAXPROCS(*), ROOT, COMM, INTERCOMM, ARRAY\_OF\_ERRCODES(*), IERROR \\CHARACTER*(*) ARRAY\_OF\_COMMANDS(*), ARRAY\_OF\_ARGV(COUNT, *)}
\mpicppemptybind{MPI::Intracomm::Spawn\_multiple(int~count, const~char*~array\_of\_commands[], const~char**~array\_of\_argv[], const~int~array\_of\_maxprocs[], const~MPI::Info~array\_of\_info[], int~root, int~array\_of\_errcodes[])}{MPI::Intercomm}
\mpicppemptybind{MPI::Intracomm::Spawn\_multiple(int~count, const~char*~array\_of\_commands[], const~char**~array\_of\_argv[], const~int~array\_of\_maxprocs[], const~MPI::Info~array\_of\_info[], int~root)}{MPI::Intercomm}
@@ -1097,7 +1097,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Open\_port(MPI\_Info~info, char~*port\_name)}
-\mpifnewbind{MPI\_Open\_port(info, port\_name, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=MPI\_MAX\_PORT\_NAME), INTENT(OUT) :: port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Open\_port(info, port\_name, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=MPI\_MAX\_PORT\_NAME), INTENT(OUT) :: port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_OPEN\_PORT(INFO, PORT\_NAME, IERROR)\fargs CHARACTER*(*) PORT\_NAME \\INTEGER INFO, IERROR}
\mpicppemptybind{MPI::Open\_port(const~MPI::Info\&~info, char*~port\_name)}{void}
@@ -1154,7 +1154,7 @@
\funcarg{\IN}{port\_name}{a port (string)}
\end{funcdef}
\mpibind{MPI\_Close\_port(const char~*port\_name)}
-\mpifnewbind{MPI\_Close\_port(port\_name, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Close\_port(port\_name, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CLOSE\_PORT(PORT\_NAME, IERROR)\fargs CHARACTER*(*) PORT\_NAME \\INTEGER IERROR}
\mpicppemptybind{MPI::Close\_port(const~char*~port\_name)}{void}
This function releases the network address represented by
@@ -1174,7 +1174,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Comm\_accept(const char~*port\_name, MPI\_Info~info, int~root, MPI\_Comm~comm, MPI\_Comm~*newcomm)}
-\mpifnewbind{MPI\_Comm\_accept(port\_name, info, root, comm, newcomm, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: port\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(IN) :: root \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_accept(port\_name, info, root, comm, newcomm, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: port\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(IN) :: root \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_ACCEPT(PORT\_NAME, INFO, ROOT, COMM, NEWCOMM, IERROR)\fargs CHARACTER*(*) PORT\_NAME \\INTEGER INFO, ROOT, COMM, NEWCOMM, IERROR}
\mpicppemptybind{MPI::Intracomm::Accept(const~char*~port\_name, const~MPI::Info\&~info, int~root) const}{MPI::Intercomm}
@@ -1212,7 +1212,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Comm\_connect(const char~*port\_name, MPI\_Info~info, int~root, MPI\_Comm~comm, MPI\_Comm~*newcomm)}
-\mpifnewbind{MPI\_Comm\_connect(port\_name, info, root, comm, newcomm, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: port\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(IN) :: root \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_connect(port\_name, info, root, comm, newcomm, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: port\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(IN) :: root \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_CONNECT(PORT\_NAME, INFO, ROOT, COMM, NEWCOMM, IERROR)\fargs CHARACTER*(*) PORT\_NAME \\INTEGER INFO, ROOT, COMM, NEWCOMM, IERROR}
\mpicppemptybind{MPI::Intracomm::Connect(const~char*~port\_name, const~MPI::Info\&~info, int~root) const}{MPI::Intercomm}
@@ -1284,7 +1284,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Publish\_name(const char~*service\_name, MPI\_Info~info, const char~*port\_name)}
-\mpifnewbind{MPI\_Publish\_name(service\_name, info, port\_name, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: service\_name, port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Publish\_name(service\_name, info, port\_name, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: service\_name, port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_PUBLISH\_NAME(SERVICE\_NAME, INFO, PORT\_NAME, IERROR)\fargs INTEGER INFO, IERROR \\CHARACTER*(*) SERVICE\_NAME, PORT\_NAME}
\mpicppemptybind{MPI::Publish\_name(const~char*~service\_name, const~MPI::Info\&~info, const~char*~port\_name)}{void}
@@ -1360,7 +1360,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Unpublish\_name(const char~*service\_name, MPI\_Info~info, const char~*port\_name)}
-\mpifnewbind{MPI\_Unpublish\_name(service\_name, info, port\_name, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: service\_name, port\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Unpublish\_name(service\_name, info, port\_name, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: service\_name, port\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_UNPUBLISH\_NAME(SERVICE\_NAME, INFO, PORT\_NAME, IERROR)\fargs INTEGER INFO, IERROR \\CHARACTER*(*) SERVICE\_NAME, PORT\_NAME}
\mpicppemptybind{MPI::Unpublish\_name(const~char*~service\_name, const~MPI::Info\&~info, const~char*~port\_name)}{void}
@@ -1391,7 +1391,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Lookup\_name(const char~*service\_name, MPI\_Info~info, char~*port\_name)}
-\mpifnewbind{MPI\_Lookup\_name(service\_name, info, port\_name, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: service\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=MPI\_MAX\_PORT\_NAME), INTENT(OUT) :: port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Lookup\_name(service\_name, info, port\_name, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: service\_name \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=MPI\_MAX\_PORT\_NAME), INTENT(OUT) :: port\_name \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_LOOKUP\_NAME(SERVICE\_NAME, INFO, PORT\_NAME, IERROR)\fargs CHARACTER*(*) SERVICE\_NAME, PORT\_NAME \\INTEGER INFO, IERROR}
\mpicppemptybind{MPI::Lookup\_name(const~char*~service\_name, const~MPI::Info\&~info, char*~port\_name)}{void}
@@ -1845,7 +1845,7 @@
\funcarg{\INOUT}{comm}{ communicator (handle)}
\end{funcdef}
\mpibind{MPI\_Comm\_disconnect(MPI\_Comm~*comm)}
-\mpifnewbind{MPI\_Comm\_disconnect(comm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(INOUT) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_disconnect(comm, ierror) \fargs TYPE(MPI\_Comm), INTENT(INOUT) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_DISCONNECT(COMM, IERROR)\fargs INTEGER COMM, IERROR \\}
\mpicppemptybind{MPI::Comm::Disconnect()}{void}
@@ -1889,7 +1889,7 @@
\funcarg{\OUT}{intercomm}{new intercommunicator (handle)}
\end{funcdef}
\mpibind{MPI\_Comm\_join(int~fd, MPI\_Comm~*intercomm)}
-\mpifnewbind{MPI\_Comm\_join(fd, intercomm, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: fd \\ TYPE(MPI\_Comm), INTENT(OUT) :: intercomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_join(fd, intercomm, ierror) \fargs INTEGER, INTENT(IN) :: fd \\ TYPE(MPI\_Comm), INTENT(OUT) :: intercomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_JOIN(FD, INTERCOMM, IERROR)\fargs INTEGER FD, INTERCOMM, IERROR}
\mpicppemptybind{MPI::Comm::Join(const~int~fd)}{static MPI::Intercomm}
Raw
mpi31-r1835-chap-ei.diff
Index: chap-ei/ei-2.tex
===================================================================
--- chap-ei/ei-2.tex (revision 1834)
+++ chap-ei/ei-2.tex (revision 1835)
@@ -88,7 +88,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Grequest\_start(MPI\_Grequest\_query\_function~*query\_fn, MPI\_Grequest\_free\_function~*free\_fn, MPI\_Grequest\_cancel\_function~*cancel\_fn, void~*extra\_state, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Grequest\_start(query\_fn, free\_fn, cancel\_fn, extra\_state, request, ierror) BIND(C) \fargs PROCEDURE(MPI\_Grequest\_query\_function) :: query\_fn \\ PROCEDURE(MPI\_Grequest\_free\_function) :: free\_fn \\ PROCEDURE(MPI\_Grequest\_cancel\_function) :: cancel\_fn \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Grequest\_start(query\_fn, free\_fn, cancel\_fn, extra\_state, request, ierror) \fargs PROCEDURE(MPI\_Grequest\_query\_function) :: query\_fn \\ PROCEDURE(MPI\_Grequest\_free\_function) :: free\_fn \\ PROCEDURE(MPI\_Grequest\_cancel\_function) :: cancel\_fn \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GREQUEST\_START(QUERY\_FN, FREE\_FN, CANCEL\_FN, EXTRA\_STATE, REQUEST, IERROR)\fargs INTEGER REQUEST, IERROR\\EXTERNAL QUERY\_FN, FREE\_FN, CANCEL\_FN\\INTEGER (KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE}
\mpicppemptybind{MPI::Grequest::Start(const~MPI::Grequest::Query\_function* query\_fn, const~MPI::Grequest::Free\_function* free\_fn, const~MPI::Grequest::Cancel\_function*~cancel\_fn, void~*extra\_state)}{static MPI::Grequest}
@@ -115,7 +115,7 @@
\par\noindent
in Fortran with the \code{mpi\_f08} module
-\mpifnewsubbind{MPI\_Grequest\_query\_function(extra\_state, status, ierror) BIND(C) \fargs TYPE(MPI\_Status) :: status \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ INTEGER :: ierror }
+\mpifnewsubbind{MPI\_Grequest\_query\_function(extra\_state, status, ierror) \fargs TYPE(MPI\_Status) :: status \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ INTEGER :: ierror }
\par\noindent
in Fortran with the \code{mpi} module and \code{mpif.h}
@@ -176,7 +176,7 @@
\par\noindent
in Fortran with the \code{mpi\_f08} module
-\mpifnewsubbind{MPI\_Grequest\_free\_function(extra\_state, ierror) BIND(C) \fargs INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ INTEGER :: ierror }
+\mpifnewsubbind{MPI\_Grequest\_free\_function(extra\_state, ierror) \fargs INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ INTEGER :: ierror }
\par\noindent
in Fortran with the \code{mpi} module and \code{mpif.h}
@@ -251,7 +251,7 @@
\par\noindent
in Fortran with the \code{mpi\_f08} module
-\mpifnewsubbind{MPI\_Grequest\_cancel\_function(extra\_state, complete, ierror) BIND(C) \fargs INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ LOGICAL :: complete \\ INTEGER :: ierror }
+\mpifnewsubbind{MPI\_Grequest\_cancel\_function(extra\_state, complete, ierror) \fargs INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state \\ LOGICAL :: complete \\ INTEGER :: ierror }
\par\noindent
in Fortran with the \code{mpi} module and \code{mpif.h}
@@ -311,7 +311,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Grequest\_complete(MPI\_Request request)}
-\mpifnewbind{MPI\_Grequest\_complete(request, ierror) BIND(C) \fargs TYPE(MPI\_Request), INTENT(IN) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Grequest\_complete(request, ierror) \fargs TYPE(MPI\_Request), INTENT(IN) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GREQUEST\_COMPLETE(REQUEST, IERROR)\fargs INTEGER REQUEST, IERROR}
\mpicppemptybind{MPI::Grequest::Complete()}{void}
@@ -519,7 +519,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Status\_set\_elements(MPI\_Status~*status, MPI\_Datatype~datatype, int~count)}
-\mpifnewbind{MPI\_Status\_set\_elements(status, datatype, count, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(INOUT) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Status\_set\_elements(status, datatype, count, ierror) \fargs TYPE(MPI\_Status), INTENT(INOUT) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_STATUS\_SET\_ELEMENTS(STATUS, DATATYPE, COUNT, IERROR)\fargs INTEGER STATUS(MPI\_STATUS\_SIZE), DATATYPE, COUNT, IERROR}
\mpicppemptybind{MPI::Status::Set\_elements(const MPI::Datatype\& datatype, int count)}{void}
@@ -537,7 +537,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Status\_set\_elements\_x(MPI\_Status~*status, MPI\_Datatype~datatype, MPI\_Count~count)}
-\mpifnewbind{MPI\_Status\_set\_elements\_x(status, datatype, count, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(INOUT) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(IN) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Status\_set\_elements\_x(status, datatype, count, ierror) \fargs TYPE(MPI\_Status), INTENT(INOUT) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND = MPI\_COUNT\_KIND), INTENT(IN) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_STATUS\_SET\_ELEMENTS\_X(STATUS, DATATYPE, COUNT, IERROR)\fargs INTEGER STATUS(MPI\_STATUS\_SIZE), DATATYPE, IERROR\\INTEGER (KIND=MPI\_COUNT\_KIND) COUNT}
These functions modify the opaque part of \mpiarg{status} so that a call
@@ -585,7 +585,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Status\_set\_cancelled(MPI\_Status~*status, int~flag)}
-\mpifnewbind{MPI\_Status\_set\_cancelled(status, flag, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(INOUT) :: status \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Status\_set\_cancelled(status, flag, ierror) \fargs TYPE(MPI\_Status), INTENT(INOUT) :: status \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_STATUS\_SET\_CANCELLED(STATUS, FLAG, IERROR)\fargs INTEGER STATUS(MPI\_STATUS\_SIZE), IERROR\\LOGICAL FLAG}
\mpicppemptybind{MPI::Status::Set\_cancelled(bool flag)}{void}
@@ -872,7 +872,7 @@
\mpibind{MPI\_Init\_thread(int~*argc, char~***argv, int~required, int~*provided)}
-\mpifnewbind{MPI\_Init\_thread(required, provided, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: required \\ INTEGER, INTENT(OUT) :: provided \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Init\_thread(required, provided, ierror) \fargs INTEGER, INTENT(IN) :: required \\ INTEGER, INTENT(OUT) :: provided \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INIT\_THREAD(REQUIRED, PROVIDED, IERROR)\fargs INTEGER REQUIRED, PROVIDED, IERROR}
\mpicppemptybind{MPI::Init\_thread(int\& argc, char**\& argv, int required)}{int}
@@ -1020,7 +1020,7 @@
\mpibind{MPI\_Query\_thread(int~*provided)}
-\mpifnewbind{MPI\_Query\_thread(provided, ierror) BIND(C) \fargs INTEGER, INTENT(OUT) :: provided \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Query\_thread(provided, ierror) \fargs INTEGER, INTENT(OUT) :: provided \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_QUERY\_THREAD(PROVIDED, IERROR)\fargs INTEGER PROVIDED, IERROR}
\mpicppemptybind{MPI::Query\_thread()}{int}
@@ -1038,7 +1038,7 @@
\mpibind{MPI\_Is\_thread\_main(int~*flag)}
-\mpifnewbind{MPI\_Is\_thread\_main(flag, ierror) BIND(C) \fargs LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Is\_thread\_main(flag, ierror) \fargs LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IS\_THREAD\_MAIN(FLAG, IERROR) \fargs LOGICAL FLAG \\ INTEGER IERROR}
\mpicppemptybind{MPI::Is\_thread\_main()}{bool}
Raw
mpi31-r1835-chap-inquiry.diff
Index: chap-inquiry/inquiry.tex
===================================================================
--- chap-inquiry/inquiry.tex (revision 1834)
+++ chap-inquiry/inquiry.tex (revision 1835)
@@ -46,7 +46,7 @@
\mpibind{MPI\_Get\_version(int~*version, int~*subversion)}
-\mpifnewbind{MPI\_Get\_version(version, subversion, ierror) BIND(C) \fargs INTEGER, INTENT(OUT) :: version, subversion \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_version(version, subversion, ierror) \fargs INTEGER, INTENT(OUT) :: version, subversion \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_VERSION(VERSION, SUBVERSION, IERROR) \fargs INTEGER VERSION, SUBVERSION, IERROR}
\mpicppemptybind{MPI::Get\_version(int\& version, int\& subversion)}{void}
@@ -63,7 +63,7 @@
\mpibind{MPI\_Get\_library\_version(char *version, int *resultlen)}
-\mpifnewbind{MPI\_Get\_library\_version(version, resulten, ierror) BIND(C) \fargs CHARACTER(LEN=MPI\_MAX\_LIBRARY\_VERSION\_STRING), INTENT(OUT) :: version \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_library\_version(version, resulten, ierror) \fargs CHARACTER(LEN=MPI\_MAX\_LIBRARY\_VERSION\_STRING), INTENT(OUT) :: version \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_LIBRARY\_VERSION(VERSION, RESULTEN, IERROR)\fargs CHARACTER*(*) VERSION\\INTEGER RESULTLEN,IERROR}
This routine returns a string representing the version of the \MPI/ library. The version argument is a
@@ -215,7 +215,7 @@
\mpibind{MPI\_Get\_processor\_name(char~*name, int~*resultlen)}
-\mpifnewbind{MPI\_Get\_processor\_name(name, resultlen, ierror) BIND(C) \fargs CHARACTER(LEN=MPI\_MAX\_PROCESSOR\_NAME), INTENT(OUT) :: name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_processor\_name(name, resultlen, ierror) \fargs CHARACTER(LEN=MPI\_MAX\_PROCESSOR\_NAME), INTENT(OUT) :: name \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_PROCESSOR\_NAME( NAME, RESULTLEN, IERROR)\fargs CHARACTER*(*) NAME\\INTEGER RESULTLEN,IERROR}
\mpicppemptybind{MPI::Get\_processor\_name(char*~name, int\&~resultlen)}{void}
@@ -275,7 +275,7 @@
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Alloc\_mem(MPI\_Aint~size, MPI\_Info~info, void~*baseptr)}
-\mpifnewbind{MPI\_Alloc\_mem(size, info, baseptr, ierror) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Alloc\_mem(size, info, baseptr, ierror) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ALLOC\_MEM(SIZE, INFO, BASEPTR, IERROR) \fargs INTEGER INFO, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) SIZE, BASEPTR \mpifoverloadOnlyInAnnex{\>INTERFACE MPI\_ALLOC\_MEM \\ \>\>SUBROUTINE MPI\_ALLOC\_MEM\_CPTR(SIZE, INFO, BASEPTR, IERROR) \\ \>\>\>USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ \>\>\>INTEGER :: INFO, IERROR \\ \>\>\>INTEGER(KIND=MPI\_ADDRESS\_KIND) :: SIZE \\ \>\>\>TYPE(C\_PTR) :: BASEPTR \\ \>\>END SUBROUTINE \\ \>END INTERFACE}}
\mpicppemptybind{MPI::Alloc\_mem(MPI::Aint size, const MPI::Info\& info)}{void*}
@@ -323,7 +323,7 @@
\mpibind{MPI\_Free\_mem(void~*base)}
-\mpifnewbind{MPI\_Free\_mem(base, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: base \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Free\_mem(base, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: base \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FREE\_MEM(BASE, IERROR) \fargs <type> BASE(*) \\INTEGER IERROR}
\mpicppemptybind{MPI::Free\_mem(void *base)}{void}
@@ -595,7 +595,7 @@
\cdeclmainindex{MPI\_Errhandler}%
\mpibind{MPI\_Comm\_create\_errhandler(MPI\_Comm\_errhandler\_function *comm\_errhandler\_fn, MPI\_Errhandler *errhandler)}
-\mpifnewbind{MPI\_Comm\_create\_errhandler(comm\_errhandler\_fn, errhandler, ierror) BIND(C) \fargs PROCEDURE(MPI\_Comm\_errhandler\_function) :: comm\_errhandler\_fn \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_create\_errhandler(comm\_errhandler\_fn, errhandler, ierror) \fargs PROCEDURE(MPI\_Comm\_errhandler\_function) :: comm\_errhandler\_fn \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_CREATE\_ERRHANDLER(COMM\_ERRHANDLER\_FN, ERRHANDLER, IERROR)\fargs EXTERNAL COMM\_ERRHANDLER\_FN \\ INTEGER ERRHANDLER, IERROR}
Creates an error handler that can be attached to communicators.
@@ -619,7 +619,7 @@
\noindent
With the Fortran \code{mpi\_f08} module, the user routine \mpiarg{comm\_errhandler\_fn} should be of the form:
-\mpifnewsubbind{MPI\_Comm\_errhandler\_function(comm, error\_code) BIND(C) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: error\_code }
+\mpifnewsubbind{MPI\_Comm\_errhandler\_function(comm, error\_code) \fargs TYPE(MPI\_Comm) :: comm \\ INTEGER :: error\_code }
\noindent
With the Fortran \code{mpi} module and \code{mpif.h},
@@ -654,7 +654,7 @@
\cdeclindex{MPI\_Errhandler}%
\mpibind{MPI\_Comm\_set\_errhandler(MPI\_Comm comm, MPI\_Errhandler errhandler)}
-\mpifnewbind{MPI\_Comm\_set\_errhandler(comm, errhandler, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Errhandler), INTENT(IN) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_set\_errhandler(comm, errhandler, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Errhandler), INTENT(IN) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_SET\_ERRHANDLER(COMM, ERRHANDLER, IERROR) \fargs INTEGER COMM, ERRHANDLER, IERROR}
Attaches a new error handler to a communicator.
@@ -671,7 +671,7 @@
\cdeclindex{MPI\_Errhandler}%
\mpibind{MPI\_Comm\_get\_errhandler(MPI\_Comm comm, MPI\_Errhandler *errhandler)}
-\mpifnewbind{MPI\_Comm\_get\_errhandler(comm, errhandler, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_get\_errhandler(comm, errhandler, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_GET\_ERRHANDLER(COMM, ERRHANDLER, IERROR) \fargs INTEGER COMM, ERRHANDLER, IERROR}
\mpicppemptybind{MPI::Comm::Get\_errhandler() const}{MPI::Errhandler}
@@ -695,7 +695,7 @@
\cdeclindex{MPI\_Errhandler}%
\mpibind{MPI\_Win\_create\_errhandler(MPI\_Win\_errhandler\_function *win\_errhandler\_fn, MPI\_Errhandler *errhandler)}
-\mpifnewbind{MPI\_Win\_create\_errhandler(win\_errhandler\_fn, errhandler, ierror) BIND(C) \fargs PROCEDURE(MPI\_Win\_errhandler\_function) :: win\_errhandler\_fn \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_create\_errhandler(win\_errhandler\_fn, errhandler, ierror) \fargs PROCEDURE(MPI\_Win\_errhandler\_function) :: win\_errhandler\_fn \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_CREATE\_ERRHANDLER(WIN\_ERRHANDLER\_FN, ERRHANDLER, IERROR) \fargs EXTERNAL WIN\_ERRHANDLER\_FN \\ INTEGER ERRHANDLER, IERROR}
\mpicppemptybind{MPI::Win::Create\_errhandler(MPI::Win::Errhandler\_function* win\_errhandler\_fn)}{static MPI::Errhandler}
@@ -715,7 +715,7 @@
\noindent
With the Fortran \code{mpi\_f08} module, the user routine \mpiarg{win\_errhandler\_fn} should be of the form:
-\mpifnewsubbind{MPI\_Win\_errhandler\_function(win, error\_code) BIND(C) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: error\_code }
+\mpifnewsubbind{MPI\_Win\_errhandler\_function(win, error\_code) \fargs TYPE(MPI\_Win) :: win \\ INTEGER :: error\_code }
\noindent
With the Fortran \code{mpi} module and \code{mpif.h},
@@ -732,7 +732,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_set\_errhandler(MPI\_Win win, MPI\_Errhandler errhandler)}
-\mpifnewbind{MPI\_Win\_set\_errhandler(win, errhandler, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Errhandler), INTENT(IN) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_set\_errhandler(win, errhandler, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Errhandler), INTENT(IN) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_SET\_ERRHANDLER(WIN, ERRHANDLER, IERROR) \fargs INTEGER WIN, ERRHANDLER, IERROR}
\mpicppemptybind{MPI::Win::Set\_errhandler(const MPI::Errhandler\& errhandler)}{void}
@@ -752,7 +752,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_get\_errhandler(MPI\_Win win, MPI\_Errhandler *errhandler)}
-\mpifnewbind{MPI\_Win\_get\_errhandler(win, errhandler, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_get\_errhandler(win, errhandler, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_GET\_ERRHANDLER(WIN, ERRHANDLER, IERROR) \fargs INTEGER WIN, ERRHANDLER, IERROR}
\mpicppemptybind{MPI::Win::Get\_errhandler() const}{MPI::Errhandler}
@@ -769,7 +769,7 @@
\cdeclindex{MPI\_Errhandler}%
\mpibind{MPI\_File\_create\_errhandler(MPI\_File\_errhandler\_function *file\_errhandler\_fn, MPI\_Errhandler *errhandler)}
-\mpifnewbind{MPI\_File\_create\_errhandler(file\_errhandler\_fn, errhandler, ierror) BIND(C) \fargs PROCEDURE(MPI\_File\_errhandler\_function) :: file\_errhandler\_fn \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_create\_errhandler(file\_errhandler\_fn, errhandler, ierror) \fargs PROCEDURE(MPI\_File\_errhandler\_function) :: file\_errhandler\_fn \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_CREATE\_ERRHANDLER(FILE\_ERRHANDLER\_FN, ERRHANDLER, IERROR)\fargs EXTERNAL FILE\_ERRHANDLER\_FN \\ INTEGER ERRHANDLER, IERROR}
\mpicppemptybind{MPI::File::Create\_errhandler(MPI::File::Errhandler\_function* file\_errhandler\_fn)}{static MPI::Errhandler}
@@ -788,7 +788,7 @@
\noindent
With the Fortran \code{mpi\_f08} module, the user routine \mpiarg{file\_errhandler\_fn} should be of the form:
-\mpifnewsubbind{MPI\_File\_errhandler\_function(file, error\_code) BIND(C) \fargs TYPE(MPI\_File) :: file \\ INTEGER :: error\_code }
+\mpifnewsubbind{MPI\_File\_errhandler\_function(file, error\_code) \fargs TYPE(MPI\_File) :: file \\ INTEGER :: error\_code }
\noindent
With the Fortran \code{mpi} module and \code{mpif.h},
@@ -805,7 +805,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_set\_errhandler(MPI\_File file, MPI\_Errhandler errhandler)}
-\mpifnewbind{MPI\_File\_set\_errhandler(file, errhandler, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: file \\ TYPE(MPI\_Errhandler), INTENT(IN) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_set\_errhandler(file, errhandler, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: file \\ TYPE(MPI\_Errhandler), INTENT(IN) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SET\_ERRHANDLER(FILE, ERRHANDLER, IERROR) \fargs INTEGER FILE, ERRHANDLER, IERROR}
\mpicppemptybind{MPI::File::Set\_errhandler(const MPI::Errhandler\& errhandler)}{void}
@@ -825,7 +825,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_get\_errhandler(MPI\_File file, MPI\_Errhandler *errhandler)}
-\mpifnewbind{MPI\_File\_get\_errhandler(file, errhandler, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: file \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_errhandler(file, errhandler, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: file \\ TYPE(MPI\_Errhandler), INTENT(OUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_ERRHANDLER(FILE, ERRHANDLER, IERROR) \fargs INTEGER FILE, ERRHANDLER, IERROR}
\mpicppemptybind{MPI::File::Get\_errhandler() const}{MPI::Errhandler}
@@ -842,7 +842,7 @@
\cdeclindex{MPI\_Errhandler}%
\mpibind{MPI\_Errhandler\_free(MPI\_Errhandler~*errhandler)}
-\mpifnewbind{MPI\_Errhandler\_free(errhandler, ierror) BIND(C) \fargs TYPE(MPI\_Errhandler), INTENT(INOUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Errhandler\_free(errhandler, ierror) \fargs TYPE(MPI\_Errhandler), INTENT(INOUT) :: errhandler \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ERRHANDLER\_FREE(ERRHANDLER, IERROR)\fargs INTEGER ERRHANDLER, IERROR}
\mpicppemptybind{MPI::Errhandler::Free()}{void}
Marks the error handler associated with \mpiarg{errhandler} for
@@ -865,7 +865,7 @@
\mpibind{MPI\_Error\_string(int~errorcode, char~*string, int~*resultlen)}
-\mpifnewbind{MPI\_Error\_string(errorcode, string, resultlen, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: errorcode \\ CHARACTER(LEN=MPI\_MAX\_ERROR\_STRING), INTENT(OUT) :: string \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Error\_string(errorcode, string, resultlen, ierror) \fargs INTEGER, INTENT(IN) :: errorcode \\ CHARACTER(LEN=MPI\_MAX\_ERROR\_STRING), INTENT(OUT) :: string \\ INTEGER, INTENT(OUT) :: resultlen \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ERROR\_STRING(ERRORCODE, STRING, RESULTLEN, IERROR)\fargs INTEGER ERRORCODE, RESULTLEN, IERROR \\ CHARACTER*(*) STRING}
\mpicppemptybind{MPI::Get\_error\_string(int~errorcode, char*~name, int\&~resultlen)}{void}
@@ -1064,7 +1064,7 @@
\mpibind{MPI\_Error\_class(int~errorcode, int~*errorclass)}
-\mpifnewbind{MPI\_Error\_class(errorcode, errorclass, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: errorcode \\ INTEGER, INTENT(OUT) :: errorclass \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Error\_class(errorcode, errorclass, ierror) \fargs INTEGER, INTENT(IN) :: errorcode \\ INTEGER, INTENT(OUT) :: errorclass \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ERROR\_CLASS(ERRORCODE, ERRORCLASS, IERROR)\fargs INTEGER ERRORCODE, ERRORCLASS, IERROR}
\mpicppemptybind{MPI::Get\_error\_class(int~errorcode)}{int}
@@ -1106,7 +1106,7 @@
\mpibind{MPI\_Add\_error\_class(int *errorclass)}
-\mpifnewbind{MPI\_Add\_error\_class(errorclass, ierror) BIND(C) \fargs INTEGER, INTENT(OUT) :: errorclass \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Add\_error\_class(errorclass, ierror) \fargs INTEGER, INTENT(OUT) :: errorclass \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ADD\_ERROR\_CLASS(ERRORCLASS, IERROR)\fargs INTEGER ERRORCLASS, IERROR}
\mpicppemptybind{MPI::Add\_error\_class()}{int}
@@ -1168,7 +1168,7 @@
\mpibind{MPI\_Add\_error\_code(int errorclass, int *errorcode)}
-\mpifnewbind{MPI\_Add\_error\_code(errorclass, errorcode, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: errorclass \\ INTEGER, INTENT(OUT) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Add\_error\_code(errorclass, errorcode, ierror) \fargs INTEGER, INTENT(IN) :: errorclass \\ INTEGER, INTENT(OUT) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ADD\_ERROR\_CODE(ERRORCLASS, ERRORCODE, IERROR)\fargs INTEGER ERRORCLASS, ERRORCODE, IERROR}
\mpicppemptybind{MPI::Add\_error\_code(int errorclass)}{int}
@@ -1194,7 +1194,7 @@
\mpibind{MPI\_Add\_error\_string(int errorcode, const char *string)}
-\mpifnewbind{MPI\_Add\_error\_string(errorcode, string, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: errorcode \\ CHARACTER(LEN=*), INTENT(IN) :: string \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Add\_error\_string(errorcode, string, ierror) \fargs INTEGER, INTENT(IN) :: errorcode \\ CHARACTER(LEN=*), INTENT(IN) :: string \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ADD\_ERROR\_STRING(ERRORCODE, STRING, IERROR)\fargs INTEGER ERRORCODE, IERROR \\ CHARACTER*(*) STRING}
\mpicppemptybind{MPI::Add\_error\_string(int errorcode, const char* string)}{void}
@@ -1223,7 +1223,7 @@
\mpibind{MPI\_Comm\_call\_errhandler(MPI\_Comm comm, int errorcode)}
-\mpifnewbind{MPI\_Comm\_call\_errhandler(comm, errorcode, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Comm\_call\_errhandler(comm, errorcode, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMM\_CALL\_ERRHANDLER(COMM, ERRORCODE, IERROR)\fargs INTEGER COMM, ERRORCODE, IERROR}
\mpicppemptybind{MPI::Comm::Call\_errhandler(int errorcode) const}{void}
@@ -1250,7 +1250,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_call\_errhandler(MPI\_Win win, int errorcode)}
-\mpifnewbind{MPI\_Win\_call\_errhandler(win, errorcode, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_call\_errhandler(win, errorcode, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_CALL\_ERRHANDLER(WIN, ERRORCODE, IERROR)\fargs INTEGER WIN, ERRORCODE, IERROR}
\mpicppemptybind{MPI::Win::Call\_errhandler(int errorcode) const}{void}
@@ -1274,7 +1274,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_call\_errhandler(MPI\_File fh, int errorcode)}
-\mpifnewbind{MPI\_File\_call\_errhandler(fh, errorcode, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_call\_errhandler(fh, errorcode, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_CALL\_ERRHANDLER(FH, ERRORCODE, IERROR)\fargs INTEGER FH, ERRORCODE, IERROR}
\mpicppemptybind{MPI::File::Call\_errhandler(int errorcode) const}{void}
@@ -1325,7 +1325,7 @@
\begin{funcdefna}{MPI\_WTIME()}
\end{funcdefna}
\mpibindnotint{double MPI\_Wtime(void)}
-\mpifnewbind{DOUBLE PRECISION MPI\_Wtime() BIND(C)}
+\mpifnewbind{DOUBLE PRECISION MPI\_Wtime()}
\mpifbind{DOUBLE PRECISION MPI\_WTIME()}
\mpicppemptybind{MPI::Wtime()}{double}
\mpifunc{MPI\_WTIME} returns a floating-point number of seconds,
@@ -1363,7 +1363,7 @@
\begin{funcdefna}{MPI\_WTICK()}
\end{funcdefna}
\mpibindnotint{double MPI\_Wtick(void)}
-\mpifnewbind{DOUBLE PRECISION MPI\_Wtick() BIND(C)}
+\mpifnewbind{DOUBLE PRECISION MPI\_Wtick()}
\mpifbind{DOUBLE PRECISION MPI\_WTICK()}
\mpicppemptybind{MPI::Wtick()}{double}
\mpifunc{MPI\_WTICK} returns the resolution of
@@ -1396,7 +1396,7 @@
\mpibind{MPI\_Init(int~*argc, char~***argv)}
-\mpifnewbind{MPI\_Init(ierror) BIND(C) \fargs INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Init(ierror) \fargs INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INIT(IERROR)\fargs INTEGER IERROR}
\mpicppemptybind{MPI::Init(int\&~argc, char**\&~argv)}{void}
\mpicppemptybind{MPI::Init()}{void}
@@ -1510,7 +1510,7 @@
\mpibind{MPI\_Finalize(void)}
-\mpifnewbind{MPI\_Finalize(ierror) BIND(C) \fargs INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Finalize(ierror) \fargs INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FINALIZE(IERROR)\fargs INTEGER IERROR}
\mpicppemptybind{MPI::Finalize()}{void}
@@ -1721,7 +1721,7 @@
\mpibind{MPI\_Initialized(int~*flag)}
-\mpifnewbind{MPI\_Initialized(flag, ierror) BIND(C) \fargs LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Initialized(flag, ierror) \fargs LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INITIALIZED(FLAG, IERROR)\fargs LOGICAL FLAG \\ INTEGER IERROR}
\mpicppemptybind{MPI::Is\_initialized()}{bool}
@@ -1742,7 +1742,7 @@
\mpibind{MPI\_Abort(MPI\_Comm~comm, int~errorcode)}
-\mpifnewbind{MPI\_Abort(comm, errorcode, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Abort(comm, errorcode, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: errorcode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ABORT(COMM, ERRORCODE, IERROR)\fargs INTEGER COMM, ERRORCODE, IERROR}
\mpicppemptybind{MPI::Comm::Abort(int~errorcode)}{void}
@@ -1834,7 +1834,7 @@
\mpibind{MPI\_Finalized(int *flag)}
-\mpifnewbind{MPI\_Finalized(flag, ierror) BIND(C) \fargs LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Finalized(flag, ierror) \fargs LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FINALIZED(FLAG, IERROR)\fargs LOGICAL FLAG\\INTEGER IERROR}
\mpicppemptybind{MPI::Is\_finalized()}{bool}
Raw
mpi31-r1835-chap-io.diff
Index: chap-io/io-2.tex
===================================================================
--- chap-io/io-2.tex (revision 1834)
+++ chap-io/io-2.tex (revision 1835)
@@ -189,7 +189,7 @@
\cdeclindex{MPI\_Info}%
\cdeclmainindex{MPI\_File}%
\mpibind{MPI\_File\_open(MPI\_Comm~comm, const char~*filename, int~amode, MPI\_Info~info, MPI\_File~*fh)}
-\mpifnewbind{MPI\_File\_open(comm, filename, amode, info, fh, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ CHARACTER(LEN=*), INTENT(IN) :: filename \\ INTEGER, INTENT(IN) :: amode \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_File), INTENT(OUT) :: fh \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_open(comm, filename, amode, info, fh, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ CHARACTER(LEN=*), INTENT(IN) :: filename \\ INTEGER, INTENT(IN) :: amode \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_File), INTENT(OUT) :: fh \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_OPEN(COMM, FILENAME, AMODE, INFO, FH, IERROR)\fargs CHARACTER*(*) FILENAME \\ INTEGER COMM, AMODE, INFO, FH, IERROR}
\mpicppemptybind{MPI::File::Open(const~MPI::Intracomm\&~comm, const~char*~filename, int~amode, const~MPI::Info\&~info)}{static MPI::File}
@@ -363,7 +363,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_close(MPI\_File~*fh)}
-\mpifnewbind{MPI\_File\_close(fh, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(INOUT) :: fh \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_close(fh, ierror) \fargs TYPE(MPI\_File), INTENT(INOUT) :: fh \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_CLOSE(FH, IERROR)\fargs INTEGER FH, IERROR}
\mpicppemptybind{MPI::File::Close()}{void}
@@ -402,7 +402,7 @@
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_File\_delete(const char~*filename, MPI\_Info~info)}
-\mpifnewbind{MPI\_File\_delete(filename, info, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: filename \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_delete(filename, info, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: filename \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_DELETE(FILENAME, INFO, IERROR)\fargs CHARACTER*(*) FILENAME \\ INTEGER INFO, IERROR}
\mpicppemptybind{MPI::File::Delete(const~char*~filename, const~MPI::Info\&~info)}{static void}
@@ -443,7 +443,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_set\_size(MPI\_File~fh, MPI\_Offset~size)}
-\mpifnewbind{MPI\_File\_set\_size(fh, size, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_set\_size(fh, size, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SET\_SIZE(FH, SIZE, IERROR)\fargs INTEGER FH, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) SIZE}
\mpicppemptybind{MPI::File::Set\_size(MPI::Offset~size)}{void}
@@ -502,7 +502,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_preallocate(MPI\_File~fh, MPI\_Offset~size)}
-\mpifnewbind{MPI\_File\_preallocate(fh, size, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_preallocate(fh, size, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_PREALLOCATE(FH, SIZE, IERROR)\fargs INTEGER FH, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) SIZE}
\mpicppemptybind{MPI::File::Preallocate(MPI::Offset~size)}{void}
@@ -543,7 +543,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_get\_size(MPI\_File~fh, MPI\_Offset~*size)}
-\mpifnewbind{MPI\_File\_get\_size(fh, size, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_size(fh, size, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_SIZE(FH, SIZE, IERROR)\fargs INTEGER FH, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) SIZE}
\mpicppemptybind{MPI::File::Get\_size() const}{MPI::Offset}
@@ -565,7 +565,7 @@
\cdeclindex{MPI\_Group}%
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_get\_group(MPI\_File~fh, MPI\_Group~*group)}
-\mpifnewbind{MPI\_File\_get\_group(fh, group, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_group(fh, group, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_GROUP(FH, GROUP, IERROR)\fargs INTEGER FH, GROUP, IERROR}
\mpicppemptybind{MPI::File::Get\_group() const}{MPI::Group}
@@ -585,7 +585,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_get\_amode(MPI\_File~fh, int~*amode)}
-\mpifnewbind{MPI\_File\_get\_amode(fh, amode, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER, INTENT(OUT) :: amode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_amode(fh, amode, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER, INTENT(OUT) :: amode \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_AMODE(FH, AMODE, IERROR)\fargs INTEGER FH, AMODE, IERROR}
\mpicppemptybind{MPI::File::Get\_amode() const}{int}
@@ -686,7 +686,7 @@
\cdeclindex{MPI\_Info}%
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_set\_info(MPI\_File~fh, MPI\_Info~info)}
-\mpifnewbind{MPI\_File\_set\_info(fh, info, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_set\_info(fh, info, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SET\_INFO(FH, INFO, IERROR)\fargs INTEGER FH, INFO, IERROR}
\mpicppemptybind{MPI::File::Set\_info(const~MPI::Info\&~info)}{void}
@@ -717,7 +717,7 @@
\cdeclindex{MPI\_Info}%
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_get\_info(MPI\_File~fh, MPI\_Info~*info\_used)}
-\mpifnewbind{MPI\_File\_get\_info(fh, info\_used, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Info), INTENT(OUT) :: info\_used \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_info(fh, info\_used, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Info), INTENT(OUT) :: info\_used \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_INFO(FH, INFO\_USED, IERROR)\fargs INTEGER FH, INFO\_USED, IERROR}
\mpicppemptybind{MPI::File::Get\_info() const}{MPI::Info}
@@ -883,7 +883,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_set\_view(MPI\_File~fh, MPI\_Offset~disp, MPI\_Datatype~etype, MPI\_Datatype~filetype, const char~*datarep, MPI\_Info~info)}
-\mpifnewbind{MPI\_File\_set\_view(fh, disp, etype, filetype, datarep, info, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: disp \\ TYPE(MPI\_Datatype), INTENT(IN) :: etype, filetype \\ CHARACTER(LEN=*), INTENT(IN) :: datarep \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_set\_view(fh, disp, etype, filetype, datarep, info, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: disp \\ TYPE(MPI\_Datatype), INTENT(IN) :: etype, filetype \\ CHARACTER(LEN=*), INTENT(IN) :: datarep \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SET\_VIEW(FH, DISP, ETYPE, FILETYPE, DATAREP, INFO, IERROR)\fargs INTEGER FH, ETYPE, FILETYPE, INFO, IERROR \\ CHARACTER*(*) DATAREP \\ INTEGER(KIND=MPI\_OFFSET\_KIND) DISP}
\mpicppemptybind{MPI::File::Set\_view(MPI::Offset~disp, const~MPI::Datatype\&~etype, const~MPI::Datatype\&~filetype, const~char*~datarep, const~MPI::Info\&~info)}{void}
@@ -1031,7 +1031,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_get\_view(MPI\_File~fh, MPI\_Offset~*disp, MPI\_Datatype~*etype, MPI\_Datatype~*filetype, char~*datarep)}
-\mpifnewbind{MPI\_File\_get\_view(fh, disp, etype, filetype, datarep, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: disp \\ TYPE(MPI\_Datatype), INTENT(OUT) :: etype, filetype \\ CHARACTER(LEN=*), INTENT(OUT) :: datarep \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_view(fh, disp, etype, filetype, datarep, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: disp \\ TYPE(MPI\_Datatype), INTENT(OUT) :: etype, filetype \\ CHARACTER(LEN=*), INTENT(OUT) :: datarep \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_VIEW(FH, DISP, ETYPE, FILETYPE, DATAREP, IERROR)\fargs INTEGER FH, ETYPE, FILETYPE, IERROR \\ CHARACTER*(*) DATAREP \\ INTEGER(KIND=MPI\_OFFSET\_KIND) DISP}
\mpicppemptybind{MPI::File::Get\_view(MPI::Offset\&~disp, MPI::Datatype\&~etype, MPI::Datatype\&~filetype, char*~datarep) const}{void}
@@ -1366,7 +1366,7 @@
\cdeclindex{MPI\_Status}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_read\_at(MPI\_File~fh, MPI\_Offset~offset, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_at(fh, offset, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_at(fh, offset, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_AT(FH, OFFSET, BUF, COUNT, DATATYPE, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Read\_at(MPI::Offset~offset, void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_at(MPI::Offset~offset, void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1387,7 +1387,7 @@
\cdeclindex{MPI\_Status}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_read\_at\_all(MPI\_File~fh, MPI\_Offset~offset, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_at\_all(fh, offset, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_at\_all(fh, offset, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_AT\_ALL(FH, OFFSET, BUF, COUNT, DATATYPE, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Read\_at\_all(MPI::Offset~offset, void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_at\_all(MPI::Offset~offset, void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1408,7 +1408,7 @@
\cdeclindex{MPI\_Status}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_write\_at(MPI\_File~fh, MPI\_Offset~offset, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_at(fh, offset, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_at(fh, offset, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_AT(FH, OFFSET, BUF, COUNT, DATATYPE, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Write\_at(MPI::Offset~offset, const~void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_at(MPI::Offset~offset, const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1430,7 +1430,7 @@
\cdeclindex{MPI\_Status}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_write\_at\_all(MPI\_File~fh, MPI\_Offset~offset, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_at\_all(fh, offset, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_at\_all(fh, offset, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_AT\_ALL(FH, OFFSET, BUF, COUNT, DATATYPE, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Write\_at\_all(MPI::Offset~offset, const~void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_at\_all(MPI::Offset~offset, const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1451,7 +1451,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_iread\_at(MPI\_File~fh, MPI\_Offset~offset, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Request~*request)}
-\mpifnewbind{MPI\_File\_iread\_at(fh, offset, buf, count, datatype, request, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_iread\_at(fh, offset, buf, count, datatype, request, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_IREAD\_AT(FH, OFFSET, BUF, COUNT, DATATYPE, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, REQUEST, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Iread\_at(MPI::Offset~offset, void*~buf, int~count, const~MPI::Datatype\&~datatype)}{MPI::Request}
@@ -1471,7 +1471,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_iwrite\_at(MPI\_File~fh, MPI\_Offset~offset, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Request~*request)}
-\mpifnewbind{MPI\_File\_iwrite\_at(fh, offset, buf, count, datatype, request, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_iwrite\_at(fh, offset, buf, count, datatype, request, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_IWRITE\_AT(FH, OFFSET, BUF, COUNT, DATATYPE, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, REQUEST, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Iwrite\_at(MPI::Offset~offset, const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{MPI::Request}
@@ -1521,7 +1521,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_read(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Read(void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\& status)}{void}
\mpicppemptybind{MPI::File::Read(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1586,7 +1586,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_read\_all(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_all(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_all(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_ALL(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Read\_all(void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_all(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1605,7 +1605,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_write(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Write(const~void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1623,7 +1623,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_write\_all(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_all(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_all(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_ALL(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Write\_all(const~void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_all(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1642,7 +1642,7 @@
\cdeclindex{MPI\_Request}%
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_iread(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Request~*request)}
-\mpifnewbind{MPI\_File\_iread(fh, buf, count, datatype, request, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_iread(fh, buf, count, datatype, request, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_IREAD(FH, BUF, COUNT, DATATYPE, REQUEST, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, REQUEST, IERROR}
\mpicppemptybind{MPI::File::Iread(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{MPI::Request}
@@ -1702,7 +1702,7 @@
\cdeclindex{MPI\_Request}%
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_iwrite(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Request~*request)}
-\mpifnewbind{MPI\_File\_iwrite(fh, buf, count, datatype, request, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_iwrite(fh, buf, count, datatype, request, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_IWRITE(FH, BUF, COUNT, DATATYPE, REQUEST, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, REQUEST, IERROR}
\mpicppemptybind{MPI::File::Iwrite(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{MPI::Request}
@@ -1717,7 +1717,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_seek(MPI\_File~fh, MPI\_Offset~offset, int~whence)}
-\mpifnewbind{MPI\_File\_seek(fh, offset, whence, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ INTEGER, INTENT(IN) :: whence \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_seek(fh, offset, whence, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ INTEGER, INTENT(IN) :: whence \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SEEK(FH, OFFSET, WHENCE, IERROR)\fargs INTEGER FH, WHENCE, IERROR\\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Seek(MPI::Offset~offset, int~whence)}{void}
@@ -1749,7 +1749,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_get\_position(MPI\_File~fh, MPI\_Offset~*offset)}
-\mpifnewbind{MPI\_File\_get\_position(fh, offset, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: offset \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_position(fh, offset, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: offset \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_POSITION(FH, OFFSET, IERROR)\fargs INTEGER FH, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Get\_position() const}{MPI::Offset}
@@ -1776,7 +1776,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_get\_byte\_offset(MPI\_File~fh, MPI\_Offset~offset, MPI\_Offset~*disp)}
-\mpifnewbind{MPI\_File\_get\_byte\_offset(fh, offset, disp, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: disp \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_byte\_offset(fh, offset, disp, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: disp \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_BYTE\_OFFSET(FH, OFFSET, DISP, IERROR)\fargs INTEGER FH, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET, DISP}
\mpicppemptybind{MPI::File::Get\_byte\_offset(const~MPI::Offset~disp) const}{MPI::Offset}
@@ -1839,7 +1839,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_read\_shared(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_shared(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_shared(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_SHARED(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR }
\mpicppemptybind{MPI::File::Read\_shared(void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_shared(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1858,7 +1858,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_write\_shared(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_shared(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_shared(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_SHARED(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Write\_shared(const~void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_shared(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1877,7 +1877,7 @@
\cdeclindex{MPI\_Request}%
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_iread\_shared(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Request~*request)}
-\mpifnewbind{MPI\_File\_iread\_shared(fh, buf, count, datatype, request, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_iread\_shared(fh, buf, count, datatype, request, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_IREAD\_SHARED(FH, BUF, COUNT, DATATYPE, REQUEST, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, REQUEST, IERROR}
\mpicppemptybind{MPI::File::Iread\_shared(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{MPI::Request}
@@ -1895,7 +1895,7 @@
\cdeclindex{MPI\_Request}%
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_iwrite\_shared(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Request~*request)}
-\mpifnewbind{MPI\_File\_iwrite\_shared(fh, buf, count, datatype, request, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_iwrite\_shared(fh, buf, count, datatype, request, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_IWRITE\_SHARED(FH, BUF, COUNT, DATATYPE, REQUEST, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, REQUEST, IERROR}
\mpicppemptybind{MPI::File::Iwrite\_shared(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{MPI::Request}
@@ -1955,7 +1955,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_read\_ordered(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_ordered(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_ordered(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_ORDERED(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Read\_ordered(void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_ordered(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1974,7 +1974,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_write\_ordered(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_ordered(fh, buf, count, datatype, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_ordered(fh, buf, count, datatype, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_ORDERED(FH, BUF, COUNT, DATATYPE, STATUS, IERROR) \fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Write\_ordered(const~void*~buf, int~count, const~MPI::Datatype\&~datatype, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_ordered(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -1999,7 +1999,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_seek\_shared(MPI\_File~fh, MPI\_Offset~offset, int~whence)}
-\mpifnewbind{MPI\_File\_seek\_shared(fh, offset, whence, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ INTEGER, INTENT(IN) :: whence \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_seek\_shared(fh, offset, whence, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ INTEGER, INTENT(IN) :: whence \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SEEK\_SHARED(FH, OFFSET, WHENCE, IERROR)\fargs INTEGER FH, WHENCE, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Seek\_shared(MPI::Offset~offset, int~whence)}{void}
@@ -2038,7 +2038,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_get\_position\_shared(MPI\_File~fh, MPI\_Offset~*offset)}
-\mpifnewbind{MPI\_File\_get\_position\_shared(fh, offset, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: offset \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_position\_shared(fh, offset, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(OUT) :: offset \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_POSITION\_SHARED(FH, OFFSET, IERROR)\fargs INTEGER FH, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Get\_position\_shared() const}{MPI::Offset}
@@ -2179,7 +2179,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_read\_at\_all\_begin(MPI\_File~fh, MPI\_Offset~offset, void~*buf, int~count, MPI\_Datatype~datatype)}
-\mpifnewbind{MPI\_File\_read\_at\_all\_begin(fh, offset, buf, count, datatype, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_at\_all\_begin(fh, offset, buf, count, datatype, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_AT\_ALL\_BEGIN(FH, OFFSET, BUF, COUNT, DATATYPE, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Read\_at\_all\_begin(MPI::Offset~offset, void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -2192,7 +2192,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_read\_at\_all\_end(MPI\_File~fh, void~*buf, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_at\_all\_end(fh, buf, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_at\_all\_end(fh, buf, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_AT\_ALL\_END(FH, BUF, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Read\_at\_all\_end(void*~buf, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_at\_all\_end(void*~buf)}{void}
@@ -2208,7 +2208,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Offset}%
\mpibind{MPI\_File\_write\_at\_all\_begin(MPI\_File~fh, MPI\_Offset~offset, const void~*buf, int~count, MPI\_Datatype~datatype)}
-\mpifnewbind{MPI\_File\_write\_at\_all\_begin(fh, offset, buf, count, datatype, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_at\_all\_begin(fh, offset, buf, count, datatype, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER(KIND=MPI\_OFFSET\_KIND), INTENT(IN) :: offset \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_AT\_ALL\_BEGIN(FH, OFFSET, BUF, COUNT, DATATYPE, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) OFFSET}
\mpicppemptybind{MPI::File::Write\_at\_all\_begin(MPI::Offset~offset, const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -2221,7 +2221,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_write\_at\_all\_end(MPI\_File~fh, const void~*buf, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_at\_all\_end(fh, buf, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_at\_all\_end(fh, buf, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_AT\_ALL\_END(FH, BUF, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Write\_at\_all\_end(const~void*~buf, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_at\_all\_end(const~void*~buf)}{void}
@@ -2237,7 +2237,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_read\_all\_begin(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype)}
-\mpifnewbind{MPI\_File\_read\_all\_begin(fh, buf, count, datatype, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_all\_begin(fh, buf, count, datatype, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_ALL\_BEGIN(FH, BUF, COUNT, DATATYPE, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, IERROR}
\mpicppemptybind{MPI::File::Read\_all\_begin(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -2250,7 +2250,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_read\_all\_end(MPI\_File~fh, void~*buf, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_all\_end(fh, buf, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_all\_end(fh, buf, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_ALL\_END(FH, BUF, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Read\_all\_end(void*~buf, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_all\_end(void*~buf)}{void}
@@ -2264,7 +2264,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_write\_all\_begin(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype)}
-\mpifnewbind{MPI\_File\_write\_all\_begin(fh, buf, count, datatype, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_all\_begin(fh, buf, count, datatype, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_ALL\_BEGIN(FH, BUF, COUNT, DATATYPE, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, IERROR}
\mpicppemptybind{MPI::File::Write\_all\_begin(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -2277,7 +2277,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_write\_all\_end(MPI\_File~fh, const void~*buf, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_all\_end(fh, buf, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_all\_end(fh, buf, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_ALL\_END(FH, BUF, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Write\_all\_end(const~void*~buf, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_all\_end(const~void*~buf)}{void}
@@ -2293,7 +2293,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_read\_ordered\_begin(MPI\_File~fh, void~*buf, int~count, MPI\_Datatype~datatype)}
-\mpifnewbind{MPI\_File\_read\_ordered\_begin(fh, buf, count, datatype, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_ordered\_begin(fh, buf, count, datatype, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_ORDERED\_BEGIN(FH, BUF, COUNT, DATATYPE, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, IERROR}
\mpicppemptybind{MPI::File::Read\_ordered\_begin(void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -2306,7 +2306,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_read\_ordered\_end(MPI\_File~fh, void~*buf, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_read\_ordered\_end(fh, buf, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_read\_ordered\_end(fh, buf, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_READ\_ORDERED\_END(FH, BUF, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Read\_ordered\_end(void*~buf, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Read\_ordered\_end(void*~buf)}{void}
@@ -2320,7 +2320,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_write\_ordered\_begin(MPI\_File~fh, const void~*buf, int~count, MPI\_Datatype~datatype)}
-\mpifnewbind{MPI\_File\_write\_ordered\_begin(fh, buf, count, datatype, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_ordered\_begin(fh, buf, count, datatype, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_ORDERED\_BEGIN(FH, BUF, COUNT, DATATYPE, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, COUNT, DATATYPE, IERROR}
\mpicppemptybind{MPI::File::Write\_ordered\_begin(const~void*~buf, int~count, const~MPI::Datatype\&~datatype)}{void}
@@ -2333,7 +2333,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_File\_write\_ordered\_end(MPI\_File~fh, const void~*buf, MPI\_Status~*status)}
-\mpifnewbind{MPI\_File\_write\_ordered\_end(fh, buf, status, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_write\_ordered\_end(fh, buf, status, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_WRITE\_ORDERED\_END(FH, BUF, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER FH, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::File::Write\_ordered\_end(const~void*~buf, MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::File::Write\_ordered\_end(const~void*~buf)}{void}
@@ -2600,7 +2600,7 @@
\cdeclindex{MPI\_File}%
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_File\_get\_type\_extent(MPI\_File~fh, MPI\_Datatype~datatype, MPI\_Aint~*extent)}
-\mpifnewbind{MPI\_File\_get\_type\_extent(fh, datatype, extent, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_type\_extent(fh, datatype, extent, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: extent \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_TYPE\_EXTENT(FH, DATATYPE, EXTENT, IERROR)\fargs INTEGER FH, DATATYPE, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTENT}
\mpicppemptybind{MPI::File::Get\_type\_extent(const~MPI::Datatype\&~datatype) const}{MPI::Aint}
@@ -2783,7 +2783,7 @@
\end{funcdef}
\mpibind{MPI\_Register\_datarep(const char~*datarep, MPI\_Datarep\_conversion\_function~*read\_conversion\_fn, MPI\_Datarep\_conversion\_function~*write\_conversion\_fn, MPI\_Datarep\_extent\_function~*dtype\_file\_extent\_fn, void~*extra\_state)}
-\mpifnewbind{MPI\_Register\_datarep(datarep, read\_conversion\_fn, write\_conversion\_fn, dtype\_file\_extent\_fn, extra\_state, ierror) BIND(C) \fargs CHARACTER(LEN=*), INTENT(IN) :: datarep \\ PROCEDURE(MPI\_Datarep\_conversion\_function) :: read\_conversion\_fn \\ PROCEDURE(MPI\_Datarep\_conversion\_function) :: write\_conversion\_fn \\ PROCEDURE(MPI\_Datarep\_extent\_function) :: dtype\_file\_extent\_fn \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Register\_datarep(datarep, read\_conversion\_fn, write\_conversion\_fn, dtype\_file\_extent\_fn, extra\_state, ierror) \fargs CHARACTER(LEN=*), INTENT(IN) :: datarep \\ PROCEDURE(MPI\_Datarep\_conversion\_function) :: read\_conversion\_fn \\ PROCEDURE(MPI\_Datarep\_conversion\_function) :: write\_conversion\_fn \\ PROCEDURE(MPI\_Datarep\_extent\_function) :: dtype\_file\_extent\_fn \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: extra\_state \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_REGISTER\_DATAREP(DATAREP, READ\_CONVERSION\_FN, WRITE\_CONVERSION\_FN, DTYPE\_FILE\_EXTENT\_FN, EXTRA\_STATE, IERROR) \fargs CHARACTER*(*) DATAREP \\ EXTERNAL READ\_CONVERSION\_FN, WRITE\_CONVERSION\_FN, DTYPE\_FILE\_EXTENT\_FN \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE \\ INTEGER IERROR}
\mpicppemptybind{MPI::Register\_datarep(const~char*~datarep, MPI::Datarep\_conversion\_function*~read\_conversion\_fn, MPI::Datarep\_conversion\_function*~write\_conversion\_fn, MPI::Datarep\_extent\_function*~dtype\_file\_extent\_fn, void*~extra\_state)}{void}
@@ -2814,7 +2814,7 @@
\cdeclindex{MPI\_Aint}%
\mpitypedefbind{MPI\_Datarep\_extent\_function(MPI\_Datatype~datatype, MPI\_Aint~*file\_extent, void~*extra\_state)}
-\mpifnewsubbind{MPI\_Datarep\_extent\_function(datatype, extent, extra\_state, ierror) BIND(C) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extent, extra\_state \\ INTEGER :: ierror }
+\mpifnewsubbind{MPI\_Datarep\_extent\_function(datatype, extent, extra\_state, ierror) \fargs TYPE(MPI\_Datatype) :: datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extent, extra\_state \\ INTEGER :: ierror }
\mpifsubbind{DATAREP\_EXTENT\_FUNCTION(DATATYPE, EXTENT, EXTRA\_STATE, IERROR)\fargs INTEGER DATATYPE, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTENT, EXTRA\_STATE}
\mpicpptypedefemptybind{MPI::Datarep\_extent\_function(const~MPI::Datatype\&~datatype, MPI::Aint\&~file\_extent, void*~extra\_state)}{void}
@@ -2833,7 +2833,7 @@
\cdeclindex{MPI\_Offset}%
\mpitypedefbind{MPI\_Datarep\_conversion\_function(void~*userbuf, MPI\_Datatype~datatype, int~count, void~*filebuf, MPI\_Offset~position, void~*extra\_state)}
-\mpifnewsubbind{MPI\_Datarep\_conversion\_function(userbuf, datatype, count, filebuf, position, extra\_state, ierror) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: userbuf, filebuf \\ TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: count, ierror \\ INTEGER(KIND=MPI\_OFFSET\_KIND) :: position \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state}
+\mpifnewsubbind{MPI\_Datarep\_conversion\_function(userbuf, datatype, count, filebuf, position, extra\_state, ierror) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), VALUE :: userbuf, filebuf \\ TYPE(MPI\_Datatype) :: datatype \\ INTEGER :: count, ierror \\ INTEGER(KIND=MPI\_OFFSET\_KIND) :: position \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) :: extra\_state}
\mpifsubbind{DATAREP\_CONVERSION\_FUNCTION(USERBUF, DATATYPE, COUNT, FILEBUF, POSITION, EXTRA\_STATE, IERROR)\fargs <TYPE> USERBUF(*), FILEBUF(*) \\ INTEGER COUNT, DATATYPE, IERROR \\ INTEGER(KIND=MPI\_OFFSET\_KIND) POSITION \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) EXTRA\_STATE}
\mpicpptypedefemptybind{MPI::Datarep\_conversion\_function(void*~userbuf, MPI::Datatype\&~datatype, int~count, void*~filebuf, MPI::Offset~position, void*~extra\_state)}{void}
@@ -3184,7 +3184,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_set\_atomicity(MPI\_File~fh, int~flag)}
-\mpifnewbind{MPI\_File\_set\_atomicity(fh, flag, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ LOGICAL, INTENT(IN) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_set\_atomicity(fh, flag, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ LOGICAL, INTENT(IN) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SET\_ATOMICITY(FH, FLAG, IERROR)\fargs INTEGER FH, IERROR\\LOGICAL FLAG}
\mpicppemptybind{MPI::File::Set\_atomicity(bool~flag)}{void}
@@ -3221,7 +3221,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_get\_atomicity(MPI\_File~fh, int~*flag)}
-\mpifnewbind{MPI\_File\_get\_atomicity(fh, flag, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_get\_atomicity(fh, flag, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_GET\_ATOMICITY(FH, FLAG, IERROR)\fargs INTEGER FH, IERROR\\LOGICAL FLAG}
\mpicppemptybind{MPI::File::Get\_atomicity() const}{bool}
@@ -3238,7 +3238,7 @@
\cdeclindex{MPI\_File}%
\mpibind{MPI\_File\_sync(MPI\_File~fh)}
-\mpifnewbind{MPI\_File\_sync(fh, ierror) BIND(C) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_File\_sync(fh, ierror) \fargs TYPE(MPI\_File), INTENT(IN) :: fh \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FILE\_SYNC(FH, IERROR)\fargs INTEGER FH, IERROR}
\mpicppemptybind{MPI::File::Sync()}{void}
Raw
mpi31-r1835-chap-misc.diff
Index: chap-misc/misc-2.tex
===================================================================
--- chap-misc/misc-2.tex (revision 1834)
+++ chap-misc/misc-2.tex (revision 1835)
@@ -94,7 +94,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_create(MPI\_Info *info)}
-\mpifnewbind{MPI\_Info\_create(info, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(OUT) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_create(info, ierror) \fargs TYPE(MPI\_Info), INTENT(OUT) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_CREATE(INFO, IERROR)\fargs INTEGER INFO, IERROR}
\mpicppemptybind{MPI::Info::Create() }{static MPI::Info}
@@ -108,7 +108,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_set(MPI\_Info~info, const char~*key, const char~*value)}
-\mpifnewbind{MPI\_Info\_set(info, key, value, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key, value \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_set(info, key, value, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key, value \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_SET(INFO, KEY, VALUE, IERROR)\fargs INTEGER INFO, IERROR \\CHARACTER*(*) KEY, VALUE}
\mpicppemptybind{MPI::Info::Set(const~char*~key, const~char*~value) }{void}
@@ -125,7 +125,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_delete(MPI\_Info~info, const char~*key)}
-\mpifnewbind{MPI\_Info\_delete(info, key, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_delete(info, key, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_DELETE(INFO, KEY, IERROR)\fargs INTEGER INFO, IERROR \\CHARACTER*(*) KEY}
\mpicppemptybind{MPI::Info::Delete(const~char*~key) }{void}
@@ -142,7 +142,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_get(MPI\_Info~info, const char~*key, int~valuelen, char~*value, int~*flag)}
-\mpifnewbind{MPI\_Info\_get(info, key, valuelen, value, flag, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key \\ INTEGER, INTENT(IN) :: valuelen \\ CHARACTER(LEN=valuelen), INTENT(OUT) :: value \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_get(info, key, valuelen, value, flag, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key \\ INTEGER, INTENT(IN) :: valuelen \\ CHARACTER(LEN=valuelen), INTENT(OUT) :: value \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_GET(INFO, KEY, VALUELEN, VALUE, FLAG, IERROR)\fargs INTEGER INFO, VALUELEN, IERROR \\CHARACTER*(*) KEY, VALUE \\LOGICAL FLAG}
\mpicppemptybind{MPI::Info::Get(const~char*~key, int~valuelen, char*~value) const }{bool}
@@ -169,7 +169,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_get\_valuelen(MPI\_Info~info, const char~*key, int~*valuelen, int~*flag)}
-\mpifnewbind{MPI\_Info\_get\_valuelen(info, key, valuelen, flag, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key \\ INTEGER, INTENT(OUT) :: valuelen \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_get\_valuelen(info, key, valuelen, flag, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ CHARACTER(LEN=*), INTENT(IN) :: key \\ INTEGER, INTENT(OUT) :: valuelen \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_GET\_VALUELEN(INFO, KEY, VALUELEN, FLAG, IERROR)\fargs INTEGER INFO, VALUELEN, IERROR \\LOGICAL FLAG \\CHARACTER*(*) KEY}
\mpicppemptybind{MPI::Info::Get\_valuelen(const~char*~key, int\&~valuelen) const }{bool}
@@ -189,7 +189,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_get\_nkeys(MPI\_Info~info, int~*nkeys)}
-\mpifnewbind{MPI\_Info\_get\_nkeys(info, nkeys, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(OUT) :: nkeys \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_get\_nkeys(info, nkeys, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(OUT) :: nkeys \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_GET\_NKEYS(INFO, NKEYS, IERROR)\fargs INTEGER INFO, NKEYS, IERROR}
\mpicppemptybind{MPI::Info::Get\_nkeys() const }{int}
@@ -203,7 +203,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_get\_nthkey(MPI\_Info~info, int~n, char~*key)}
-\mpifnewbind{MPI\_Info\_get\_nthkey(info, n, key, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(IN) :: n \\ CHARACTER(LEN=*), INTENT(OUT) :: key \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_get\_nthkey(info, n, key, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, INTENT(IN) :: n \\ CHARACTER(LEN=*), INTENT(OUT) :: key \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_GET\_NTHKEY(INFO, N, KEY, IERROR)\fargs INTEGER INFO, N, IERROR \\CHARACTER*(*) KEY}
\mpicppemptybind{MPI::Info::Get\_nthkey(int~n, char*~key) const }{void}
@@ -222,7 +222,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_dup(MPI\_Info info, MPI\_Info *newinfo)}
-\mpifnewbind{MPI\_Info\_dup(info, newinfo, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Info), INTENT(OUT) :: newinfo \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_dup(info, newinfo, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Info), INTENT(OUT) :: newinfo \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_DUP(INFO, NEWINFO, IERROR)\fargs INTEGER INFO, NEWINFO, IERROR}
\mpicppemptybind{MPI::Info::Dup() const }{MPI::Info}
@@ -234,7 +234,7 @@
\end{funcdef}
\cdeclindex{MPI\_Info}%
\mpibind{MPI\_Info\_free(MPI\_Info *info)}
-\mpifnewbind{MPI\_Info\_free(info, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(INOUT) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Info\_free(info, ierror) \fargs TYPE(MPI\_Info), INTENT(INOUT) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INFO\_FREE(INFO, IERROR) \fargs INTEGER INFO, IERROR}
\mpicppemptybind{MPI::Info::Free() }{void}
Raw
mpi31-r1835-chap-one-sided.diff
Index: chap-one-side/one-side-2.tex
===================================================================
--- chap-one-side/one-side-2.tex (revision 1834)
+++ chap-one-side/one-side-2.tex (revision 1835)
@@ -144,7 +144,7 @@
\cdeclmainindex{MPI\_Win}%
\cdeclindex{MPI\_Aint}%
-\mpifnewbind{MPI\_Win\_create(base, size, disp\_unit, info, comm, win, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: base \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, INTENT(IN) :: disp\_unit \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_create(base, size, disp\_unit, info, comm, win, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: base \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, INTENT(IN) :: disp\_unit \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_CREATE(BASE, SIZE, DISP\_UNIT, INFO, COMM, WIN, IERROR)\fargs <type> BASE(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) SIZE \\INTEGER DISP\_UNIT, INFO, COMM, WIN, IERROR}
\mpicppemptybind{MPI::Win::Create(const void* base, MPI::Aint size, int disp\_unit, const MPI::Info\& info, const MPI::Intracomm\& comm)}{static MPI::Win}
@@ -300,7 +300,7 @@
%% views base (baseptr in alloc_mem) as an address-sized integer in
%% Fortran. If there is a change in Alloc_mem to use new Fortran
%% interfaces, this binding should follow the same approach
-\mpifnewbind{MPI\_Win\_allocate(size, disp\_unit, info, comm, baseptr, win, ierror) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, INTENT(IN) :: disp\_unit \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_allocate(size, disp\_unit, info, comm, baseptr, win, ierror) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, INTENT(IN) :: disp\_unit \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_ALLOCATE(SIZE, DISP\_UNIT, INFO, COMM, BASEPTR, WIN, IERROR)\fargs INTEGER DISP\_UNIT, INFO, COMM, WIN, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) SIZE, BASEPTR \mpifoverloadOnlyInAnnex{\>INTERFACE MPI\_WIN\_ALLOCATE \\ \>\>SUBROUTINE MPI\_WIN\_ALLOCATE\_CPTR(SIZE, DISP\_UNIT, INFO, COMM, BASEPTR, \& \\ \>\>\>\>WIN, IERROR) \\ \>\>\>USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ \>\>\>INTEGER :: DISP\_UNIT, INFO, COMM, WIN, IERROR \\ \>\>\>INTEGER(KIND=MPI\_ADDRESS\_KIND) :: SIZE \\ \>\>\>TYPE(C\_PTR) :: BASEPTR \\ \>\>END SUBROUTINE \\ \>END INTERFACE}}
%\mpicppemptybind{MPI::Win::Allocate(MPI::Aint size, int disp\_unit, %const MPI::Info\& info, const MPI::Intracomm\& comm, void** baseptr)}{static MPI::Win}
@@ -384,7 +384,7 @@
%% views base (baseptr in alloc_mem) as an address-sized integer in
%% Fortran. If there is a change in Alloc_mem to use new Fortran
%% interfaces, this binding should follow the same approach
-\mpifnewbind{MPI\_Win\_allocate\_shared(size, disp\_unit, info, comm, baseptr, win, ierror) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, INTENT(IN) :: disp\_unit \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_allocate\_shared(size, disp\_unit, info, comm, baseptr, win, ierror) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, INTENT(IN) :: disp\_unit \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_ALLOCATE\_SHARED(SIZE, DISP\_UNIT, INFO, COMM, BASEPTR, WIN, IERROR)\fargs INTEGER DISP\_UNIT, INFO, COMM, WIN, IERROR \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) SIZE, BASEPTR \mpifoverloadOnlyInAnnex{\>INTERFACE MPI\_WIN\_ALLOCATE\_SHARED \\ \>\>SUBROUTINE MPI\_WIN\_ALLOCATE\_SHARED\_CPTR(SIZE, DISP\_UNIT, INFO, COMM, \& \\ \>\>\>\>BASEPTR, WIN, IERROR) \\ \>\>\>USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ \>\>\>INTEGER :: DISP\_UNIT, INFO, COMM, WIN, IERROR \\ \>\>\>INTEGER(KIND=MPI\_ADDRESS\_KIND) :: SIZE \\ \>\>\>TYPE(C\_PTR) :: BASEPTR \\ \>\>END SUBROUTINE \\ \>END INTERFACE}}
%\mpicppemptybind{MPI::Win::Allocate(MPI::Aint size, int disp\_unit, %const MPI::Info\& info, const MPI::Intracomm\& comm, void* baseptr)}{static MPI::Win}
@@ -487,7 +487,7 @@
\mpibind{MPI\_Win\_shared\_query(MPI\_Win win, int rank, MPI\_Aint *size, int~*disp\_unit, void~*baseptr)}
-\mpifnewbind{MPI\_Win\_shared\_query(win, rank, size, disp\_unit, baseptr, ierror) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: rank \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: size \\ INTEGER, INTENT(OUT) :: disp\_unit \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_shared\_query(win, rank, size, disp\_unit, baseptr, ierror) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, INTENT(IN) :: rank \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(OUT) :: size \\ INTEGER, INTENT(OUT) :: disp\_unit \\ TYPE(C\_PTR), INTENT(OUT) :: baseptr \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_SHARED\_QUERY(WIN, RANK, SIZE, DISP\_UNIT, BASEPTR, IERROR)\fargs INTEGER WIN, RANK, DISP\_UNIT, IERROR\\INTEGER (KIND=MPI\_ADDRESS\_KIND) SIZE, BASEPTR \mpifoverloadOnlyInAnnex{ INTERFACE MPI\_WIN\_SHARED\_QUERY \\ \>\>SUBROUTINE MPI\_WIN\_SHARED\_QUERY\_CPTR(WIN, RANK, SIZE, DISP\_UNIT, \&\\ \>\>\>\>BASEPTR, IERROR) \\ \>\>\>USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ \>\>\>INTEGER :: WIN, RANK, DISP\_UNIT, IERROR \\ \>\>\>INTEGER(KIND=MPI\_ADDRESS\_KIND) :: SIZE \\ \>\>\>TYPE(C\_PTR) :: BASEPTR \\ \>\>END SUBROUTINE \\ \>END INTERFACE}}
This function queries the process-local address for remote memory segments
@@ -564,7 +564,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Win\_create\_dynamic(MPI\_Info info, MPI\_Comm~comm, MPI\_Win~*win)}
-\mpifnewbind{MPI\_Win\_create\_dynamic(info, comm, win, ierror) BIND(C) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_create\_dynamic(info, comm, win, ierror) \fargs TYPE(MPI\_Info), INTENT(IN) :: info \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Win), INTENT(OUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_CREATE\_DYNAMIC(INFO, COMM, WIN, IERROR)\fargs INTEGER INFO, COMM, WIN, IERROR}
%\mpicppemptybind{MPI::Win::Create\_dynamic(const MPI::Info\& info, const MPI::Intracomm\& comm)}{static MPI::Win}
@@ -625,7 +625,7 @@
\mpibind{MPI\_Win\_attach(MPI\_Win win, void *base, MPI\_Aint size)}
-\mpifnewbind{MPI\_Win\_attach(win, base, size, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: base \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_attach(win, base, size, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: base \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_ATTACH(WIN, BASE, SIZE, IERROR)\fargs INTEGER WIN, IERROR\\<type> BASE(*)\\INTEGER (KIND=MPI\_ADDRESS\_KIND) SIZE}
%\mpicppemptybind{MPI::Win::Register(void *base, MPI::Aint size) const}{void}
@@ -689,7 +689,7 @@
\mpibind{MPI\_Win\_detach(MPI\_Win win, const~void *base)}
-\mpifnewbind{MPI\_Win\_detach(win, base, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: base \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_detach(win, base, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: base \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_DETACH(WIN, BASE, IERROR)\fargs INTEGER WIN, IERROR\\<type> BASE(*)}
%\mpicppemptybind{MPI::Win::Detach(void *base, MPI\_Aint size) const}{void}
@@ -721,7 +721,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_free(MPI\_Win *win)}
-\mpifnewbind{MPI\_Win\_free(win, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(INOUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_free(win, ierror) \fargs TYPE(MPI\_Win), INTENT(INOUT) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_FREE(WIN, IERROR)\fargs INTEGER WIN, IERROR}
\mpicppemptybind{MPI::Win::Free()}{void}
@@ -888,7 +888,7 @@
\cdeclindex{MPI\_Group}%
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_get\_group(MPI\_Win~win, MPI\_Group~*group)}
-\mpifnewbind{MPI\_Win\_get\_group(win, group, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_get\_group(win, group, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Group), INTENT(OUT) :: group \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_GET\_GROUP(WIN, GROUP, IERROR)\fargs INTEGER WIN, GROUP, IERROR}
\mpicppemptybind{MPI::Win::Get\_group() const}{MPI::Group}
@@ -936,7 +936,7 @@
\cdeclindex{MPI\_Info}%
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_set\_info(MPI\_Win~win, MPI\_Info~info)}
-\mpifnewbind{MPI\_Win\_set\_info(win, info, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_set\_info(win, info, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_SET\_INFO(WIN, INFO, IERROR)\fargs INTEGER WIN, INFO, IERROR}
\mpifunc{MPI\_WIN\_SET\_INFO} sets new values for the hints of the window associated with \mpiarg{win}.
@@ -959,7 +959,7 @@
\cdeclindex{MPI\_Info}%
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_get\_info(MPI\_Win~win, MPI\_Info~*info\_used)}
-\mpifnewbind{MPI\_Win\_get\_info(win, info\_used, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Info), INTENT(OUT) :: info\_used \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_get\_info(win, info\_used, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Info), INTENT(OUT) :: info\_used \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_GET\_INFO(WIN, INFO\_USED, IERROR)\fargs INTEGER WIN, INFO\_USED, IERROR}
\mpifunc{MPI\_WIN\_GET\_INFO} returns a new info object containing the hints of the window associated with \mpiarg{win}.
@@ -1082,7 +1082,7 @@
\mpibind{MPI\_Put(const void *origin\_addr, int origin\_count, MPI\_Datatype origin\_datatype, int target\_rank, MPI\_Aint target\_disp, int target\_count, MPI\_Datatype target\_datatype, MPI\_Win win)}
-\mpifnewbind{MPI\_Put(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Put(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_PUT(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, WIN, IERROR)\fargs <type> ORIGIN\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, WIN, IERROR}
@@ -1199,7 +1199,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Get(void *origin\_addr, int origin\_count, MPI\_Datatype~origin\_datatype, int~target\_rank, MPI\_Aint~target\_disp, int~target\_count, MPI\_Datatype~target\_datatype, MPI\_Win~win)}
-\mpifnewbind{MPI\_Get(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, WIN, IERROR)\fargs <type> ORIGIN\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, WIN, IERROR}
% \mpicppemptybind{MPI::Win::Get(const void *origin\_addr, int origin\_count, const MPI::Datatype\& origin\_datatype, int target\_rank, MPI::Aint target\_disp, int target\_count, const MPI::Datatype\& target\_datatype) const}{void}
@@ -1410,7 +1410,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Accumulate(const void~*origin\_addr, int~origin\_count, MPI\_Datatype~origin\_datatype, int~target\_rank, MPI\_Aint~target\_disp, int~target\_count, MPI\_Datatype~target\_datatype, MPI\_Op~op, MPI\_Win~win)}
-\mpifnewbind{MPI\_Accumulate(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Accumulate(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ACCUMULATE(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, IERROR) \fargs <type> ORIGIN\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE,TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, IERROR}
\mpicppemptybind{MPI::Win::Accumulate(const void* origin\_addr, int origin\_count, const MPI::Datatype\& origin\_datatype, int target\_rank, MPI::Aint target\_disp, int target\_count, const MPI::Datatype\& target\_datatype, const MPI::Op\& op) const}{void}
@@ -1553,7 +1553,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Get\_accumulate(const~void~*origin\_addr, int~origin\_count, MPI\_Datatype~origin\_datatype, void~*result\_addr, int~result\_count, MPI\_Datatype~result\_datatype, int~target\_rank, MPI\_Aint~target\_disp, int~target\_count, MPI\_Datatype~target\_datatype, MPI\_Op~op, MPI\_Win~win)}
-\mpifnewbind{MPI\_Get\_accumulate(origin\_addr, origin\_count, origin\_datatype, result\_addr, result\_count, result\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ INTEGER, INTENT(IN) :: origin\_count, result\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype, result\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_accumulate(origin\_addr, origin\_count, origin\_datatype, result\_addr, result\_count, result\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ INTEGER, INTENT(IN) :: origin\_count, result\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype, result\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_ACCUMULATE(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, RESULT\_ADDR, RESULT\_COUNT, RESULT\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, IERROR) \fargs <type> ORIGIN\_ADDR(*), RESULT\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE, RESULT\_COUNT, RESULT\_DATATYPE, TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, IERROR}
%\mpicppemptybind{MPI::Win::Get\_accumulate(const void* origin\_addr, void* result\_addr, const MPI::Datatype\& datatype, int target\_rank, MPI::Aint target\_disp, const MPI::Op\& op) const}{void}
@@ -1637,7 +1637,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Fetch\_and\_op(const~void~*origin\_addr, void~*result\_addr, MPI\_Datatype~datatype, int~target\_rank, MPI\_Aint~target\_disp, MPI\_Op~op, MPI\_Win~win)}
-\mpifnewbind{MPI\_Fetch\_and\_op(origin\_addr, result\_addr, datatype, target\_rank, target\_disp, op, win, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: target\_rank \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Fetch\_and\_op(origin\_addr, result\_addr, datatype, target\_rank, target\_disp, op, win, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: target\_rank \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_FETCH\_AND\_OP(ORIGIN\_ADDR, RESULT\_ADDR, DATATYPE, TARGET\_RANK, TARGET\_DISP, OP, WIN, IERROR) \fargs <type> ORIGIN\_ADDR(*), RESULT\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER DATATYPE, TARGET\_RANK, OP, WIN, IERROR}
%\mpicppemptybind{MPI::Win::Fetch\_and\_op(const void* origin\_addr, void* result\_addr, const MPI::Datatype\& datatype, int target\_rank, MPI::Aint target\_disp, const MPI::Op\& op) const}{void}
@@ -1683,7 +1683,7 @@
% compare_addr gets its own declaration to avoid having it spill to the next
% line.
-\mpifnewbind{MPI\_Compare\_and\_swap(origin\_addr, compare\_addr, result\_addr, datatype, target\_rank, target\_disp, win, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: compare\_addr \\TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: target\_rank \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Compare\_and\_swap(origin\_addr, compare\_addr, result\_addr, datatype, target\_rank, target\_disp, win, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: compare\_addr \\TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(IN) :: target\_rank \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_COMPARE\_AND\_SWAP(ORIGIN\_ADDR, COMPARE\_ADDR, RESULT\_ADDR, DATATYPE, TARGET\_RANK, TARGET\_DISP, WIN, IERROR) \fargs <type> ORIGIN\_ADDR(*), COMPARE\_ADDR(*), RESULT\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER DATATYPE, TARGET\_RANK, WIN, IERROR}
%\mpicppemptybind{MPI::Win::Compare\_and\_swap(const void* origin\_addr, const void* compare\_addr, void* result\_addr, const MPI::Datatype\& datatype, int target\_rank, MPI::Aint target\_disp) const}{void}
@@ -1763,7 +1763,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Rput(const~void *origin\_addr, int origin\_count, MPI\_Datatype~origin\_datatype, int~target\_rank, MPI\_Aint~target\_disp, int~target\_count, MPI\_Datatype~target\_datatype, MPI\_Win~win, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Rput(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Rput(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RPUT(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, WIN, REQUEST, IERROR)\fargs <type> ORIGIN\_ADDR(*)\\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, WIN, REQUEST, IERROR}
\mpifunc{MPI\_RPUT} is similar to \mpifunc{MPI\_PUT}
@@ -1804,7 +1804,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Rget(void *origin\_addr, int origin\_count, MPI\_Datatype~origin\_datatype, int~target\_rank, MPI\_Aint~target\_disp, int~target\_count, MPI\_Datatype~target\_datatype, MPI\_Win~win, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Rget(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Rget(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, win, request, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RGET(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, WIN, REQUEST, IERROR)\fargs <type> ORIGIN\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, WIN, REQUEST, IERROR}
\mpifunc{MPI\_RGET} is similar to \mpifunc{MPI\_GET}
@@ -1836,7 +1836,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Raccumulate(const~void~*origin\_addr, int~origin\_count, MPI\_Datatype~origin\_datatype, int~target\_rank, MPI\_Aint~target\_disp, int~target\_count, MPI\_Datatype~target\_datatype, MPI\_Op~op, MPI\_Win~win, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Raccumulate(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Raccumulate(origin\_addr, origin\_count, origin\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ INTEGER, INTENT(IN) :: origin\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RACCUMULATE(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, REQUEST, IERROR) \fargs <type> ORIGIN\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE, TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, REQUEST, IERROR}
\mpifunc{MPI\_RACCUMULATE} is similar to \mpifunc{MPI\_ACCUMULATE}
@@ -1872,7 +1872,7 @@
\cdeclindex{MPI\_Aint}%
\mpibind{MPI\_Rget\_accumulate(const~void~*origin\_addr, int~origin\_count, MPI\_Datatype~origin\_datatype, void~*result\_addr, int~result\_count, MPI\_Datatype~result\_datatype, int~target\_rank, MPI\_Aint~target\_disp, int~target\_count, MPI\_Datatype~target\_datatype, MPI\_Op~op, MPI\_Win~win, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Rget\_accumulate(origin\_addr, origin\_count, origin\_datatype, result\_addr, result\_count, result\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ INTEGER, INTENT(IN) :: origin\_count, result\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype, result\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Rget\_accumulate(origin\_addr, origin\_count, origin\_datatype, result\_addr, result\_count, result\_datatype, target\_rank, target\_disp, target\_count, target\_datatype, op, win, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: origin\_addr \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: result\_addr \\ INTEGER, INTENT(IN) :: origin\_count, result\_count, target\_rank, target\_count \\ TYPE(MPI\_Datatype), INTENT(IN) :: origin\_datatype, target\_datatype, result\_datatype \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: target\_disp \\ TYPE(MPI\_Op), INTENT(IN) :: op \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RGET\_ACCUMULATE(ORIGIN\_ADDR, ORIGIN\_COUNT, ORIGIN\_DATATYPE, RESULT\_ADDR, RESULT\_COUNT, RESULT\_DATATYPE, TARGET\_RANK, TARGET\_DISP, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, REQUEST, IERROR) \fargs <type> ORIGIN\_ADDR(*), RESULT\_ADDR(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND) TARGET\_DISP \\ INTEGER ORIGIN\_COUNT, ORIGIN\_DATATYPE, RESULT\_COUNT, RESULT\_DATATYPE, TARGET\_RANK, TARGET\_COUNT, TARGET\_DATATYPE, OP, WIN, REQUEST, IERROR}
\mpifunc{MPI\_RGET\_ACCUMULATE} is similar to
@@ -2170,7 +2170,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_fence(int~assert, MPI\_Win~win)}
-\mpifnewbind{MPI\_Win\_fence(assert, win, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_fence(assert, win, ierror) \fargs INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_FENCE(ASSERT, WIN, IERROR)\fargs INTEGER ASSERT, WIN, IERROR}
\mpicppemptybind{MPI::Win::Fence(int assert) const}{void}
@@ -2233,7 +2233,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_start(MPI\_Group group, int assert, MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_start(group, assert, win, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_start(group, assert, win, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_START(GROUP, ASSERT, WIN, IERROR)\fargs INTEGER GROUP, ASSERT, WIN, IERROR}
\mpicppemptybind{MPI::Win::Start(const MPI::Group\& group, int assert) const}{void}
@@ -2263,7 +2263,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_complete(MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_complete(win, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_complete(win, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_COMPLETE(WIN, IERROR)\fargs INTEGER WIN, IERROR}
\mpicppemptybind{MPI::Win::Complete() const}{void}
@@ -2329,7 +2329,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_post(MPI\_Group group, int assert, MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_post(group, assert, win, ierror) BIND(C) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_post(group, assert, win, ierror) \fargs TYPE(MPI\_Group), INTENT(IN) :: group \\ INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_POST(GROUP, ASSERT, WIN, IERROR)\fargs INTEGER GROUP, ASSERT, WIN, IERROR}
\mpicppemptybind{MPI::Win::Post(const MPI::Group\& group, int assert) const}{void}
@@ -2350,7 +2350,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_wait(MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_wait(win, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_wait(win, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_WAIT(WIN, IERROR)\fargs INTEGER WIN, IERROR}
\mpicppemptybind{MPI::Win::Wait() const}{void}
@@ -2396,7 +2396,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_test(MPI\_Win win, int *flag)}
-\mpifnewbind{MPI\_Win\_test(win, flag, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_test(win, flag, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_TEST(WIN, FLAG, IERROR)\fargs INTEGER WIN, IERROR\\LOGICAL FLAG}
\mpicppemptybind{MPI::Win::Test() const}{bool}
@@ -2501,7 +2501,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_lock(int lock\_type, int rank, int assert, MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_lock(lock\_type, rank, assert, win, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: lock\_type, rank, assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_lock(lock\_type, rank, assert, win, ierror) \fargs INTEGER, INTENT(IN) :: lock\_type, rank, assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_LOCK(LOCK\_TYPE, RANK, ASSERT, WIN, IERROR)\fargs INTEGER LOCK\_TYPE, RANK, ASSERT, WIN, IERROR}
\mpicppemptybind{MPI::Win::Lock(int lock\_type, int rank, int assert) const}{void}
@@ -2519,7 +2519,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_lock\_all(int assert, MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_lock\_all(assert, win, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_lock\_all(assert, win, ierror) \fargs INTEGER, INTENT(IN) :: assert \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_LOCK\_ALL(ASSERT, WIN, IERROR)\fargs INTEGER ASSERT, WIN, IERROR}
%\mpicppemptybind{MPI::Win::Lock\_all(int assert) const}{void}
@@ -2548,7 +2548,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_unlock(int rank, MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_unlock(rank, win, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: rank \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_unlock(rank, win, ierror) \fargs INTEGER, INTENT(IN) :: rank \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_UNLOCK(RANK, WIN, IERROR)\fargs INTEGER RANK, WIN, IERROR}
\mpicppemptybind{MPI::Win::Unlock(int rank) const}{void}
@@ -2564,7 +2564,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_unlock\_all(MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_unlock\_all(win, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_unlock\_all(win, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_UNLOCK\_ALL(WIN, IERROR)\fargs INTEGER WIN, IERROR}
%\mpicppemptybind{MPI::Win::Unlock\_all() const}{void}
@@ -2688,7 +2688,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_flush(int rank, MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_flush(rank, win, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: rank \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_flush(rank, win, ierror) \fargs INTEGER, INTENT(IN) :: rank \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_FLUSH(RANK, WIN, IERROR)\fargs INTEGER RANK, WIN, IERROR}
%\mpicppemptybind{MPI::Win::Flush(int rank) const}{void}
@@ -2704,7 +2704,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_flush\_all(MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_flush\_all(win, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_flush\_all(win, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_FLUSH\_ALL(WIN, IERROR)\fargs INTEGER WIN, IERROR}
%\mpicppemptybind{MPI::Win::Flush\_all() const}{void}
@@ -2722,7 +2722,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_flush\_local(int rank, MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_flush\_local(rank, win, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: rank \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_flush\_local(rank, win, ierror) \fargs INTEGER, INTENT(IN) :: rank \\ TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_FLUSH\_LOCAL(RANK, WIN, IERROR)\fargs INTEGER RANK, WIN, IERROR}
%\mpicppemptybind{MPI::Win::Flush\_local(int rank) const}{void}
@@ -2739,7 +2739,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_flush\_local\_all(MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_flush\_local\_all(win, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_flush\_local\_all(win, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_FLUSH\_LOCAL\_ALL(WIN, IERROR)\fargs INTEGER WIN, IERROR}
%\mpicppemptybind{MPI::Win::Flush\_local\_all() const}{void}
@@ -2755,7 +2755,7 @@
\cdeclindex{MPI\_Win}%
\mpibind{MPI\_Win\_sync(MPI\_Win win)}
-\mpifnewbind{MPI\_Win\_sync(win, ierror) BIND(C) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Win\_sync(win, ierror) \fargs TYPE(MPI\_Win), INTENT(IN) :: win \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WIN\_SYNC(WIN, IERROR)\fargs INTEGER WIN, IERROR}
%\mpicppemptybind{MPI::Win::sync() const}{void}
Raw
mpi31-r1835-chap-prof.diff
Index: chap-tools/prof.tex
===================================================================
--- chap-tools/prof.tex (revision 1834)
+++ chap-tools/prof.tex (revision 1835)
@@ -140,7 +140,7 @@
\funcarg{\IN}{level}{Profiling level (integer)}
\end{funcdef}
\mpibind{MPI\_Pcontrol(const~int~level, \ldots)}
-\mpifnewbind{MPI\_Pcontrol(level) BIND(C) \fargs INTEGER, INTENT(IN) :: level}
+\mpifnewbind{MPI\_Pcontrol(level) \fargs INTEGER, INTENT(IN) :: level}
\mpifbind{MPI\_PCONTROL(LEVEL)\fargs INTEGER LEVEL}
\mpicppemptybind{MPI::Pcontrol(const int~level, \ldots)}{void}
Raw
mpi31-r1835-chap-pt2pt.diff
Index: chap-pt2pt/pt2pt.tex
===================================================================
--- chap-pt2pt/pt2pt.tex (revision 1834)
+++ chap-pt2pt/pt2pt.tex (revision 1835)
@@ -94,7 +94,7 @@
\cdeclmainindex{MPI\_Comm}%
\mpibind{MPI\_Send(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Send(buf, count, datatype, dest, tag, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Send(buf, count, datatype, dest, tag, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Send(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{void}
@@ -406,7 +406,7 @@
\cdeclmainindex{MPI\_Status}%
\mpibind{MPI\_Recv(void*~buf, int~count, MPI\_Datatype~datatype, int~source, int~tag, MPI\_Comm~comm, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Recv(buf, count, datatype, source, tag, comm, status, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count, source, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Recv(buf, count, datatype, source, tag, comm, status, ierror) \fargs TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count, source, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RECV(BUF, COUNT, DATATYPE, SOURCE, TAG, COMM, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, SOURCE, TAG, COMM, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Comm::Recv(void*~buf, int~count, const~MPI::Datatype\&~datatype, int~source, int~tag, MPI::Status\&~status) const}{void}
\mpicppemptybind{MPI::Comm::Recv(void*~buf, int~count, const~MPI::Datatype\&~datatype, int~source, int~tag) const}{void}
@@ -602,7 +602,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Get\_count(const MPI\_Status~*status, MPI\_Datatype~datatype, int~*count)}
-\mpifnewbind{MPI\_Get\_count(status, datatype, count, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Get\_count(status, datatype, count, ierror) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ INTEGER, INTENT(OUT) :: count \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GET\_COUNT(STATUS, DATATYPE, COUNT, IERROR)\fargs INTEGER STATUS(MPI\_STATUS\_SIZE), DATATYPE, COUNT, IERROR}
\mpicppemptybind{MPI::Status::Get\_count(const~MPI::Datatype\&~datatype) const}{int}
@@ -1196,7 +1196,7 @@
\mpibind{MPI\_Bsend(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Bsend(buf, count, datatype, dest, tag, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Bsend(buf, count, datatype, dest, tag, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_BSEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Bsend(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{void}
@@ -1215,7 +1215,7 @@
\mpibind{MPI\_Ssend(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Ssend(buf, count, datatype, dest, tag, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ssend(buf, count, datatype, dest, tag, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SSEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Ssend(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{void}
@@ -1234,7 +1234,7 @@
\mpibind{MPI\_Rsend(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Rsend(buf, count, datatype, dest, tag, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Rsend(buf, count, datatype, dest, tag, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RSEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, IERROR}
\mpicppemptybind{MPI::Comm::Rsend(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{void}
@@ -1616,7 +1616,7 @@
\mpibind{MPI\_Buffer\_attach(void*~buffer, int~size)}
-\mpifnewbind{MPI\_Buffer\_attach(buffer, size, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buffer \\ INTEGER, INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Buffer\_attach(buffer, size, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buffer \\ INTEGER, INTENT(IN) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_BUFFER\_ATTACH(BUFFER, SIZE, IERROR)\fargs <type> BUFFER(*) \\ INTEGER SIZE, IERROR}
\mpicppemptybind{MPI::Attach\_buffer(void*~buffer, int~size)}{void}
@@ -1638,7 +1638,7 @@
\mpibind{MPI\_Buffer\_detach(void*~buffer\_addr, int*~size)}
-\mpifnewbind{MPI\_Buffer\_detach(buffer\_addr, size, ierror) BIND(C) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), INTENT(OUT) :: buffer\_addr \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Buffer\_detach(buffer\_addr, size, ierror) \fargs USE, INTRINSIC :: ISO\_C\_BINDING, ONLY : C\_PTR \\ TYPE(C\_PTR), INTENT(OUT) :: buffer\_addr \\ INTEGER, INTENT(OUT) :: size \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_BUFFER\_DETACH(BUFFER\_ADDR, SIZE, IERROR)\fargs <type> BUFFER\_ADDR(*) \\ INTEGER SIZE, IERROR}
\mpicppemptybind{MPI::Detach\_buffer(void*\&~buffer)}{int}
@@ -1929,7 +1929,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Isend(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Isend(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Isend(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ISEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Isend(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Request}
@@ -1952,7 +1952,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Ibsend(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ibsend(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ibsend(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IBSEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Ibsend(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Request}
@@ -1976,7 +1976,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Issend(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Issend(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Issend(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_ISSEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Issend(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Request}
@@ -1999,7 +1999,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Irsend(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Irsend(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Irsend(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IRSEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Irsend(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Request}
@@ -2022,7 +2022,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Irecv(void*~buf, int~count, MPI\_Datatype~datatype, int~source, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Irecv(buf, count, datatype, source, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, source, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Irecv(buf, count, datatype, source, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, source, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IRECV(BUF, COUNT, DATATYPE, SOURCE, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, SOURCE, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Irecv(void*~buf, int~count, const MPI::Datatype\&~datatype, int~source, int~tag) const}{MPI::Request}
@@ -2133,7 +2133,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Wait(MPI\_Request~*request, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Wait(request, status, ierror) BIND(C) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Wait(request, status, ierror) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WAIT(REQUEST, STATUS, IERROR)\fargs INTEGER REQUEST, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Request::Wait(MPI::Status\&~status)}{void}
\mpicppemptybind{MPI::Request::Wait()}{void}
@@ -2185,7 +2185,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Test(MPI\_Request~*request, int~*flag, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Test(request, flag, status, ierror) BIND(C) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Test(request, flag, status, ierror) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TEST(REQUEST, FLAG, STATUS, IERROR)\fargs LOGICAL FLAG \\ INTEGER REQUEST, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Request::Test(MPI::Status\&~status)}{bool}
\mpicppemptybind{MPI::Request::Test()}{bool}
@@ -2268,7 +2268,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Request\_free(MPI\_Request~*request)}
-\mpifnewbind{MPI\_Request\_free(request, ierror) BIND(C) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Request\_free(request, ierror) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_REQUEST\_FREE(REQUEST, IERROR)\fargs INTEGER REQUEST, IERROR}
\mpicppemptybind{MPI::Request::Free()}{void}
@@ -2462,7 +2462,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Waitany(int~count, MPI\_Request~array\_of\_requests[], int~*index, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Waitany(count, array\_of\_requests, index, status, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ INTEGER, INTENT(OUT) :: index \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Waitany(count, array\_of\_requests, index, status, ierror) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ INTEGER, INTENT(OUT) :: index \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WAITANY(COUNT, ARRAY\_OF\_REQUESTS, INDEX, STATUS, IERROR)\fargs INTEGER COUNT, ARRAY\_OF\_REQUESTS(*), INDEX, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Request::Waitany(int~count, MPI::Request~array\_of\_requests[], MPI::Status\&~status)}{static int}
\mpicppemptybind{MPI::Request::Waitany(int~count, MPI::Request~array\_of\_requests[])}{static int}
@@ -2514,7 +2514,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Testany(int~count, MPI\_Request~array\_of\_requests[], int~*index, int~*flag, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Testany(count, array\_of\_requests, index, flag, status, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ INTEGER, INTENT(OUT) :: index \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Testany(count, array\_of\_requests, index, flag, status, ierror) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ INTEGER, INTENT(OUT) :: index \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TESTANY(COUNT, ARRAY\_OF\_REQUESTS, INDEX, FLAG, STATUS, IERROR)\fargs LOGICAL FLAG \\ INTEGER COUNT, ARRAY\_OF\_REQUESTS(*), INDEX, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Request::Testany(int~count, MPI::Request~array\_of\_requests[], int\&~index, MPI::Status\&~status)}{static bool}
\mpicppemptybind{MPI::Request::Testany(int~count, MPI::Request~array\_of\_requests[], int\&~index)}{static bool}
@@ -2567,7 +2567,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Waitall(int~count, MPI\_Request~array\_of\_requests[], MPI\_Status~array\_of\_statuses[])}
-\mpifnewbind{MPI\_Waitall(count, array\_of\_requests, array\_of\_statuses, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Waitall(count, array\_of\_requests, array\_of\_statuses, ierror) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WAITALL(COUNT, ARRAY\_OF\_REQUESTS, ARRAY\_OF\_STATUSES, IERROR)\fargs INTEGER COUNT, ARRAY\_OF\_REQUESTS(*) \\ INTEGER ARRAY\_OF\_STATUSES(MPI\_STATUS\_SIZE,*), IERROR}
\mpicppemptybind{MPI::Request::Waitall(int~count, MPI::Request~array\_of\_requests[], MPI::Status~array\_of\_statuses[])}{static void}
\mpicppemptybind{MPI::Request::Waitall(int~count, MPI::Request~array\_of\_requests[])}{static void}
@@ -2631,7 +2631,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Testall(int~count, MPI\_Request~array\_of\_requests[], int~*flag, MPI\_Status~array\_of\_statuses[])}
-\mpifnewbind{MPI\_Testall(count, array\_of\_requests, flag, array\_of\_statuses, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Testall(count, array\_of\_requests, flag, array\_of\_statuses, ierror) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TESTALL(COUNT, ARRAY\_OF\_REQUESTS, FLAG, ARRAY\_OF\_STATUSES, IERROR)\fargs LOGICAL FLAG \\ INTEGER COUNT, ARRAY\_OF\_REQUESTS(*), ARRAY\_OF\_STATUSES(MPI\_STATUS\_SIZE,*), IERROR}
\mpicppemptybind{MPI::Request::Testall(int~count, MPI::Request~array\_of\_requests[], MPI::Status~array\_of\_statuses[])}{static bool}
\mpicppemptybind{MPI::Request::Testall(int~count, MPI::Request~array\_of\_requests[])}{static bool}
@@ -2676,7 +2676,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Waitsome(int~incount, MPI\_Request~array\_of\_requests[], int~*outcount, int~array\_of\_indices[], MPI\_Status~array\_of\_statuses[])}
-\mpifnewbind{MPI\_Waitsome(incount, array\_of\_requests, outcount, array\_of\_indices, array\_of\_statuses, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(incount) \\ INTEGER, INTENT(OUT) :: outcount, array\_of\_indices(*) \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Waitsome(incount, array\_of\_requests, outcount, array\_of\_indices, array\_of\_statuses, ierror) \fargs INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(incount) \\ INTEGER, INTENT(OUT) :: outcount, array\_of\_indices(*) \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_WAITSOME(INCOUNT, ARRAY\_OF\_REQUESTS, OUTCOUNT, ARRAY\_OF\_INDICES, ARRAY\_OF\_STATUSES, IERROR)\fargs INTEGER INCOUNT, ARRAY\_OF\_REQUESTS(*), OUTCOUNT, ARRAY\_OF\_INDICES(*), ARRAY\_OF\_STATUSES(MPI\_STATUS\_SIZE,*), IERROR}
\mpicppemptybind{MPI::Request::Waitsome(int~incount, MPI::Request~array\_of\_requests[], int~array\_of\_indices[], MPI::Status~array\_of\_statuses[])}{static int}
\mpicppemptybind{MPI::Request::Waitsome(int~incount, MPI::Request~array\_of\_requests[], int~array\_of\_indices[])}{static int}
@@ -2732,7 +2732,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Testsome(int~incount, MPI\_Request~array\_of\_requests[], int~*outcount, int~array\_of\_indices[], MPI\_Status~array\_of\_statuses[])}
-\mpifnewbind{MPI\_Testsome(incount, array\_of\_requests, outcount, array\_of\_indices, array\_of\_statuses, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(incount) \\ INTEGER, INTENT(OUT) :: outcount, array\_of\_indices(*) \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Testsome(incount, array\_of\_requests, outcount, array\_of\_indices, array\_of\_statuses, ierror) \fargs INTEGER, INTENT(IN) :: incount \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(incount) \\ INTEGER, INTENT(OUT) :: outcount, array\_of\_indices(*) \\ TYPE(MPI\_Status) :: array\_of\_statuses(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TESTSOME(INCOUNT, ARRAY\_OF\_REQUESTS, OUTCOUNT, ARRAY\_OF\_INDICES, ARRAY\_OF\_STATUSES, IERROR)\fargs INTEGER INCOUNT, ARRAY\_OF\_REQUESTS(*), OUTCOUNT, ARRAY\_OF\_INDICES(*), ARRAY\_OF\_STATUSES(MPI\_STATUS\_SIZE,*), IERROR}
\mpicppemptybind{MPI::Request::Testsome(int~incount, MPI::Request~array\_of\_requests[], int~array\_of\_indices[], MPI::Status~array\_of\_statuses[])}{static int}
\mpicppemptybind{MPI::Request::Testsome(int~incount, MPI::Request~array\_of\_requests[], int~array\_of\_indices[])}{static int}
@@ -2885,7 +2885,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Request\_get\_status(MPI\_Request~request, int~*flag, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Request\_get\_status(request, flag, status, ierror) BIND(C) \fargs TYPE(MPI\_Request), INTENT(IN) :: request \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Request\_get\_status(request, flag, status, ierror) \fargs TYPE(MPI\_Request), INTENT(IN) :: request \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_REQUEST\_GET\_STATUS( REQUEST, FLAG, STATUS, IERROR) \fargs INTEGER REQUEST, STATUS(MPI\_STATUS\_SIZE), IERROR\\LOGICAL FLAG}
\mpicppemptybind{MPI::Request::Get\_status(MPI::Status\& status) const}{bool}
@@ -2933,7 +2933,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Iprobe(int~source, int~tag, MPI\_Comm~comm, int~*flag, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Iprobe(source, tag, comm, flag, status, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Iprobe(source, tag, comm, flag, status, ierror) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ LOGICAL, INTENT(OUT) :: flag \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IPROBE(SOURCE, TAG, COMM, FLAG, STATUS, IERROR)\fargs LOGICAL FLAG \\ INTEGER SOURCE, TAG, COMM, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Comm::Iprobe(int~source, int~tag, MPI::Status\&~status) const}{bool}
\mpicppemptybind{MPI::Comm::Iprobe(int~source, int~tag) const}{bool}
@@ -2990,7 +2990,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Probe(int~source, int~tag, MPI\_Comm~comm, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Probe(source, tag, comm, status, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Probe(source, tag, comm, status, ierror) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_PROBE(SOURCE, TAG, COMM, STATUS, IERROR)\fargs INTEGER SOURCE, TAG, COMM, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Comm::Probe(int~source, int~tag, MPI::Status\&~status) const}{void}
\mpicppemptybind{MPI::Comm::Probe(int~source, int~tag) const}{void}
@@ -3165,7 +3165,7 @@
\cdeclmainindex{MPI\_Message}%
\mpibind{MPI\_Improbe(int~source, int~tag, MPI\_Comm~comm, int~*flag, MPI\_Message~*message, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Improbe(source, tag, comm, flag, message, status, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: flag \\ TYPE(MPI\_Message), INTENT(OUT) :: message \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Improbe(source, tag, comm, flag, message, status, ierror) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: flag \\ TYPE(MPI\_Message), INTENT(OUT) :: message \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IMPROBE(SOURCE, TAG, COMM, FLAG, MESSAGE, STATUS, IERROR)\fargs INTEGER SOURCE, TAG, COMM, FLAG, MESSAGE, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpifunc{MPI\_IMPROBE(source, tag, comm, flag, message, status)} returns
@@ -3226,7 +3226,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Mprobe(int~source, int~tag, MPI\_Comm~comm, MPI\_Message~*message, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Mprobe(source, tag, comm, message, status, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Message), INTENT(OUT) :: message \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Mprobe(source, tag, comm, message, status, ierror) \fargs INTEGER, INTENT(IN) :: source, tag \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Message), INTENT(OUT) :: message \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_MPROBE(SOURCE, TAG, COMM, MESSAGE, STATUS, IERROR)\fargs INTEGER SOURCE, TAG, COMM, MESSAGE, STATUS(MPI\_STATUS\_SIZE), IERROR}
@@ -3258,7 +3258,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Mrecv(void*~buf, int~count, MPI\_Datatype~datatype, MPI\_Message~*message, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Mrecv(buf, count, datatype, message, status, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Message), INTENT(INOUT) :: message \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Mrecv(buf, count, datatype, message, status, ierror) \fargs TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Message), INTENT(INOUT) :: message \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_MRECV(BUF, COUNT, DATATYPE, MESSAGE, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, MESSAGE, STATUS(MPI\_STATUS\_SIZE), IERROR}
This call receives a message matched by a matching probe operation
@@ -3304,7 +3304,7 @@
\mpibind{MPI\_Imrecv(void*~buf, int~count, MPI\_Datatype~datatype, MPI\_Message~*message, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Imrecv(buf, count, datatype, message, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Message), INTENT(INOUT) :: message \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Imrecv(buf, count, datatype, message, request, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Message), INTENT(INOUT) :: message \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_IMRECV(BUF, COUNT, DATATYPE, MESSAGE, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, MESSAGE, REQUEST, IERROR}
\mpifunc{MPI\_IMRECV} is the nonblocking variant of \mpifunc{MPI\_MRECV}
@@ -3344,7 +3344,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Cancel(MPI\_Request~*request)}
-\mpifnewbind{MPI\_Cancel(request, ierror) BIND(C) \fargs TYPE(MPI\_Request), INTENT(IN) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cancel(request, ierror) \fargs TYPE(MPI\_Request), INTENT(IN) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CANCEL(REQUEST, IERROR)\fargs INTEGER REQUEST, IERROR}
\mpicppemptybind{MPI::Request::Cancel() const}{void}
@@ -3411,7 +3411,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Test\_cancelled(const MPI\_Status~*status, int~*flag)}
-\mpifnewbind{MPI\_Test\_cancelled(status, flag, ierror) BIND(C) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Test\_cancelled(status, flag, ierror) \fargs TYPE(MPI\_Status), INTENT(IN) :: status \\ LOGICAL, INTENT(OUT) :: flag \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TEST\_CANCELLED(STATUS, FLAG, IERROR)\fargs LOGICAL FLAG \\ INTEGER STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Status::Is\_cancelled() const}{bool}
@@ -3487,7 +3487,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Send\_init(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Send\_init(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Send\_init(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SEND\_INIT(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Send\_init(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Prequest}
@@ -3514,7 +3514,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Bsend\_init(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Bsend\_init(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Bsend\_init(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_BSEND\_INIT(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Bsend\_init(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Prequest}
@@ -3539,7 +3539,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Ssend\_init(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ssend\_init(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ssend\_init(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SSEND\_INIT(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Ssend\_init(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Prequest}
@@ -3564,7 +3564,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Rsend\_init(const void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Rsend\_init(buf, count, datatype, dest, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Rsend\_init(buf, count, datatype, dest, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, dest, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RSEND\_INIT(BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Rsend\_init(const void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~tag) const}{MPI::Prequest}
@@ -3589,7 +3589,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Recv\_init(void*~buf, int~count, MPI\_Datatype~datatype, int~source, int~tag, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Recv\_init(buf, count, datatype, source, tag, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, source, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Recv\_init(buf, count, datatype, source, tag, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), ASYNCHRONOUS :: buf \\ INTEGER, INTENT(IN) :: count, source, tag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_RECV\_INIT(BUF, COUNT, DATATYPE, SOURCE, TAG, COMM, REQUEST, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, SOURCE, TAG, COMM, REQUEST, IERROR}
\mpicppemptybind{MPI::Comm::Recv\_init(void*~buf, int~count, const MPI::Datatype\&~datatype, int~source, int~tag) const}{MPI::Prequest}
@@ -3611,7 +3611,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Start(MPI\_Request~*request)}
-\mpifnewbind{MPI\_Start(request, ierror) BIND(C) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Start(request, ierror) \fargs TYPE(MPI\_Request), INTENT(INOUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_START(REQUEST, IERROR)\fargs INTEGER REQUEST, IERROR}
\mpicppemptybind{MPI::Prequest::Start()}{void}
@@ -3651,7 +3651,7 @@
\cdeclindex{MPI\_Request}%
\mpibind{MPI\_Startall(int~count, MPI\_Request~array\_of\_requests[])}
-\mpifnewbind{MPI\_Startall(count, array\_of\_requests, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Startall(count, array\_of\_requests, ierror) \fargs INTEGER, INTENT(IN) :: count \\ TYPE(MPI\_Request), INTENT(INOUT) :: array\_of\_requests(count) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_STARTALL(COUNT, ARRAY\_OF\_REQUESTS, IERROR)\fargs INTEGER COUNT, ARRAY\_OF\_REQUESTS(*), IERROR}
\mpicppemptybind{MPI::Prequest::Startall(int~count, MPI::Prequest~array\_of\_requests[])}{static void}
@@ -3774,7 +3774,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Sendrecv(const void~*sendbuf, int~sendcount, MPI\_Datatype~sendtype, int~dest, int~sendtag, void~*recvbuf, int~recvcount, MPI\_Datatype~recvtype, int~source, int~recvtag, MPI\_Comm~comm, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Sendrecv(sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, dest, sendtag, recvcount, source, recvtag \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Sendrecv(sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, dest, sendtag, recvcount, source, recvtag \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SENDRECV(SENDBUF, SENDCOUNT, SENDTYPE, DEST, SENDTAG, RECVBUF, RECVCOUNT, RECVTYPE, SOURCE, RECVTAG, COMM, STATUS, IERROR)\fargs <type> SENDBUF(*), RECVBUF(*) \\ INTEGER SENDCOUNT, SENDTYPE, DEST, SENDTAG, RECVCOUNT, RECVTYPE, SOURCE, RECVTAG, COMM, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Comm::Sendrecv(const void~*sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, int~dest, int~sendtag, void~*recvbuf, int~recvcount, const~MPI::Datatype\&~recvtype, int~source, int~recvtag, MPI::Status\&~status) const}{void}
\mpicppemptybind{MPI::Comm::Sendrecv(const void~*sendbuf, int~sendcount, const MPI::Datatype\&~sendtype, int~dest, int~sendtag, void~*recvbuf, int~recvcount, const~MPI::Datatype\&~recvtype, int~source, int~recvtag) const}{void}
@@ -3809,7 +3809,7 @@
\cdeclindex{MPI\_Status}%
\mpibind{MPI\_Sendrecv\_replace(void*~buf, int~count, MPI\_Datatype~datatype, int~dest, int~sendtag, int~source, int~recvtag, MPI\_Comm~comm, MPI\_Status~*status)}
-\mpifnewbind{MPI\_Sendrecv\_replace(buf, count, datatype, dest, sendtag, source, recvtag, comm, status, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count, dest, sendtag, source, recvtag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Sendrecv\_replace(buf, count, datatype, dest, sendtag, source, recvtag, comm, status, ierror) \fargs TYPE(*), DIMENSION(..) :: buf \\ INTEGER, INTENT(IN) :: count, dest, sendtag, source, recvtag \\ TYPE(MPI\_Datatype), INTENT(IN) :: datatype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Status) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_SENDRECV\_REPLACE(BUF, COUNT, DATATYPE, DEST, SENDTAG, SOURCE, RECVTAG, COMM, STATUS, IERROR)\fargs <type> BUF(*) \\ INTEGER COUNT, DATATYPE, DEST, SENDTAG, SOURCE, RECVTAG, COMM, STATUS(MPI\_STATUS\_SIZE), IERROR}
\mpicppemptybind{MPI::Comm::Sendrecv\_replace(void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~sendtag, int~source, int~recvtag, MPI::Status\&~status) const}{void}
\mpicppemptybind{MPI::Comm::Sendrecv\_replace(void*~buf, int~count, const MPI::Datatype\&~datatype, int~dest, int~sendtag, int~source, int~recvtag) const}{void}
Raw
mpi31-r1835-chap-topol.diff
Index: chap-topol/topol.tex
===================================================================
--- chap-topol/topol.tex (revision 1834)
+++ chap-topol/topol.tex (revision 1835)
@@ -216,7 +216,7 @@
\mpibind{MPI\_Cart\_create(MPI\_Comm~comm\_old, int~ndims, const int~dims[], const int~periods[], int~reorder, MPI\_Comm~*comm\_cart)}
-\mpifnewbind{MPI\_Cart\_create(comm\_old, ndims, dims, periods, reorder, comm\_cart, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: ndims, dims(ndims) \\ LOGICAL, INTENT(IN) :: periods(ndims), reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_cart \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cart\_create(comm\_old, ndims, dims, periods, reorder, comm\_cart, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: ndims, dims(ndims) \\ LOGICAL, INTENT(IN) :: periods(ndims), reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_cart \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CART\_CREATE(COMM\_OLD, NDIMS, DIMS, PERIODS, REORDER, COMM\_CART, IERROR)\fargs INTEGER COMM\_OLD, NDIMS, DIMS(*), COMM\_CART, IERROR \\ LOGICAL PERIODS(*), REORDER}
\mpicppemptybind{MPI::Intracomm::Create\_cart(int~ndims, const~int~dims[], const~bool~periods[], bool~reorder) const}{MPI::Cartcomm}
@@ -251,7 +251,7 @@
\mpibind{MPI\_Dims\_create(int~nnodes, int~ndims, int~dims[])}
-\mpifnewbind{MPI\_Dims\_create(nnodes, ndims, dims, ierror) BIND(C) \fargs INTEGER, INTENT(IN) :: nnodes, ndims \\ INTEGER, INTENT(INOUT) :: dims(ndims) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Dims\_create(nnodes, ndims, dims, ierror) \fargs INTEGER, INTENT(IN) :: nnodes, ndims \\ INTEGER, INTENT(INOUT) :: dims(ndims) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_DIMS\_CREATE(NNODES, NDIMS, DIMS, IERROR)\fargs INTEGER NNODES, NDIMS, DIMS(*), IERROR}
\mpicppemptybind{MPI::Compute\_dims(int~nnodes, int~ndims, int~dims[])}{void}
@@ -303,7 +303,7 @@
\mpibind{MPI\_Graph\_create(MPI\_Comm~comm\_old, int~nnodes, const int~index[], const int~edges[], int~reorder, MPI\_Comm~*comm\_graph)}
-\mpifnewbind{MPI\_Graph\_create(comm\_old, nnodes, index, edges, reorder, comm\_graph, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: nnodes, index(nnodes), edges(*) \\ LOGICAL, INTENT(IN) :: reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_graph \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Graph\_create(comm\_old, nnodes, index, edges, reorder, comm\_graph, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: nnodes, index(nnodes), edges(*) \\ LOGICAL, INTENT(IN) :: reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_graph \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GRAPH\_CREATE(COMM\_OLD, NNODES, INDEX, EDGES, REORDER, COMM\_GRAPH, IERROR)\fargs INTEGER COMM\_OLD, NNODES, INDEX(*), EDGES(*), COMM\_GRAPH, IERROR \\ LOGICAL REORDER}
\mpicppemptybind{MPI::Intracomm::Create\_graph(int~nnodes, const~int~index[], const~int~edges[], bool~reorder) const}{MPI::Graphcomm}
@@ -471,7 +471,7 @@
\mpibind{MPI\_Dist\_graph\_create\_adjacent(MPI\_Comm~comm\_old, int~indegree, const int~sources[], const int~sourceweights[], int~outdegree, const int~destinations[], const int destweights[], MPI\_Info~info, int~reorder, MPI\_Comm~*comm\_dist\_graph)}
-\mpifnewbind{MPI\_Dist\_graph\_create\_adjacent(comm\_old, indegree, sources, sourceweights, outdegree, destinations, destweights, info, reorder, comm\_dist\_graph, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: indegree, sources(indegree), outdegree, destinations(outdegree) \\ INTEGER, INTENT(IN) :: sourceweights(*), destweights(*) \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ LOGICAL, INTENT(IN) :: reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_dist\_graph \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Dist\_graph\_create\_adjacent(comm\_old, indegree, sources, sourceweights, outdegree, destinations, destweights, info, reorder, comm\_dist\_graph, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: indegree, sources(indegree), outdegree, destinations(outdegree) \\ INTEGER, INTENT(IN) :: sourceweights(*), destweights(*) \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ LOGICAL, INTENT(IN) :: reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_dist\_graph \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_DIST\_GRAPH\_CREATE\_ADJACENT(COMM\_OLD, INDEGREE, SOURCES, SOURCEWEIGHTS, OUTDEGREE, DESTINATIONS, DESTWEIGHTS, INFO, REORDER, COMM\_DIST\_GRAPH, IERROR)\fargs INTEGER COMM\_OLD, INDEGREE, SOURCES(*), SOURCEWEIGHTS(*), OUTDEGREE, \\ \ \ \ \ DESTINATIONS(*), DESTWEIGHTS(*), INFO, COMM\_DIST\_GRAPH, IERROR \\ LOGICAL REORDER}
\mpicppemptybind{MPI::Intracomm::Dist\_graph\_create\_adjacent(int indegree, const~int~sources[], const~int~sourceweights[], int~outdegree, const~int~destinations[], const~int~destweights[], const~MPI::Info\&~info, bool~reorder) const}{MPI::Distgraphcomm}
@@ -567,7 +567,7 @@
\mpibind{MPI\_Dist\_graph\_create(MPI\_Comm~comm\_old, int~n, const int~sources[], const int~degrees[], const int~destinations[], const int~weights[], MPI\_Info~info, int~reorder, MPI\_Comm~*comm\_dist\_graph)}
-\mpifnewbind{MPI\_Dist\_graph\_create(comm\_old, n, sources, degrees, destinations, weights, info, reorder, comm\_dist\_graph, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: n, sources(n), degrees(n), destinations(*) \\ INTEGER, INTENT(IN) :: weights(*) \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ LOGICAL, INTENT(IN) :: reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_dist\_graph \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Dist\_graph\_create(comm\_old, n, sources, degrees, destinations, weights, info, reorder, comm\_dist\_graph, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm\_old \\ INTEGER, INTENT(IN) :: n, sources(n), degrees(n), destinations(*) \\ INTEGER, INTENT(IN) :: weights(*) \\ TYPE(MPI\_Info), INTENT(IN) :: info \\ LOGICAL, INTENT(IN) :: reorder \\ TYPE(MPI\_Comm), INTENT(OUT) :: comm\_dist\_graph \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_DIST\_GRAPH\_CREATE(COMM\_OLD, N, SOURCES, DEGREES, DESTINATIONS, WEIGHTS, INFO, REORDER, COMM\_DIST\_GRAPH, IERROR)\fargs INTEGER COMM\_OLD, N, SOURCES(*), DEGREES(*), DESTINATIONS(*), WEIGHTS(*), INFO, COMM\_DIST\_GRAPH, IERROR \\ LOGICAL REORDER}
\mpicppemptybind{MPI::Intracomm::Dist\_graph\_create(int~n, const~int~sources[], const~int~degrees[], const~int destinations[], const~int~weights[], const~MPI::Info\&~info, bool~reorder) const}{MPI::Distgraphcomm}
@@ -822,7 +822,7 @@
\mpibind{MPI\_Topo\_test(MPI\_Comm~comm, int~*status)}
-\mpifnewbind{MPI\_Topo\_test(comm, status, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Topo\_test(comm, status, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: status \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_TOPO\_TEST(COMM, STATUS, IERROR)\fargs INTEGER COMM, STATUS, IERROR}
\mpicppemptybind{MPI::Comm::Get\_topology() const}{int}
@@ -845,7 +845,7 @@
\mpibind{MPI\_Graphdims\_get(MPI\_Comm~comm, int~*nnodes, int~*nedges)}
-\mpifnewbind{MPI\_Graphdims\_get(comm, nnodes, nedges, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: nnodes, nedges \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Graphdims\_get(comm, nnodes, nedges, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: nnodes, nedges \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GRAPHDIMS\_GET(COMM, NNODES, NEDGES, IERROR)\fargs INTEGER COMM, NNODES, NEDGES, IERROR}
\mpicppemptybind{MPI::Graphcomm::Get\_dims(int~nnodes[], int~nedges[]) const}{void}
@@ -869,7 +869,7 @@
\mpibind{MPI\_Graph\_get(MPI\_Comm~comm, int~maxindex, int~maxedges, int~index[], int~edges[])}
-\mpifnewbind{MPI\_Graph\_get(comm, maxindex, maxedges, index, edges, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: maxindex, maxedges \\ INTEGER, INTENT(OUT) :: index(maxindex), edges(maxedges) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Graph\_get(comm, maxindex, maxedges, index, edges, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: maxindex, maxedges \\ INTEGER, INTENT(OUT) :: index(maxindex), edges(maxedges) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GRAPH\_GET(COMM, MAXINDEX, MAXEDGES, INDEX, EDGES, IERROR)\fargs INTEGER COMM, MAXINDEX, MAXEDGES, INDEX(*), EDGES(*), IERROR}
\mpicppemptybind{MPI::Graphcomm::Get\_topo(int~maxindex, int~maxedges, int~index[], int~edges[]) const}{void}
@@ -880,7 +880,7 @@
\mpibind{MPI\_Cartdim\_get(MPI\_Comm~comm, int~*ndims)}
-\mpifnewbind{MPI\_Cartdim\_get(comm, ndims, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: ndims \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cartdim\_get(comm, ndims, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: ndims \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CARTDIM\_GET(COMM, NDIMS, IERROR)\fargs INTEGER COMM, NDIMS, IERROR}
\mpicppemptybind{MPI::Cartcomm::Get\_dim() const}{int}
@@ -902,7 +902,7 @@
\mpibind{MPI\_Cart\_get(MPI\_Comm~comm, int~maxdims, int~dims[], int~periods[], int~coords[])}
-\mpifnewbind{MPI\_Cart\_get(comm, maxdims, dims, periods, coords, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: maxdims \\ INTEGER, INTENT(OUT) :: dims(maxdims), coords(maxdims) \\ LOGICAL, INTENT(OUT) :: periods(maxdims) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cart\_get(comm, maxdims, dims, periods, coords, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: maxdims \\ INTEGER, INTENT(OUT) :: dims(maxdims), coords(maxdims) \\ LOGICAL, INTENT(OUT) :: periods(maxdims) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CART\_GET(COMM, MAXDIMS, DIMS, PERIODS, COORDS, IERROR)\fargs INTEGER COMM, MAXDIMS, DIMS(*), COORDS(*), IERROR \\ LOGICAL PERIODS(*)}
\mpicppemptybind{MPI::Cartcomm::Get\_topo(int~maxdims, int~dims[], bool~periods[], int~coords[]) const}{void}
@@ -914,7 +914,7 @@
\mpibind{MPI\_Cart\_rank(MPI\_Comm~comm, const int~coords[], int~*rank)}
-\mpifnewbind{MPI\_Cart\_rank(comm, coords, rank, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: coords(*) \\ INTEGER, INTENT(OUT) :: rank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cart\_rank(comm, coords, rank, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: coords(*) \\ INTEGER, INTENT(OUT) :: rank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CART\_RANK(COMM, COORDS, RANK, IERROR)\fargs INTEGER COMM, COORDS(*), RANK, IERROR}
\mpicppemptybind{MPI::Cartcomm::Get\_cart\_rank(const~int~coords[]) const}{int}
@@ -942,7 +942,7 @@
\mpibind{MPI\_Cart\_coords(MPI\_Comm~comm, int~rank, int~maxdims, int~coords[])}
-\mpifnewbind{MPI\_Cart\_coords(comm, rank, maxdims, coords, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: rank, maxdims \\ INTEGER, INTENT(OUT) :: coords(maxdims) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cart\_coords(comm, rank, maxdims, coords, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: rank, maxdims \\ INTEGER, INTENT(OUT) :: coords(maxdims) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CART\_COORDS(COMM, RANK, MAXDIMS, COORDS, IERROR)\fargs INTEGER COMM, RANK, MAXDIMS, COORDS(*), IERROR}
\mpicppemptybind{MPI::Cartcomm::Get\_coords(int~rank, int~maxdims, int~coords[]) const}{void}
@@ -960,7 +960,7 @@
\mpibind{MPI\_Graph\_neighbors\_count(MPI\_Comm~comm, int~rank, int~*nneighbors)}
-\mpifnewbind{MPI\_Graph\_neighbors\_count(comm, rank, nneighbors, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: rank \\ INTEGER, INTENT(OUT) :: nneighbors \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Graph\_neighbors\_count(comm, rank, nneighbors, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: rank \\ INTEGER, INTENT(OUT) :: nneighbors \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GRAPH\_NEIGHBORS\_COUNT(COMM, RANK, NNEIGHBORS, IERROR)\fargs INTEGER COMM, RANK, NNEIGHBORS, IERROR}
\mpicppemptybind{MPI::Graphcomm::Get\_neighbors\_count(int~rank) const}{int}
@@ -974,7 +974,7 @@
\mpibind{MPI\_Graph\_neighbors(MPI\_Comm~comm, int~rank, int~maxneighbors, int~neighbors[])}
-\mpifnewbind{MPI\_Graph\_neighbors(comm, rank, maxneighbors, neighbors, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: rank, maxneighbors \\ INTEGER, INTENT(OUT) :: neighbors(maxneighbors) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Graph\_neighbors(comm, rank, maxneighbors, neighbors, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: rank, maxneighbors \\ INTEGER, INTENT(OUT) :: neighbors(maxneighbors) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GRAPH\_NEIGHBORS(COMM, RANK, MAXNEIGHBORS, NEIGHBORS, IERROR)\fargs INTEGER COMM, RANK, MAXNEIGHBORS, NEIGHBORS(*), IERROR}
\mpicppemptybind{MPI::Graphcomm::Get\_neighbors(int~rank, int~maxneighbors, int neighbors[]) const}{void}
@@ -1119,7 +1119,7 @@
\mpibind{MPI\_Dist\_graph\_neighbors\_count(MPI\_Comm~comm, int~*indegree, int~*outdegree, int~*weighted)}
-\mpifnewbind{MPI\_Dist\_graph\_neighbors\_count(comm, indegree, outdegree, weighted, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: indegree, outdegree \\ LOGICAL, INTENT(OUT) :: weighted \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Dist\_graph\_neighbors\_count(comm, indegree, outdegree, weighted, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(OUT) :: indegree, outdegree \\ LOGICAL, INTENT(OUT) :: weighted \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_DIST\_GRAPH\_NEIGHBORS\_COUNT(COMM, INDEGREE, OUTDEGREE, WEIGHTED, IERROR)\fargs INTEGER COMM, INDEGREE, OUTDEGREE, IERROR \\ LOGICAL WEIGHTED}
\mpicppemptybind{MPI::Distgraphcomm::Get\_dist\_neighbors\_count(int~rank, int~indegree[], int~outdegree[], bool\&~weighted) const}{void}
@@ -1142,7 +1142,7 @@
\mpibind{MPI\_Dist\_graph\_neighbors(MPI\_Comm~comm, int~maxindegree, int~sources[], int~sourceweights[], int~maxoutdegree, int~destinations[], int~destweights[])}
-\mpifnewbind{MPI\_Dist\_graph\_neighbors(comm, maxindegree, sources, sourceweights, maxoutdegree, destinations, destweights, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: maxindegree, maxoutdegree \\ INTEGER, INTENT(OUT) :: sources(maxindegree), destinations(maxoutdegree) \\ INTEGER :: sourceweights(*), destweights(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Dist\_graph\_neighbors(comm, maxindegree, sources, sourceweights, maxoutdegree, destinations, destweights, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: maxindegree, maxoutdegree \\ INTEGER, INTENT(OUT) :: sources(maxindegree), destinations(maxoutdegree) \\ INTEGER :: sourceweights(*), destweights(*) \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_DIST\_GRAPH\_NEIGHBORS(COMM, MAXINDEGREE, SOURCES, SOURCEWEIGHTS, MAXOUTDEGREE, DESTINATIONS, DESTWEIGHTS, IERROR)\fargs INTEGER COMM, MAXINDEGREE, SOURCES(*), SOURCEWEIGHTS(*), MAXOUTDEGREE, \\ \ \ \ \ DESTINATIONS(*), DESTWEIGHTS(*), IERROR}
\mpicppemptybind{MPI::Distgraphcomm::Get\_dist\_neighbors(int~maxindegree, int~sources[], int~sourceweights[], int~maxoutdegree, int~destinations[], int~destweights[])}{void}
@@ -1206,7 +1206,7 @@
\mpibind{MPI\_Cart\_shift(MPI\_Comm~comm, int~direction, int~disp, int~*rank\_source, int~*rank\_dest)}
-\mpifnewbind{MPI\_Cart\_shift(comm, direction, disp, rank\_source, rank\_dest, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: direction, disp \\ INTEGER, INTENT(OUT) :: rank\_source, rank\_dest \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cart\_shift(comm, direction, disp, rank\_source, rank\_dest, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: direction, disp \\ INTEGER, INTENT(OUT) :: rank\_source, rank\_dest \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CART\_SHIFT(COMM, DIRECTION, DISP, RANK\_SOURCE, RANK\_DEST, IERROR)\fargs INTEGER COMM, DIRECTION, DISP, RANK\_SOURCE, RANK\_DEST, IERROR}
\mpicppemptybind{MPI::Cartcomm::Shift(int~direction, int~disp, int\&~rank\_source, int\&~rank\_dest) const}{void}
@@ -1281,7 +1281,7 @@
\mpibind{MPI\_Cart\_sub(MPI\_Comm~comm, const int~remain\_dims[], MPI\_Comm~*newcomm)}
-\mpifnewbind{MPI\_Cart\_sub(comm, remain\_dims, newcomm, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ LOGICAL, INTENT(IN) :: remain\_dims(*) \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cart\_sub(comm, remain\_dims, newcomm, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ LOGICAL, INTENT(IN) :: remain\_dims(*) \\ TYPE(MPI\_Comm), INTENT(OUT) :: newcomm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CART\_SUB(COMM, REMAIN\_DIMS, NEWCOMM, IERROR)\fargs INTEGER COMM, NEWCOMM, IERROR \\ LOGICAL REMAIN\_DIMS(*)}
\mpicppemptybind{MPI::Cartcomm::Sub(const~bool~remain\_dims[]) const}{MPI::Cartcomm}
@@ -1339,7 +1339,7 @@
\mpibind{MPI\_Cart\_map(MPI\_Comm~comm, int~ndims, const int~dims[], const int~periods[], int~*newrank)}
-\mpifnewbind{MPI\_Cart\_map(comm, ndims, dims, periods, newrank, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: ndims, dims(ndims) \\ LOGICAL, INTENT(IN) :: periods(ndims) \\ INTEGER, INTENT(OUT) :: newrank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Cart\_map(comm, ndims, dims, periods, newrank, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: ndims, dims(ndims) \\ LOGICAL, INTENT(IN) :: periods(ndims) \\ INTEGER, INTENT(OUT) :: newrank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_CART\_MAP(COMM, NDIMS, DIMS, PERIODS, NEWRANK, IERROR)\fargs INTEGER COMM, NDIMS, DIMS(*), NEWRANK, IERROR \\ LOGICAL PERIODS(*)}
\mpicppemptybind{MPI::Cartcomm::Map(int~ndims, const~int~dims[], const~bool~periods[]) const}{int}
@@ -1381,7 +1381,7 @@
\mpibind{MPI\_Graph\_map(MPI\_Comm~comm, int~nnodes, const int~index[], const int~edges[], int~*newrank)}
-\mpifnewbind{MPI\_Graph\_map(comm, nnodes, index, edges, newrank, ierror) BIND(C) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: nnodes, index(nnodes), edges(*) \\ INTEGER, INTENT(OUT) :: newrank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Graph\_map(comm, nnodes, index, edges, newrank, ierror) \fargs TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, INTENT(IN) :: nnodes, index(nnodes), edges(*) \\ INTEGER, INTENT(OUT) :: newrank \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_GRAPH\_MAP(COMM, NNODES, INDEX, EDGES, NEWRANK, IERROR)\fargs INTEGER COMM, NNODES, INDEX(*), EDGES(*), NEWRANK, IERROR}
\mpicppemptybind{MPI::Graphcomm::Map(int~nnodes, const~int~index[], const~int~edges[]) const}{int}
@@ -1486,7 +1486,7 @@
\mpibind{MPI\_Neighbor\_allgather(const void* sendbuf, int sendcount, MPI\_Datatype sendtype, void* recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Neighbor\_allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Neighbor\_allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_NEIGHBOR\_ALLGATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, IERROR}
This function supports Cartesian communicators, graph communicators, and
@@ -1579,7 +1579,7 @@
\mpibind{MPI\_Neighbor\_allgatherv(const void* sendbuf, int sendcount, MPI\_Datatype sendtype, void* recvbuf, const int recvcounts[], const int displs[], MPI\_Datatype recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Neighbor\_allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Neighbor\_allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_NEIGHBOR\_ALLGATHERV(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNTS, DISPLS, RECVTYPE, COMM, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNT, SENDTYPE, RECVCOUNTS(*), DISPLS(*), RECVTYPE, COMM, IERROR}
This function supports Cartesian communicators, graph communicators, and
@@ -1661,7 +1661,7 @@
\mpibind{MPI\_Neighbor\_alltoall(const void* sendbuf, int sendcount, MPI\_Datatype sendtype, void* recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Neighbor\_alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Neighbor\_alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_NEIGHBOR\_ALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, IERROR}
This function supports Cartesian communicators, graph communicators, and
@@ -1742,7 +1742,7 @@
\mpibind{MPI\_Neighbor\_alltoallv(const void* sendbuf, const int sendcounts[], const int sdispls[], MPI\_Datatype sendtype, void* recvbuf, const int recvcounts[], const int rdispls[], MPI\_Datatype recvtype, MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Neighbor\_alltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Neighbor\_alltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_NEIGHBOR\_ALLTOALLV(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPE, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPE, COMM, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPE, RECVCOUNTS(*), RDISPLS(*), RECVTYPE, COMM, IERROR}
This function supports Cartesian communicators, graph communicators, and
@@ -1827,7 +1827,7 @@
\mpibind{MPI\_Neighbor\_alltoallw(const void* sendbuf, const int sendcounts[], const MPI\_Aint sdispls[], const MPI\_Datatype sendtypes[], void* recvbuf, const int recvcounts[], const MPI\_Aint rdispls[], const MPI\_Datatype recvtypes[], MPI\_Comm~comm)}
-\mpifnewbind{MPI\_Neighbor\_alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), recvcounts(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: sdispls(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtypes(*), recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Neighbor\_alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf \\ TYPE(*), DIMENSION(..) :: recvbuf \\ INTEGER, INTENT(IN) :: sendcounts(*), recvcounts(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN) :: sdispls(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtypes(*), recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_NEIGHBOR\_ALLTOALLW(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPES, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPES, COMM, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER(KIND=MPI\_ADDRESS\_KIND) SDISPLS(*), RDISPLS(*)\\INTEGER SENDCOUNTS(*), SENDTYPES(*), RECVCOUNTS(*), RECVTYPES(*), COMM, IERROR}
This function supports Cartesian communicators, graph communicators, and
@@ -1909,7 +1909,7 @@
\mpibind{MPI\_Ineighbor\_allgather(const void* sendbuf, int sendcount, MPI\_Datatype sendtype, void* recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm~comm, MPI\_Request~*request)}
-\mpifnewbind{MPI\_Ineighbor\_allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ineighbor\_allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INEIGHBOR\_ALLGATHER(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR}
This call starts a nonblocking variant of
@@ -1934,7 +1934,7 @@
\mpibind{MPI\_Ineighbor\_allgatherv(const void* sendbuf, int sendcount, MPI\_Datatype sendtype, void* recvbuf, const int recvcounts[], const int displs[], MPI\_Datatype recvtype, MPI\_Comm~comm, MPI\_Request *request)}
-\mpifnewbind{MPI\_Ineighbor\_allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ineighbor\_allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: recvcounts(*), displs(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INEIGHBOR\_ALLGATHERV(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNTS, DISPLS, RECVTYPE, COMM, REQUEST, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNT, SENDTYPE, RECVCOUNTS(*), DISPLS(*), RECVTYPE, COMM, REQUEST, IERROR}
%
This call starts a nonblocking variant of
@@ -1956,7 +1956,7 @@
\mpibind{MPI\_Ineighbor\_alltoall(const void* sendbuf, int sendcount, MPI\_Datatype sendtype, void* recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm~comm, MPI\_Request *request)}
-\mpifnewbind{MPI\_Ineighbor\_alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ineighbor\_alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN) :: sendcount, recvcount \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INEIGHBOR\_ALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, REQUEST, IERROR}
This call starts a nonblocking variant of
@@ -1986,7 +1986,7 @@
\mpibind{MPI\_Ineighbor\_alltoallv(const void* sendbuf, const int sendcounts[], const int sdispls[], MPI\_Datatype sendtype, void* recvbuf, const int recvcounts[], const int rdispls[], MPI\_Datatype recvtype, MPI\_Comm~comm, MPI\_Request *request)}
-\mpifnewbind{MPI\_Ineighbor\_alltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ineighbor\_alltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN) :: sendtype, recvtype \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INEIGHBOR\_ALLTOALLV(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPE, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPE, COMM, REQUEST, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPE, RECVCOUNTS(*), RDISPLS(*), RECVTYPE, COMM, REQUEST, IERROR}
This call starts a nonblocking variant of
@@ -2013,7 +2013,7 @@
\mpibind{MPI\_Ineighbor\_alltoallw(const void* sendbuf, const int sendcounts[], const MPI\_Aint sdispls[], const MPI\_Datatype sendtypes[], void* recvbuf, const int recvcounts[], const MPI\_Aint rdispls[], const MPI\_Datatype recvtypes[], MPI\_Comm~comm, MPI\_Request *request)}
-\mpifnewbind{MPI\_Ineighbor\_alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, request, ierror) BIND(C) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), recvcounts(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN), ASYNCHRONOUS :: sdispls(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN), ASYNCHRONOUS :: sendtypes(*), recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
+\mpifnewbind{MPI\_Ineighbor\_alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, request, ierror) \fargs TYPE(*), DIMENSION(..), INTENT(IN), ASYNCHRONOUS :: sendbuf \\ TYPE(*), DIMENSION(..), ASYNCHRONOUS :: recvbuf \\ INTEGER, INTENT(IN), ASYNCHRONOUS :: sendcounts(*), recvcounts(*) \\ INTEGER(KIND=MPI\_ADDRESS\_KIND), INTENT(IN), ASYNCHRONOUS :: sdispls(*), rdispls(*) \\ TYPE(MPI\_Datatype), INTENT(IN), ASYNCHRONOUS :: sendtypes(*), recvtypes(*) \\ TYPE(MPI\_Comm), INTENT(IN) :: comm \\ TYPE(MPI\_Request), INTENT(OUT) :: request \\ INTEGER, OPTIONAL, INTENT(OUT) :: ierror}
\mpifbind{MPI\_INEIGHBOR\_ALLTOALLW(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPES, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPES, COMM, REQUEST, IERROR)\fargs $<$type$>$ SENDBUF(*), RECVBUF(*)\\INTEGER(KIND=MPI\_ADDRESS\_KIND) SDISPLS(*), RDISPLS(*)\\INTEGER SENDCOUNTS(*), SENDTYPES(*), RECVCOUNTS(*), RECVTYPES(*), COMM, REQUEST, IERROR}
This call starts a nonblocking variant of
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment