Commits

Anonymous committed dc01f3b

Quote uses of AC_LANG_PROGRAM to avoid warnings from autoconf as of version 2.68.

Comments (0)

Files changed (5)

dumpi/acinclude/mpiconfigs.m4

     AC_LANG_PUSH(C)
     AC_MSG_CHECKING([whether mpi.h is found])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
           #include <stdlib.h>
           MPI_Finalize();
           return EXIT_SUCCESS;
         ]
-      ),
+      )],
       AC_MSG_RESULT([yes]),
       AC_MSG_FAILURE([no])
     )
     AH_TEMPLATE([DUMPI_HAVE_MPI_WIN], [if MPI_Win is a recognized type])
     AC_MSG_CHECKING([whether MPI_Win is a valid type])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Init(argc, argv);
           PMPI_Init(argc, argv);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_DEFINE(DUMPI_HAVE_MPI_WIN, [1])
         AC_MSG_RESULT([yes])
     AH_TEMPLATE([DUMPI_SKIP_MPI_INIT], [if MPI_Init is missing])
     AC_MSG_CHECKING([whether MPI_Init is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Init(argc, argv);
           PMPI_Init(argc, argv);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
 	have_init=yes
     AH_TEMPLATE([DUMPI_SKIP_MPI_INIT_THREAD], [if MPI_Init_thread is missing])
     AC_MSG_CHECKING([whether MPI_Init_thread is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Init_thread(argc, argv, required, provided);
           PMPI_Init_thread(argc, argv, required, provided);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_FINALIZE], [if MPI_Finalize is missing])
     AC_MSG_CHECKING([whether MPI_Finalize is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Init(&argc, &argv);
           MPI_Finalize();
           PMPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_HAVE_MPIO_REQUEST_NULL], [MPIO_REQUEST_NULL defined])
     AC_MSG_CHECKING([whether MPIO_REQUEST_NULL is defined])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
-        [#include <mpi.h>],
-        [MPIO_Request req = MPIO_REQUEST_NULL;]
-      ),
+      [AC_LANG_PROGRAM(
+        [
+          #include <mpi.h>
+        ], [
+          MPIO_Request req = MPIO_REQUEST_NULL;
+        ])],
       [
         AC_MSG_RESULT([yes])
         AC_DEFINE(DUMPI_HAVE_MPIO_REQUEST_NULL, [1])
     AH_TEMPLATE([DUMPI_SKIP_MPI_SEND], [if MPI_Send is missing])
     AC_MSG_CHECKING([whether MPI_Send is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Send(buf, count, datatype, dest, tag, comm);
           PMPI_Send(buf, count, datatype, dest, tag, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_RECV], [if MPI_Recv is missing])
     AC_MSG_CHECKING([whether MPI_Recv is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Recv(buf, count, datatype, source, tag, comm, status);
           PMPI_Recv(buf, count, datatype, source, tag, comm, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GET_COUNT], [if MPI_Get_count is missing])
     AC_MSG_CHECKING([whether MPI_Get_count is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Get_count(status, datatype, count);
           PMPI_Get_count(status, datatype, count);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_BSEND], [if MPI_Bsend is missing])
     AC_MSG_CHECKING([whether MPI_Bsend is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Bsend(buf, count, datatype, dest, tag, comm);
           PMPI_Bsend(buf, count, datatype, dest, tag, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SSEND], [if MPI_Ssend is missing])
     AC_MSG_CHECKING([whether MPI_Ssend is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Ssend(buf, count, datatype, dest, tag, comm);
           PMPI_Ssend(buf, count, datatype, dest, tag, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_RSEND], [if MPI_Rsend is missing])
     AC_MSG_CHECKING([whether MPI_Rsend is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Rsend(buf, count, datatype, dest, tag, comm);
           PMPI_Rsend(buf, count, datatype, dest, tag, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_BUFFER_ATTACH], [if MPI_Buffer_attach is missing])
     AC_MSG_CHECKING([whether MPI_Buffer_attach is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Buffer_attach(buf, size);
           PMPI_Buffer_attach(buf, size);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_BUFFER_DETACH], [if MPI_Buffer_detach is missing])
     AC_MSG_CHECKING([whether MPI_Buffer_detach is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Buffer_detach(buf, size);
           PMPI_Buffer_detach(buf, size);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ISEND], [if MPI_Isend is missing])
     AC_MSG_CHECKING([whether MPI_Isend is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Isend(buf, count, datatype, dest, tag, comm, request);
           PMPI_Isend(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_IBSEND], [if MPI_Ibsend is missing])
     AC_MSG_CHECKING([whether MPI_Ibsend is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Ibsend(buf, count, datatype, dest, tag, comm, request);
           PMPI_Ibsend(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ISSEND], [if MPI_Issend is missing])
     AC_MSG_CHECKING([whether MPI_Issend is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Issend(buf, count, datatype, dest, tag, comm, request);
           PMPI_Issend(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_IRSEND], [if MPI_Irsend is missing])
     AC_MSG_CHECKING([whether MPI_Irsend is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Irsend(buf, count, datatype, dest, tag, comm, request);
           PMPI_Irsend(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_IRECV], [if MPI_Irecv is missing])
     AC_MSG_CHECKING([whether MPI_Irecv is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Irecv(buf, count, datatype, source, tag, comm, request);
           PMPI_Irecv(buf, count, datatype, source, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_WAIT], [if MPI_Wait is missing])
     AC_MSG_CHECKING([whether MPI_Wait is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Wait(request, status);
           PMPI_Wait(request, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TEST], [if MPI_Test is missing])
     AC_MSG_CHECKING([whether MPI_Test is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Test(request, flag, status);
           PMPI_Test(request, flag, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_REQUEST_FREE], [if MPI_Request_free is missing])
     AC_MSG_CHECKING([whether MPI_Request_free is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Request_free(request);
           PMPI_Request_free(request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_WAITANY], [if MPI_Waitany is missing])
     AC_MSG_CHECKING([whether MPI_Waitany is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Waitany(count, requests, index, status);
           PMPI_Waitany(count, requests, index, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TESTANY], [if MPI_Testany is missing])
     AC_MSG_CHECKING([whether MPI_Testany is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Testany(count, requests, index, flag, status);
           PMPI_Testany(count, requests, index, flag, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_WAITALL], [if MPI_Waitall is missing])
     AC_MSG_CHECKING([whether MPI_Waitall is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Waitall(count, requests, statuses);
           PMPI_Waitall(count, requests, statuses);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TESTALL], [if MPI_Testall is missing])
     AC_MSG_CHECKING([whether MPI_Testall is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Testall(count, requests, flag, statuses);
           PMPI_Testall(count, requests, flag, statuses);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_WAITSOME], [if MPI_Waitsome is missing])
     AC_MSG_CHECKING([whether MPI_Waitsome is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Waitsome(count, requests, outcount, indices, statuses);
           PMPI_Waitsome(count, requests, outcount, indices, statuses);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TESTSOME], [if MPI_Testsome is missing])
     AC_MSG_CHECKING([whether MPI_Testsome is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Testsome(count, requests, outcount, indices, statuses);
           PMPI_Testsome(count, requests, outcount, indices, statuses);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_IPROBE], [if MPI_Iprobe is missing])
     AC_MSG_CHECKING([whether MPI_Iprobe is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Iprobe(source, tag, comm, flag, status);
           PMPI_Iprobe(source, tag, comm, flag, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_PROBE], [if MPI_Probe is missing])
     AC_MSG_CHECKING([whether MPI_Probe is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Probe(source, tag, comm, status);
           PMPI_Probe(source, tag, comm, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CANCEL], [if MPI_Cancel is missing])
     AC_MSG_CHECKING([whether MPI_Cancel is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cancel(request);
           PMPI_Cancel(request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TEST_CANCELLED], [if MPI_Test_cancelled is missing])
     AC_MSG_CHECKING([whether MPI_Test_cancelled is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Test_cancelled(status, cancelled);
           PMPI_Test_cancelled(status, cancelled);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SEND_INIT], [if MPI_Send_init is missing])
     AC_MSG_CHECKING([whether MPI_Send_init is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Send_init(buf, count, datatype, dest, tag, comm, request);
           PMPI_Send_init(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_BSEND_INIT], [if MPI_Bsend_init is missing])
     AC_MSG_CHECKING([whether MPI_Bsend_init is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Bsend_init(buf, count, datatype, dest, tag, comm, request);
           PMPI_Bsend_init(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SSEND_INIT], [if MPI_Ssend_init is missing])
     AC_MSG_CHECKING([whether MPI_Ssend_init is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Ssend_init(buf, count, datatype, dest, tag, comm, request);
           PMPI_Ssend_init(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_RSEND_INIT], [if MPI_Rsend_init is missing])
     AC_MSG_CHECKING([whether MPI_Rsend_init is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Rsend_init(buf, count, datatype, dest, tag, comm, request);
           PMPI_Rsend_init(buf, count, datatype, dest, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_RECV_INIT], [if MPI_Recv_init is missing])
     AC_MSG_CHECKING([whether MPI_Recv_init is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Recv_init(buf, count, datatype, source, tag, comm, request);
           PMPI_Recv_init(buf, count, datatype, source, tag, comm, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_START], [if MPI_Start is missing])
     AC_MSG_CHECKING([whether MPI_Start is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Start(request);
           PMPI_Start(request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_STARTALL], [if MPI_Startall is missing])
     AC_MSG_CHECKING([whether MPI_Startall is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Startall(count, request);
           PMPI_Startall(count, request);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SENDRECV], [if MPI_Sendrecv is missing])
     AC_MSG_CHECKING([whether MPI_Sendrecv is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Sendrecv(sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status);
           PMPI_Sendrecv(sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SENDRECV_REPLACE], [if MPI_Sendrecv_replace is missing])
     AC_MSG_CHECKING([whether MPI_Sendrecv_replace is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Sendrecv_replace(buf, count, datatype, dest, sendtag, source, recvtag, comm, status);
           PMPI_Sendrecv_replace(buf, count, datatype, dest, sendtag, source, recvtag, comm, status);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_CONTIGUOUS], [if MPI_Type_contiguous is missing])
     AC_MSG_CHECKING([whether MPI_Type_contiguous is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_contiguous(count, oldtype, newtype);
           PMPI_Type_contiguous(count, oldtype, newtype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_VECTOR], [if MPI_Type_vector is missing])
     AC_MSG_CHECKING([whether MPI_Type_vector is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_vector(count, blocklength, stride, oldtype, newtype);
           PMPI_Type_vector(count, blocklength, stride, oldtype, newtype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_HVECTOR], [if MPI_Type_hvector is missing])
     AC_MSG_CHECKING([whether MPI_Type_hvector is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_hvector(count, blocklength, stride, oldtype, newtype);
           PMPI_Type_hvector(count, blocklength, stride, oldtype, newtype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_INDEXED], [if MPI_Type_indexed is missing])
     AC_MSG_CHECKING([whether MPI_Type_indexed is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_indexed(count, lengths, indices, oldtype, newtype);
           PMPI_Type_indexed(count, lengths, indices, oldtype, newtype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_HINDEXED], [if MPI_Type_hindexed is missing])
     AC_MSG_CHECKING([whether MPI_Type_hindexed is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_hindexed(count, lengths, indices, oldtype, newtype);
           PMPI_Type_hindexed(count, lengths, indices, oldtype, newtype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_STRUCT], [if MPI_Type_struct is missing])
     AC_MSG_CHECKING([whether MPI_Type_struct is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_struct(count, lengths, indices, oldtypes, newtype);
           PMPI_Type_struct(count, lengths, indices, oldtypes, newtype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ADDRESS], [if MPI_Address is missing])
     AC_MSG_CHECKING([whether MPI_Address is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Address(buf, address);
           PMPI_Address(buf, address);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_EXTENT], [if MPI_Type_extent is missing])
     AC_MSG_CHECKING([whether MPI_Type_extent is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_extent(datatype, extent);
           PMPI_Type_extent(datatype, extent);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_SIZE], [if MPI_Type_size is missing])
     AC_MSG_CHECKING([whether MPI_Type_size is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_size(datatype, size);
           PMPI_Type_size(datatype, size);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_LB], [if MPI_Type_lb is missing])
     AC_MSG_CHECKING([whether MPI_Type_lb is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_lb(datatype, lb);
           PMPI_Type_lb(datatype, lb);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_UB], [if MPI_Type_ub is missing])
     AC_MSG_CHECKING([whether MPI_Type_ub is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_ub(datatype, ub);
           PMPI_Type_ub(datatype, ub);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_COMMIT], [if MPI_Type_commit is missing])
     AC_MSG_CHECKING([whether MPI_Type_commit is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_commit(datatype);
           PMPI_Type_commit(datatype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TYPE_FREE], [if MPI_Type_free is missing])
     AC_MSG_CHECKING([whether MPI_Type_free is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Type_free(datatype);
           PMPI_Type_free(datatype);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GET_ELEMENTS], [if MPI_Get_elements is missing])
     AC_MSG_CHECKING([whether MPI_Get_elements is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Get_elements(status, datatype, elements);
           PMPI_Get_elements(status, datatype, elements);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_PACK], [if MPI_Pack is missing])
     AC_MSG_CHECKING([whether MPI_Pack is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Pack(inbuf, incount, datatype, outbuf, outcount, position, comm);
           PMPI_Pack(inbuf, incount, datatype, outbuf, outcount, position, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_UNPACK], [if MPI_Unpack is missing])
     AC_MSG_CHECKING([whether MPI_Unpack is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Unpack(inbuf, incount, position, outbuf, outcount, datatype, comm);
           PMPI_Unpack(inbuf, incount, position, outbuf, outcount, datatype, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_PACK_SIZE], [if MPI_Pack_size is missing])
     AC_MSG_CHECKING([whether MPI_Pack_size is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Pack_size(incount, datatype, comm, size);
           PMPI_Pack_size(incount, datatype, comm, size);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_BARRIER], [if MPI_Barrier is missing])
     AC_MSG_CHECKING([whether MPI_Barrier is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Barrier(comm);
           PMPI_Barrier(comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_BCAST], [if MPI_Bcast is missing])
     AC_MSG_CHECKING([whether MPI_Bcast is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Bcast(sendbuf, count, datatype, root, comm);
           PMPI_Bcast(sendbuf, count, datatype, root, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GATHER], [if MPI_Gather is missing])
     AC_MSG_CHECKING([whether MPI_Gather is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Gather(inbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
           PMPI_Gather(inbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GATHERV], [if MPI_Gatherv is missing])
     AC_MSG_CHECKING([whether MPI_Gatherv is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Gatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm);
           PMPI_Gatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SCATTER], [if MPI_Scatter is missing])
     AC_MSG_CHECKING([whether MPI_Scatter is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
           PMPI_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SCATTERV], [if MPI_Scatterv is missing])
     AC_MSG_CHECKING([whether MPI_Scatterv is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
           PMPI_Scatterv(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ALLGATHER], [if MPI_Allgather is missing])
     AC_MSG_CHECKING([whether MPI_Allgather is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
           PMPI_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ALLGATHERV], [if MPI_Allgatherv is missing])
     AC_MSG_CHECKING([whether MPI_Allgatherv is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
           PMPI_Allgatherv(sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ALLTOALL], [if MPI_Alltoall is missing])
     AC_MSG_CHECKING([whether MPI_Alltoall is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
           PMPI_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ALLTOALLV], [if MPI_Alltoallv is missing])
     AC_MSG_CHECKING([whether MPI_Alltoallv is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Alltoallv(sendbuf, sendcounts, senddispls, sendtype, recvbuf, recvcounts, recvdispls, recvtype, comm);
           PMPI_Alltoallv(sendbuf, sendcounts, senddispls, sendtype, recvbuf, recvcounts, recvdispls, recvtype, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_REDUCE], [if MPI_Reduce is missing])
     AC_MSG_CHECKING([whether MPI_Reduce is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
           PMPI_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_OP_CREATE], [if MPI_Op_create is missing])
     AC_MSG_CHECKING([whether MPI_Op_create is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Op_create(fptr, commute, op);
           PMPI_Op_create(fptr, commute, op);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_OP_FREE], [if MPI_Op_free is missing])
     AC_MSG_CHECKING([whether MPI_Op_free is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Op_free(op);
           PMPI_Op_free(op);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ALLREDUCE], [if MPI_Allreduce is missing])
     AC_MSG_CHECKING([whether MPI_Allreduce is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm);
           PMPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_REDUCE_SCATTER], [if MPI_Reduce_scatter is missing])
     AC_MSG_CHECKING([whether MPI_Reduce_scatter is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Reduce_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm);
           PMPI_Reduce_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_SCAN], [if MPI_Scan is missing])
     AC_MSG_CHECKING([whether MPI_Scan is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Scan(sendbuf, recvbuf, count, datatype, op, comm);
           PMPI_Scan(sendbuf, recvbuf, count, datatype, op, comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_SIZE], [if MPI_Group_size is missing])
     AC_MSG_CHECKING([whether MPI_Group_size is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_size(group, size);
           PMPI_Group_size(group, size);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_RANK], [if MPI_Group_rank is missing])
     AC_MSG_CHECKING([whether MPI_Group_rank is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_rank(group, rank);
           PMPI_Group_rank(group, rank);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_TRANSLATE_RANKS], [if MPI_Group_translate_ranks is missing])
     AC_MSG_CHECKING([whether MPI_Group_translate_ranks is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_translate_ranks(group1, count, ranks1, group2, ranks2);
           PMPI_Group_translate_ranks(group1, count, ranks1, group2, ranks2);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_COMPARE], [if MPI_Group_compare is missing])
     AC_MSG_CHECKING([whether MPI_Group_compare is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_compare(group1, group2, result);
           PMPI_Group_compare(group1, group2, result);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_GROUP], [if MPI_Comm_group is missing])
     AC_MSG_CHECKING([whether MPI_Comm_group is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_group(comm, group);
           PMPI_Comm_group(comm, group);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_UNION], [if MPI_Group_union is missing])
     AC_MSG_CHECKING([whether MPI_Group_union is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_union(group1, group2, newgroup);
           PMPI_Group_union(group1, group2, newgroup);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_INTERSECTION], [if MPI_Group_intersection is missing])
     AC_MSG_CHECKING([whether MPI_Group_intersection is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_intersection(group1, group2, newgroup);
           PMPI_Group_intersection(group1, group2, newgroup);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_DIFFERENCE], [if MPI_Group_difference is missing])
     AC_MSG_CHECKING([whether MPI_Group_difference is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_difference(group1, group2, newgroup);
           PMPI_Group_difference(group1, group2, newgroup);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_INCL], [if MPI_Group_incl is missing])
     AC_MSG_CHECKING([whether MPI_Group_incl is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_incl(group, count, ranks, newgroup);
           PMPI_Group_incl(group, count, ranks, newgroup);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_EXCL], [if MPI_Group_excl is missing])
     AC_MSG_CHECKING([whether MPI_Group_excl is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_excl(group, count, ranks, newgroup);
           PMPI_Group_excl(group, count, ranks, newgroup);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_RANGE_INCL], [if MPI_Group_range_incl is missing])
     AC_MSG_CHECKING([whether MPI_Group_range_incl is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_range_incl(group, count, ranges, newgroup);
           PMPI_Group_range_incl(group, count, ranges, newgroup);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_RANGE_EXCL], [if MPI_Group_range_excl is missing])
     AC_MSG_CHECKING([whether MPI_Group_range_excl is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_range_excl(group, count, ranges, newgroup);
           PMPI_Group_range_excl(group, count, ranges, newgroup);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GROUP_FREE], [if MPI_Group_free is missing])
     AC_MSG_CHECKING([whether MPI_Group_free is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Group_free(group);
           PMPI_Group_free(group);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_SIZE], [if MPI_Comm_size is missing])
     AC_MSG_CHECKING([whether MPI_Comm_size is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_size(comm, size);
           PMPI_Comm_size(comm, size);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_RANK], [if MPI_Comm_rank is missing])
     AC_MSG_CHECKING([whether MPI_Comm_rank is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_rank(comm, rank);
           PMPI_Comm_rank(comm, rank);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_COMPARE], [if MPI_Comm_compare is missing])
     AC_MSG_CHECKING([whether MPI_Comm_compare is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_compare(comm1, comm2, result);
           PMPI_Comm_compare(comm1, comm2, result);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_DUP], [if MPI_Comm_dup is missing])
     AC_MSG_CHECKING([whether MPI_Comm_dup is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_dup(oldcomm, newcomm);
           PMPI_Comm_dup(oldcomm, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_CREATE], [if MPI_Comm_create is missing])
     AC_MSG_CHECKING([whether MPI_Comm_create is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_create(oldcomm, group, newcomm);
           PMPI_Comm_create(oldcomm, group, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_SPLIT], [if MPI_Comm_split is missing])
     AC_MSG_CHECKING([whether MPI_Comm_split is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_split(oldcomm, color, key, newcomm);
           PMPI_Comm_split(oldcomm, color, key, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_FREE], [if MPI_Comm_free is missing])
     AC_MSG_CHECKING([whether MPI_Comm_free is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_free(comm);
           PMPI_Comm_free(comm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_TEST_INTER], [if MPI_Comm_test_inter is missing])
     AC_MSG_CHECKING([whether MPI_Comm_test_inter is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_test_inter(comm, inter);
           PMPI_Comm_test_inter(comm, inter);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_REMOTE_SIZE], [if MPI_Comm_remote_size is missing])
     AC_MSG_CHECKING([whether MPI_Comm_remote_size is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_remote_size(comm, size);
           PMPI_Comm_remote_size(comm, size);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_COMM_REMOTE_GROUP], [if MPI_Comm_remote_group is missing])
     AC_MSG_CHECKING([whether MPI_Comm_remote_group is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Comm_remote_group(comm, group);
           PMPI_Comm_remote_group(comm, group);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_INTERCOMM_CREATE], [if MPI_Intercomm_create is missing])
     AC_MSG_CHECKING([whether MPI_Intercomm_create is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Intercomm_create(localcomm, localleader, remotecomm, remoteleader, tag, newcomm);
           PMPI_Intercomm_create(localcomm, localleader, remotecomm, remoteleader, tag, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_INTERCOMM_MERGE], [if MPI_Intercomm_merge is missing])
     AC_MSG_CHECKING([whether MPI_Intercomm_merge is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Intercomm_merge(comm, high, newcomm);
           PMPI_Intercomm_merge(comm, high, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_KEYVAL_CREATE], [if MPI_Keyval_create is missing])
     AC_MSG_CHECKING([whether MPI_Keyval_create is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Keyval_create(copyfunc, delfunc, key, state);
           PMPI_Keyval_create(copyfunc, delfunc, key, state);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_KEYVAL_FREE], [if MPI_Keyval_free is missing])
     AC_MSG_CHECKING([whether MPI_Keyval_free is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Keyval_free(key);
           PMPI_Keyval_free(key);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ATTR_PUT], [if MPI_Attr_put is missing])
     AC_MSG_CHECKING([whether MPI_Attr_put is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Attr_put(comm, key, attr);
           PMPI_Attr_put(comm, key, attr);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ATTR_GET], [if MPI_Attr_get is missing])
     AC_MSG_CHECKING([whether MPI_Attr_get is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Attr_get(comm, key, attr, flag);
           PMPI_Attr_get(comm, key, attr, flag);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_ATTR_DELETE], [if MPI_Attr_delete is missing])
     AC_MSG_CHECKING([whether MPI_Attr_delete is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Attr_delete(comm, key);
           PMPI_Attr_delete(comm, key);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_TOPO_TEST], [if MPI_Topo_test is missing])
     AC_MSG_CHECKING([whether MPI_Topo_test is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Topo_test(comm, topo);
           PMPI_Topo_test(comm, topo);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CART_CREATE], [if MPI_Cart_create is missing])
     AC_MSG_CHECKING([whether MPI_Cart_create is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cart_create(oldcomm, ndim, dims, periods, reorder, newcomm);
           PMPI_Cart_create(oldcomm, ndim, dims, periods, reorder, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_DIMS_CREATE], [if MPI_Dims_create is missing])
     AC_MSG_CHECKING([whether MPI_Dims_create is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Dims_create(nodes, ndim, dims);
           PMPI_Dims_create(nodes, ndim, dims);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GRAPH_CREATE], [if MPI_Graph_create is missing])
     AC_MSG_CHECKING([whether MPI_Graph_create is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Graph_create(oldcomm, nodes, index, edges, reorder, newcomm);
           PMPI_Graph_create(oldcomm, nodes, index, edges, reorder, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GRAPHDIMS_GET], [if MPI_Graphdims_get is missing])
     AC_MSG_CHECKING([whether MPI_Graphdims_get is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Graphdims_get(comm, nodes, edges);
           PMPI_Graphdims_get(comm, nodes, edges);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GRAPH_GET], [if MPI_Graph_get is missing])
     AC_MSG_CHECKING([whether MPI_Graph_get is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Graph_get(comm, maxindex, maxedges, index, edges);
           PMPI_Graph_get(comm, maxindex, maxedges, index, edges);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CARTDIM_GET], [if MPI_Cartdim_get is missing])
     AC_MSG_CHECKING([whether MPI_Cartdim_get is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cartdim_get(comm, ndim);
           PMPI_Cartdim_get(comm, ndim);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CART_GET], [if MPI_Cart_get is missing])
     AC_MSG_CHECKING([whether MPI_Cart_get is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cart_get(comm, maxdims, dims, periods, coords);
           PMPI_Cart_get(comm, maxdims, dims, periods, coords);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CART_RANK], [if MPI_Cart_rank is missing])
     AC_MSG_CHECKING([whether MPI_Cart_rank is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cart_rank(comm, coords, rank);
           PMPI_Cart_rank(comm, coords, rank);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CART_COORDS], [if MPI_Cart_coords is missing])
     AC_MSG_CHECKING([whether MPI_Cart_coords is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cart_coords(comm, rank, maxdims, coords);
           PMPI_Cart_coords(comm, rank, maxdims, coords);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GRAPH_NEIGHBORS_COUNT], [if MPI_Graph_neighbors_count is missing])
     AC_MSG_CHECKING([whether MPI_Graph_neighbors_count is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Graph_neighbors_count(comm, rank, nneigh);
           PMPI_Graph_neighbors_count(comm, rank, nneigh);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_GRAPH_NEIGHBORS], [if MPI_Graph_neighbors is missing])
     AC_MSG_CHECKING([whether MPI_Graph_neighbors is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Graph_neighbors(comm, rank, maxneighbors, neighbors);
           PMPI_Graph_neighbors(comm, rank, maxneighbors, neighbors);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CART_SHIFT], [if MPI_Cart_shift is missing])
     AC_MSG_CHECKING([whether MPI_Cart_shift is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cart_shift(comm, direction, displ, source, dest);
           PMPI_Cart_shift(comm, direction, displ, source, dest);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CART_SUB], [if MPI_Cart_sub is missing])
     AC_MSG_CHECKING([whether MPI_Cart_sub is present])
     AC_LINK_IFELSE(
-      AC_LANG_PROGRAM(
+      [AC_LANG_PROGRAM(
         [
           #include <mpi.h>
         ], [
           MPI_Cart_sub(oldcomm, remain_dims, newcomm);
           PMPI_Cart_sub(oldcomm, remain_dims, newcomm);
           MPI_Finalize();
-        ]),
+        ])],
       [
         AC_MSG_RESULT([yes])
       ], [
     AH_TEMPLATE([DUMPI_SKIP_MPI_CART_MAP], [if MPI_Cart_map is missing])
     AC_MSG_CHECKING([whether MPI_Cart_map is present])
     AC_LINK_IFELSE(