Make a pass through all top-level MPI functions

- Mark those who are still not yet implemented:
  - return an error
  - have a grep-able string indicating that they are not yet
    implemented
- ensure every function checks for init/finalize
- add more error checking to a bunch of functions
- unify the error checking -- it reflected about 3 different
  [previous] error checking styles and MPI exception invocation styles

This commit was SVN r1817.

src/mpi/c/abort.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Abort = PMPI_Abort
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_Abort(MPI_Comm comm, int errorcode) {
+static const char FUNC_NAME[] = "MPI_Abort";
-	return MPI_SUCCESS;
+
+
+int MPI_Abort(MPI_Comm comm, int errorcode) 
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/accumulate.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Accumulate = PMPI_Accumulate
@@ -15,9 +17,18 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_Accumulate(void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+static const char FUNC_NAME[] = "MPI_Accumlate";
-					int target_rank, MPI_Aint target_disp, int target_count,
-					MPI_Datatype target_datatype, MPI_Op op, MPI_Win win) {
 
-	return MPI_SUCCESS;
+
+int MPI_Accumulate(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) 
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/add_error_class.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Add_error_class";
+static const char FUNC_NAME[] = "MPI_Add_error_class";
 
 
 int MPI_Add_error_class(int *errorclass) 

src/mpi/c/add_error_code.c

@@ -19,7 +19,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Add_error_code";
+static const char FUNC_NAME[] = "MPI_Add_error_code";
 
 
 int MPI_Add_error_code(int errorclass, int *errorcode)

src/mpi/c/add_error_string.c

@@ -19,7 +19,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Add_error_code";
+static const char FUNC_NAME[] = "MPI_Add_error_code";
 
 
 int MPI_Add_error_string(int errorcode, char *string)

src/mpi/c/address.c

@@ -21,14 +21,16 @@
 
 static const char FUNC_NAME[] = "MPI_Address";
 
+
 int MPI_Address(void *location, MPI_Aint *address)
 {
     if( MPI_PARAM_CHECK ) {
-        if( OMPI_MPI_INVALID_STATE ) {
+      OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-            OMPI_ERRHANDLER_RETURN( MPI_ERR_INTERN, (ompi_communicator_t*)NULL,
+      if (NULL == location || NULL == address) {
-                                    MPI_ERR_INTERN, FUNC_NAME );
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
-        }
+      }
     }
+
     *address = (MPI_Aint)location;
-	return MPI_SUCCESS;
+    return MPI_SUCCESS;
 }

src/mpi/c/allgatherv.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Allgatherv";
+static const char FUNC_NAME[] = "MPI_Allgatherv";
 
 
 int MPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,

src/mpi/c/alloc_mem.c

@@ -8,6 +8,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Alloc_mem = PMPI_Alloc_mem
@@ -17,13 +19,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Alloc_mem";
+
+
 int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)
 {
-  if (size < 0) {
+  if (MPI_PARAM_CHECK) {
-    /* Return error on MPI_COMM_WORLD */
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-  }
+    if (size < 0 || NULL == baseptr) {
-  if (NULL == baseptr) {
+      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
-    /* Return error on MPI_COMM_WORLD */
+                                    FUNC_NAME);
+    }
   }
 
   /* Check the MPI_Info and see if we requested a specific MCA
@@ -33,5 +39,7 @@ int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)
 
      If either fails, return an error on MPI_COMM_WORLD. */
 
-  return MPI_SUCCESS;
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/allreduce.c

@@ -19,7 +19,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Allreduce";
+static const char FUNC_NAME[] = "MPI_Allreduce";
 
 
 int MPI_Allreduce(void *sendbuf, void *recvbuf, int count,

src/mpi/c/alltoallv.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Alltoallv";
+static const char FUNC_NAME[] = "MPI_Alltoallv";
 
 
 int MPI_Alltoallv(void *sendbuf, int *sendcounts, int *sdispls,

src/mpi/c/alltoallw.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Alltoallw";
+static const char FUNC_NAME[] = "MPI_Alltoallw";
 
 
 int MPI_Alltoallw(void *sendbuf, int *sendcounts, int *sdispls, 

src/mpi/c/attr_delete.c

@@ -19,11 +19,13 @@
 
 static const char FUNC_NAME[] = "MPI_Attr_delete";
 
+
 int MPI_Attr_delete(MPI_Comm comm, int keyval)
 {
     int ret;
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if (MPI_COMM_NULL == comm) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
 					 FUNC_NAME);

src/mpi/c/attr_get.c

@@ -24,6 +24,7 @@ int MPI_Attr_get(MPI_Comm comm, int keyval, void *attribute_val, int *flag)
     int ret;
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if ((NULL == attribute_val) || (NULL == flag)) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, 
 					 FUNC_NAME);

src/mpi/c/attr_put.c

@@ -24,6 +24,7 @@ int MPI_Attr_put(MPI_Comm comm, int keyval, void *attribute_val)
     int ret;
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if (MPI_COMM_NULL == comm) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
 					 FUNC_NAME);

src/mpi/c/bindings.h

@@ -26,14 +26,14 @@ extern bool ompi_mpi_param_check;
  */
 #define OMPI_CHECK_DATATYPE_FOR_SEND( RC, DDT, COUNT ) \
 do { \
-   if( (DDT) == MPI_DATATYPE_NULL ) (RC) = MPI_ERR_TYPE; \
+   if( NULL == (DDT) || MPI_DATATYPE_NULL == (DDT) ) (RC) = MPI_ERR_TYPE; \
    else if( (COUNT) < 0 ) (RC) = MPI_ERR_COUNT; \
    else if( !ompi_ddt_is_committed((DDT)) ) (RC) = MPI_ERR_TYPE; \
 } while (0)
 
 #define OMPI_CHECK_DATATYPE_FOR_RECV( RC, DDT, COUNT ) \
 do { \
-   if( (DDT) == MPI_DATATYPE_NULL ) (RC) = MPI_ERR_TYPE; \
+   if( NULL == (DDT) || MPI_DATATYPE_NULL == (DDT) ) (RC) = MPI_ERR_TYPE; \
    else if( (COUNT) < 0 ) (RC) = MPI_ERR_COUNT; \
    else if( !ompi_ddt_is_committed((DDT)) ) (RC) = MPI_ERR_TYPE; \
    else if( ompi_ddt_is_overerlapped((DDT)) ) (RC) = MPI_ERR_TYPE; \
@@ -41,7 +41,7 @@ do { \
 
 #define OMPI_CHECK_DATATYPE_FOR_ONE_SIDED( RC, DDT, COUNT ) \
 do { \
-   if( (DDT) == MPI_DATATYPE_NULL ) (RC) = MPI_ERR_TYPE; \
+   if( NULL == (DDT) || MPI_DATATYPE_NULL == (DDT) ) (RC) = MPI_ERR_TYPE; \
    else if( (COUNT) < 0 ) (RC) = MPI_ERR_COUNT; \
    else if( !ompi_ddt_is_committed((DDT)) ) (RC) = MPI_ERR_TYPE; \
    else if( ompi_ddt_is_overerlapped((DDT)) ) (RC) = MPI_ERR_TYPE; \

src/mpi/c/buffer_attach.c

@@ -7,6 +7,8 @@
 #include "mpi.h"
 #include "mpi/c/bindings.h"
 #include "runtime/runtime.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 #include "mca/pml/pml.h"
 #include "mca/pml/base/pml_base_bsend.h"
 
@@ -19,9 +21,18 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Buffer_attach";
+
 
 int MPI_Buffer_attach(void *buffer, int size) 
 {
-    return mca_pml_base_bsend_attach(buffer, size);
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+    if (NULL == buffer || size < 0) {
+      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
+    }
+  }
+
+  return mca_pml_base_bsend_attach(buffer, size);
 }
 

src/mpi/c/buffer_detach.c

@@ -18,7 +18,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Buffer_detach";
+
+
 int MPI_Buffer_detach(void *buffer, int *size) 
 {
-    return mca_pml_base_bsend_detach(buffer, size);
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+    if (NULL == buffer || NULL == size || *size < 0) {
+      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
+    }
+  }
+
+  return mca_pml_base_bsend_detach(buffer, size);
 }

src/mpi/c/cancel.c

@@ -8,6 +8,8 @@
 #include "runtime/runtime.h"
 #include "mpi/c/bindings.h"
 #include "mca/pml/pml.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Cancel = PMPI_Cancel
@@ -17,14 +19,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cancel";
+
+
 int MPI_Cancel(MPI_Request *request) 
 {
     int rc;
     if ( MPI_PARAM_CHECK ) {
         rc = MPI_SUCCESS;
-        if ( OMPI_MPI_INVALID_STATE ) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-            rc = MPI_ERR_INTERN;
+        if (request == NULL) {
-        } else if (request == NULL) {
             rc = MPI_ERR_REQUEST;
         }
         /* JMS: Tim will fix to invoke on the communicator/window/file

src/mpi/c/cart_coords.c

@@ -19,31 +19,35 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cart_coords";
+
+
 int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords) {
     int err;
     mca_topo_base_cart_coords_fn_t func;
 
     /* check the arguments */
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         if (MPI_COMM_NULL == comm) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_coords");
+                                          FUNC_NAME);
         }
         if (OMPI_COMM_IS_INTER(comm)) { 
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_coords");
+                                          FUNC_NAME);
         }
         if (!OMPI_COMM_IS_CART(comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
-                                          "MPI_Cart_coords");
+                                          FUNC_NAME);
         }
         if ( (0 > maxdims) || ((0 < maxdims) && (NULL == coords))) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_coords");
+                                          FUNC_NAME);
         }
         if ((0 > rank) || (rank > ompi_group_size(comm->c_local_group))) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_RANK,
-                                          "MPI_Cart_coords");
+                                          FUNC_NAME);
         }
     }
 
@@ -51,12 +55,12 @@ int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords) {
     func = comm->c_topo->topo_cart_coords;
     if (NULL == func) {
         return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER, 
-                                     "MPI_Cart_coords");
+                                     FUNC_NAME);
     }
     /* call the function */
     if ( MPI_SUCCESS != 
             (err = func(comm, rank, maxdims, coords))) {
-        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_coords");
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
     }
 
     /* all done */

src/mpi/c/cart_create.c

@@ -18,6 +18,9 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cart_create";
+
+
 int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
                     int *periods, int reorder, MPI_Comm *comm_cart) {
 
@@ -26,25 +29,26 @@ int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
 
     /* check the arguments */
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         if (MPI_COMM_NULL == old_comm) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_create");
+                                          FUNC_NAME);
         }
         if (OMPI_COMM_IS_INTER(old_comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_create");
+                                          FUNC_NAME);
         }
         if (1 > ndims) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_create");
+                                          FUNC_NAME);
         }
         if (NULL == dims || NULL == periods || NULL == comm_cart) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_create");
+                                          FUNC_NAME);
         }
         if (0 > reorder || 1 < reorder) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_create");
+                                          FUNC_NAME);
         }
 
         /* check if the number of processes on the grid are corrct */
@@ -61,7 +65,7 @@ int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
 
            if (parent_procs < count_nodes) {
                return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                              "MPI_Cart_create");
+                                              FUNC_NAME);
            }
         }
     }
@@ -83,7 +87,7 @@ int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
 
     /* check the error status */
     if (MPI_SUCCESS != err) {
-        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_create");
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
     }
     
     /* All done */

src/mpi/c/cart_get.c

@@ -18,6 +18,9 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cart_get";
+
+
 int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims,
                  int *periods, int *coords) {
     /* local variables */
@@ -26,31 +29,33 @@ int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims,
 
     /* check the arguments */
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         if (MPI_COMM_NULL == comm || OMPI_COMM_IS_INTER(comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_get");
+                                          FUNC_NAME);
         }
         if (!OMPI_COMM_IS_CART(comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
-                                          "MPI_Cart_get");
+                                          FUNC_NAME);
         }
         if ((0 > maxdims) || (0 < maxdims && 
-                        ((NULL == dims) || (NULL == periods) || (NULL == coords)))) {
+                              ((NULL == dims) || (NULL == periods) ||
+                               (NULL == coords)))) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_get");
+                                          FUNC_NAME);
         }
     }
     /* get the function pointer to do the right thing */
     func = comm->c_topo->topo_cart_get;
     if (NULL == func) {
         return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER, 
-                                     "MPI_Cart_get");
+                                     FUNC_NAME);
     }
 
     /* all arguments are checked and now call the back end function */
     if ( MPI_SUCCESS != 
             (err = func(comm, maxdims, dims, periods, coords))) {
-        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_get");
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
     }
     
     /* All done */

src/mpi/c/cart_map.c

@@ -18,6 +18,9 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cart_map";
+
+
 int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims,
                 int *periods, int *newrank) {
     int err;
@@ -25,21 +28,22 @@ int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims,
 
     /* check the arguments */
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         if (MPI_COMM_NULL == comm) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_map");
+                                          FUNC_NAME);
         }
         if (OMPI_COMM_IS_INTER(comm)) { 
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_map");
+                                          FUNC_NAME);
         }
         if(!OMPI_COMM_IS_CART(comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
-                                          "MPI_Cart_map");
+                                          FUNC_NAME);
         }
         if ((NULL == dims) || (NULL == periods) || (NULL == newrank)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_map");
+                                          FUNC_NAME);
         }
     }
 
@@ -47,12 +51,12 @@ int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims,
     func = comm->c_topo->topo_cart_map;
     if (NULL == func) {
         return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER, 
-                                     "MPI_Cart_map");
+                                     FUNC_NAME);
     }
     /* call the function */
     if ( MPI_SUCCESS != 
             (err = func(comm, ndims, dims, periods, newrank))) {
-        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_map");
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
     }
 
     return MPI_SUCCESS;

src/mpi/c/cart_rank.c

@@ -18,6 +18,8 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cart_rank";
+
 
 int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank) {
     int err;
@@ -25,21 +27,22 @@ int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank) {
 
     /* check the arguments */
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         if (MPI_COMM_NULL == comm) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_rank");
+                                          FUNC_NAME);
         }
         if (OMPI_COMM_IS_INTER(comm)) { 
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_rank");
+                                          FUNC_NAME);
         }
         if (!OMPI_COMM_IS_CART(comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
-                                          "MPI_Cart_rank");
+                                          FUNC_NAME);
         }
         if ((NULL == coords) || (NULL == rank)){
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_rank");
+                                          FUNC_NAME);
         }
     }
 
@@ -47,12 +50,12 @@ int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank) {
     func = comm->c_topo->topo_cart_rank;
     if (NULL == func) {
         return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER, 
-                                     "MPI_Cart_rank");
+                                     FUNC_NAME);
     }
     /* call the function */
     if ( MPI_SUCCESS != 
             (err = func(comm, coords, rank))) {
-        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_rank");
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
     }
 
     return MPI_SUCCESS;

src/mpi/c/cart_shift.c

@@ -18,6 +18,9 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cart_shift";
+
+
 int MPI_Cart_shift(MPI_Comm comm, int direction, int disp,
                    int *rank_source, int *rank_dest) {
     int err;
@@ -25,25 +28,26 @@ int MPI_Cart_shift(MPI_Comm comm, int direction, int disp,
 
     /* check the arguments */
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         if (MPI_COMM_NULL == comm) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_shift");
+                                          FUNC_NAME);
         }
         if (OMPI_COMM_IS_INTER(comm)) { 
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_shift");
+                                          FUNC_NAME);
         }
         if (!OMPI_COMM_IS_CART(comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
-                                          "MPI_Cart_shift");
+                                          FUNC_NAME);
         }
         if (0 > direction) { /* yet to detect direction >= comm->c_topo_ndims */
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_DIMS,
-                                          "MPI_Cart_shift");
+                                          FUNC_NAME);
         }
         if (NULL == rank_source || NULL == rank_dest) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_shift");
+                                          FUNC_NAME);
         }
     }
 
@@ -51,12 +55,12 @@ int MPI_Cart_shift(MPI_Comm comm, int direction, int disp,
     func = comm->c_topo->topo_cart_shift;
     if (NULL == func) {
         return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER, 
-                                     "MPI_Cart_shift");
+                                     FUNC_NAME);
     }
     /* call the function */
     if ( MPI_SUCCESS != 
             (err = func(comm, direction, disp, rank_source, rank_dest))) {
-        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_shift");
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
     }
 
     /* all done */

src/mpi/c/cart_sub.c

@@ -18,6 +18,8 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Cart_sub";
+
 
 int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm) {
     int err;
@@ -25,21 +27,22 @@ int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm) {
 
     /* check the arguments */
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         if (MPI_COMM_NULL == comm) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_sub");
+                                          FUNC_NAME);
         }
         if (OMPI_COMM_IS_INTER(comm)) { 
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_COMM,
-                                          "MPI_Cart_sub");
+                                          FUNC_NAME);
         }
         if (!OMPI_COMM_IS_CART(comm)) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_TOPOLOGY,
-                                          "MPI_Cart_sub");
+                                          FUNC_NAME);
         }
         if (NULL == remain_dims || NULL == new_comm) {
             return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_ARG,
-                                          "MPI_Cart_sub");
+                                          FUNC_NAME);
         }
     }
 
@@ -47,12 +50,12 @@ int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm) {
     func = comm->c_topo->topo_cart_sub;
     if (NULL == func) {
         return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_OTHER, 
-                                     "MPI_Cart_sub");
+                                     FUNC_NAME);
     }
     /* call the function */
     if ( MPI_SUCCESS != 
             (err = func(comm, remain_dims, new_comm))) {
-        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, "MPI_Cart_sub");
+        return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, err, FUNC_NAME);
     }
 
     /* all done */

src/mpi/c/cartdim_get.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Cartdim_get = PMPI_Cartdim_get
@@ -16,6 +18,16 @@
 #endif
 
 
-int MPI_Cartdim_get(MPI_Comm comm, int *ndims) {
+static const char FUNC_NAME[] = "MPI_Cartdim_get";
-    return MPI_SUCCESS;
+
+
+int MPI_Cartdim_get(MPI_Comm comm, int *ndims) 
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/close_port.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Close_port";
+static const char FUNC_NAME[] = "MPI_Close_port";
 
 
 int MPI_Close_port(char *port_name) 
@@ -27,7 +27,7 @@ int MPI_Close_port(char *port_name)
 
         if ( NULL == port_name )
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, 
-                                          "MPI_Close_port");
+                                          FUNC_NAME);
     }
 
     /* As far as I can see at the moment, this is an empty function.
@@ -35,5 +35,7 @@ int MPI_Close_port(char *port_name)
        therefore we don't have to free an 'address'.
     */
 
-    return MPI_SUCCESS;
+    /* This function is not yet implemented */
+
+    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/comm_accept.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_accept";
+static const char FUNC_NAME[] = "MPI_Comm_accept";
 
 
 int MPI_Comm_accept(char *port_name, MPI_Info info, int root,
@@ -35,18 +35,22 @@ int MPI_Comm_accept(char *port_name, MPI_Info info, int root,
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
+        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
                                           FUNC_NAME);
-        if ( OMPI_COMM_IS_INTER(comm))
+        }
+        if ( OMPI_COMM_IS_INTER(comm)) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
                                           FUNC_NAME);
-        if ( 0 > root || ompi_comm_size(comm) < root ) 
+        }
+        if ( 0 > root || ompi_comm_size(comm) < root ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
-        if ( NULL == newcomm )
+        }
+        if ( NULL == newcomm ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
+        }
     }
     
     rank = ompi_comm_rank ( comm );

src/mpi/c/comm_c2f.c

@@ -18,18 +18,19 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Comm_c2f";
+
+
 MPI_Fint MPI_Comm_c2f(MPI_Comm comm) 
 {
     ompi_communicator_t *cptr=(ompi_communicator_t *)comm;
 
     if ( MPI_PARAM_CHECK) {
-        if ( ompi_mpi_finalized )
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-            return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, 
-                                         "MPI_Comm_c2f");
         
         if ( ompi_comm_invalid (cptr))
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
-                                        "MPI_Comm_c2f");
+                                        FUNC_NAME);
     }
 
     /* Since MPI_COMM_NULL is an object itself, we do not have to check

src/mpi/c/comm_call_errhandler.c

@@ -18,20 +18,23 @@
 #endif
     
 
+static const char FUNC_NAME[] = "MPI_Comm_call_errhandler";
+
+
 int MPI_Comm_call_errhandler(MPI_Comm comm, int errorcode)
 {
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
-    if (NULL == comm ||
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-        MPI_COMM_NULL == comm) {
+    if (ompi_comm_invalid(comm)) {
-      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
+      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM,
-                                   "MPI_Comm_call_errhandler");
+                                    FUNC_NAME);
     }
   }
 
   /* Invoke the errhandler */
 
-  return OMPI_ERRHANDLER_INVOKE(comm, errorcode,
+  return OMPI_ERRHANDLER_INVOKE(comm, errorcode, FUNC_NAME);
-                               "MPI_Comm_call_errhandler");
 }
+

src/mpi/c/comm_compare.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_compare";
+static const char FUNC_NAME[] = "MPI_Comm_compare";
 
 
 int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result) {

src/mpi/c/comm_connect.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_connect";
+static const char FUNC_NAME[] = "MPI_Comm_connect";
 
 
 int MPI_Comm_connect(char *port_name, MPI_Info info, int root,
@@ -35,18 +35,22 @@ int MPI_Comm_connect(char *port_name, MPI_Info info, int root,
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
+        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
                                           FUNC_NAME);
-        if ( OMPI_COMM_IS_INTER(comm))
+        }
+        if ( OMPI_COMM_IS_INTER(comm)) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
                                           FUNC_NAME);
-        if ( 0 > root || ompi_comm_size(comm) < root ) 
+        }
+        if ( 0 > root || ompi_comm_size(comm) < root ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
-        if ( NULL == newcomm )
+        }
+        if ( NULL == newcomm ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
+        }
     }
     
     rank = ompi_comm_rank ( comm );

src/mpi/c/comm_create.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_create";
+static const char FUNC_NAME[] = "MPI_Comm_create";
 
 
 int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm) {

src/mpi/c/comm_create_errhandler.c

@@ -18,6 +18,9 @@
 #endif
 
 
+static const char FUNC_NAME[] = "MPI_Comm_create_errhandler";
+
+
 int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function,
                                MPI_Errhandler *errhandler) 
 {
@@ -26,10 +29,12 @@ int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function,
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
     if (NULL == function || 
         NULL == errhandler) {
       return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
-                                   "MPI_Comm_create_errhandler");
+                                    FUNC_NAME);
     }
   }
 
@@ -42,6 +47,5 @@ int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function,
     err = MPI_ERR_INTERN;
   }
 
-  OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, MPI_ERR_INTERN,
+  OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
-                        "MPI_Comm_create_errhandler");
 }

src/mpi/c/comm_create_keyval.c

@@ -18,6 +18,7 @@
 
 static const char FUNC_NAME[] = "MPI_Comm_create_keyval";
 
+
 int 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)
@@ -27,6 +28,7 @@ int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function *comm_copy_attr_fn,
     ompi_attribute_fn_ptr_union_t del_fn;
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if ((NULL == comm_copy_attr_fn) || (NULL == comm_delete_attr_fn) ||
 	    (NULL == comm_keyval)) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, 

src/mpi/c/comm_delete_attr.c

@@ -18,11 +18,13 @@
 
 static const char FUNC_NAME[] = "MPI_Comm_delete_attr";
 
+
 int MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval) 
 {
     int ret;
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if (MPI_COMM_NULL == comm) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
 					 FUNC_NAME);

src/mpi/c/comm_disconnect.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_disconnect";
+static const char FUNC_NAME[] = "MPI_Comm_disconnect";
 
 
 int MPI_Comm_disconnect(MPI_Comm *comm) 

src/mpi/c/comm_dup.c

@@ -17,11 +17,11 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_dup";
+static const char FUNC_NAME[] = "MPI_Comm_dup";
 
 
-int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm) {
+int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm) 
-    
+{
     /* local variables */
     ompi_communicator_t *comp, *newcomp;
     int rsize, mode, rc=MPI_SUCCESS;

src/mpi/c/comm_f2c.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_f2c";
+static const char FUNC_NAME[] = "MPI_Comm_f2c";
 
 
 MPI_Comm MPI_Comm_f2c(MPI_Fint comm) 

src/mpi/c/comm_free.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_free";
+static const char FUNC_NAME[] = "MPI_Comm_free";
 
 
 int MPI_Comm_free(MPI_Comm *comm) {

src/mpi/c/comm_free_keyval.c

@@ -18,6 +18,7 @@
 
 static const char FUNC_NAME[] = "MPI_Comm_free_keyval";
 
+
 int MPI_Comm_free_keyval(int *comm_keyval) 
 {
     int ret;
@@ -25,6 +26,7 @@ int MPI_Comm_free_keyval(int *comm_keyval)
     /* Check for valid key pointer */
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if (NULL == comm_keyval) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, 
 					 FUNC_NAME);

src/mpi/c/comm_get_attr.c

@@ -18,12 +18,14 @@
 
 static const char FUNC_NAME[] = "MPI_Comm_get_attr";
 
+
 int MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval,
                       void *attribute_val, int *flag)
 {
     int ret;
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if ((NULL == attribute_val) || (NULL == flag)) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, 
 					 FUNC_NAME);

src/mpi/c/comm_get_errhandler.c

@@ -18,18 +18,22 @@
 #endif
 
 
+static const char FUNC_NAME[] = "MPI_Comm_get_errhandler";
+
+
 int MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler *errhandler)
 {
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
     if (NULL == comm || 
         MPI_COMM_NULL == comm) {
       return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
-                                   "MPI_Comm_get_errhandler");
+                                    FUNC_NAME);
     } else if (NULL == errhandler) {
       return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
-                                   "MPI_Comm_get_errhandler");
+                                    FUNC_NAME);
     }
   }
 

src/mpi/c/comm_get_name.c

@@ -21,7 +21,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_get_name";
+static const char FUNC_NAME[] = "MPI_Comm_get_name";
 
 
 int MPI_Comm_get_name(MPI_Comm comm, char *name, int *length)  {

src/mpi/c/comm_get_parent.c

@@ -17,16 +17,19 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Comm_get_parent";
+
+
 int MPI_Comm_get_parent(MPI_Comm *parent) 
 {
 
     if ( MPI_PARAM_CHECK ) {
-        if ( ompi_mpi_finalized )
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-            return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, 
+
-                                          "MPI_Comm_get_parent");
+        if ( NULL == parent ) {
-        if ( NULL == parent )
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, 
-                                         "MPI_Comm_get_parent");
+                                          FUNC_NAME);
+        }
     }
     /*
      * ompi_mpi_comm_parent is MPI_COMM_NULL, in case this 
@@ -40,5 +43,7 @@ int MPI_Comm_get_parent(MPI_Comm *parent)
        *parent  = &ompi_mpi_comm_null;
      */
 
-    return MPI_SUCCESS;
+    /* This function is not yet implemented */
+
+    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/comm_group.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_group";
+static const char FUNC_NAME[] = "MPI_Comm_group";
 
 
 int MPI_Comm_group(MPI_Comm comm, MPI_Group *group) {

src/mpi/c/comm_join.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_join";
+static const char FUNC_NAME[] = "MPI_Comm_join";
 
 
 int MPI_Comm_join(int fd, MPI_Comm *intercomm) 
@@ -32,9 +32,10 @@ int MPI_Comm_join(int fd, MPI_Comm *intercomm)
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( NULL == intercomm ) 
+        if ( NULL == intercomm ) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, 
                                           FUNC_NAME);
+        }
     }
     
     /* sendrecv OOB-name (port-name) through the socket connection.

src/mpi/c/comm_rank.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_rank";
+static const char FUNC_NAME[] = "MPI_Comm_rank";
 
 
 int MPI_Comm_rank(MPI_Comm comm, int *rank) 

src/mpi/c/comm_remote_group.c

@@ -10,7 +10,6 @@
 #include "runtime/runtime.h"
 #include "communicator/communicator.h"
 
-
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Comm_remote_group = PMPI_Comm_remote_group
 #endif
@@ -20,29 +19,32 @@
 #endif
 
 
+static const char FUNC_NAME[] = "MPI_Comm_remote_group";
+
+
 int MPI_Comm_remote_group(MPI_Comm comm, MPI_Group *group) 
 {
 
     if ( MPI_PARAM_CHECK ) {
-        if ( ompi_mpi_finalized )
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-            return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, 
+        if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
-                                         "MPI_Comm_remote_group");
-
-        if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
-                                         "MPI_Comm_remote_group");
+                                          FUNC_NAME);
+        }
 
-        if ( NULL == group )
+        if ( NULL == group ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
-                                         "MPI_Comm_remote_group");
+                                          FUNC_NAME);
+        }
     }
 
     if ( OMPI_COMM_IS_INTER(comm) ) {        
         OBJ_RETAIN(comm->c_remote_group);
     }
-    else
+    else {
         return OMPI_ERRHANDLER_INVOKE (comm, MPI_ERR_COMM, 
-                                      "MPI_Comm_remote_group");
+                                       FUNC_NAME);
+    }
 
     *group = (MPI_Group) comm->c_remote_group;
     return MPI_SUCCESS;

src/mpi/c/comm_remote_size.c

@@ -18,20 +18,22 @@
 #endif
 
 
+static const char FUNC_NAME[] = "MPI_Comm_remote_size";
+
+
 int MPI_Comm_remote_size(MPI_Comm comm, int *size) {
 
     if ( MPI_PARAM_CHECK ) {
-        if ( ompi_mpi_finalized )
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-            return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, 
-                                         "MPI_Comm_remote_size");
 
-        if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
+        if (MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
-                                         "MPI_Comm_remote_size");
+                                          FUNC_NAME);
+        }
 
-        if ( NULL == size )
+        if ( NULL == size ) {
-            return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
+            return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, FUNC_NAME);
-                                         "MPI_Comm_remote_size");
+        }
     }
 
     *size = ompi_comm_remote_size ((ompi_communicator_t*)comm);

src/mpi/c/comm_set_attr.c

@@ -18,11 +18,13 @@
 
 static const char FUNC_NAME[] = "MPI_Comm_set_attr";
 
+
 int MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val) 
 {
     int ret;
 
     if (MPI_PARAM_CHECK) {
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 	if (MPI_COMM_NULL == comm) {
 	    return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
 					 FUNC_NAME);
@@ -31,6 +33,5 @@ int MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val)
     
     ret = ompi_attr_set(COMM_ATTR, comm, comm->c_keyhash, 
 		       comm_keyval, attribute_val, 0);
-
     OMPI_ERRHANDLER_RETURN(ret, comm, MPI_ERR_OTHER, FUNC_NAME);  
 }

src/mpi/c/comm_set_errhandler.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_set_errhandler";
+static const char FUNC_NAME[] = "MPI_Comm_set_errhandler";
 
 
 int MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) 

src/mpi/c/comm_set_name.c

@@ -21,7 +21,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_set_name";
+static const char FUNC_NAME[] = "MPI_Comm_set_name";
 
 
 int MPI_Comm_set_name(MPI_Comm comm, char *name) {
@@ -31,13 +31,15 @@ int MPI_Comm_set_name(MPI_Comm comm, char *name) {
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) )
+        if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) ) {
             return OMPI_ERRHANDLER_INVOKE ( MPI_COMM_WORLD, MPI_ERR_COMM,
                                             FUNC_NAME);
+        }
 
-        if ( NULL == name )
+        if ( NULL == name ) {
             return OMPI_ERRHANDLER_INVOKE ( comm, MPI_ERR_ARG, 
                                             FUNC_NAME);
+        }
     }
 
     /* -- Thread safety entrance -- */

src/mpi/c/comm_size.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_comm_size";
+static const char FUNC_NAME[] = "MPI_comm_size";
 
 
 int MPI_Comm_size(MPI_Comm comm, int *size) {
@@ -25,12 +25,14 @@ int MPI_Comm_size(MPI_Comm comm, int *size) {
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
+        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, 
                                           MPI_ERR_COMM, FUNC_NAME);
+        }
 
-        if ( NULL == size )
+        if ( NULL == size ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, FUNC_NAME);
+        }
     }
 
     *size = ompi_comm_size((ompi_communicator_t*)comm);

src/mpi/c/comm_spawn.c

@@ -19,7 +19,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_spawn";
+static const char FUNC_NAME[] = "MPI_Comm_spawn";
 
 
 int MPI_Comm_spawn(char *command, char **argv, int maxprocs, MPI_Info info,
@@ -36,35 +36,43 @@ int MPI_Comm_spawn(char *command, char **argv, int maxprocs, MPI_Info info,
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
+        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
                                           FUNC_NAME);
-        if ( OMPI_COMM_IS_INTER(comm))
+        }
+        if ( OMPI_COMM_IS_INTER(comm)) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
                                           FUNC_NAME);
-        if ( 0 > root || ompi_comm_size(comm) < root ) 
+        }
+        if ( 0 > root || ompi_comm_size(comm) < root ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
-        if ( NULL == intercomm ) 
+        }
+        if ( NULL == intercomm ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                           FUNC_NAME);
-        if ( NULL == array_of_errcodes ) 
+        }
+        if ( NULL == array_of_errcodes ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                           FUNC_NAME);
+        }
     }
    
    rank = ompi_comm_rank ( comm );
    if ( MPI_PARAM_CHECK ) {
        if ( rank == root ) {
-           if ( NULL == command ) 
+         if ( NULL == command ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                              FUNC_NAME);
-           if ( NULL == argv ) 
+         }
+         if ( NULL == argv ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                              FUNC_NAME);
-           if ( 0 > maxprocs ) 
+         }
+         if ( 0 > maxprocs ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                              FUNC_NAME);
+         }
        }
    }
 

src/mpi/c/comm_spawn_multiple.c

@@ -18,7 +18,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_spawn_multiple";
+static const char FUNC_NAME[] = "MPI_Comm_spawn_multiple";
 
 
 int MPI_Comm_spawn_multiple(int count, char **array_of_commands, char ***array_of_argv,
@@ -37,52 +37,65 @@ int MPI_Comm_spawn_multiple(int count, char **array_of_commands, char ***array_o
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm))
+        if ( MPI_COMM_NULL == comm || ompi_comm_invalid (comm)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
                                           FUNC_NAME);
-        if ( OMPI_COMM_IS_INTER(comm))
+        }
+        if ( OMPI_COMM_IS_INTER(comm)) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM,
                                           FUNC_NAME);
-        if ( 0 > root || ompi_comm_size(comm) < root ) 
+        }
+        if ( 0 > root || ompi_comm_size(comm) < root ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
-        if ( NULL == intercomm ) 
+        }
+        if ( NULL == intercomm ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                           FUNC_NAME);
-        if ( NULL == array_of_errcodes ) 
+        }
+        if ( NULL == array_of_errcodes ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                           FUNC_NAME);
+        }
     }
    
    rank = ompi_comm_rank ( comm );
    if ( MPI_PARAM_CHECK ) {
        if ( rank == root ) {
-           if ( 0 > count ) 
+         if ( 0 > count ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                              FUNC_NAME);
-           if ( NULL == array_of_commands ) 
+         }
+         if ( NULL == array_of_commands ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                              FUNC_NAME);
-           if ( NULL == array_of_argv ) 
+         }
+         if ( NULL == array_of_argv ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                              FUNC_NAME);
-           if ( NULL ==  array_of_maxprocs ) 
+         }
+         if ( NULL ==  array_of_maxprocs ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                              FUNC_NAME);
-           if ( NULL == array_of_info ) 
+         }
+         if ( NULL == array_of_info ) {
                return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                              FUNC_NAME);
-           for ( i=0; i<count; i++ ) {
+         }
-               if ( NULL == array_of_commands[i] ) 
+         for ( i=0; i<count; i++ ) {
-                   return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
+           if ( NULL == array_of_commands[i] ) {
-                                                 FUNC_NAME);
-               if ( NULL == array_of_argv[i] ) 
-                   return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
-                                                 FUNC_NAME);
-               if ( 0 > array_of_maxprocs[i] ) 
                    return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
                                                  FUNC_NAME);
            }
+           if ( NULL == array_of_argv[i] ) {
+                   return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
+                                                 FUNC_NAME);
+           }
+           if ( 0 > array_of_maxprocs[i] ) {
+                   return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG,
+                                                 FUNC_NAME);
+           }
+         }
        }
    }
 

src/mpi/c/comm_split.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_split";
+static const char FUNC_NAME[] = "MPI_Comm_split";
 
 
 int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm) {
@@ -27,17 +27,20 @@ int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm) {
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( comm == MPI_COMM_NULL || ompi_comm_invalid ( comm ))
+        if ( comm == MPI_COMM_NULL || ompi_comm_invalid ( comm )) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, 
                                           FUNC_NAME);
+        }
 
-        if ( color < 0 &&  MPI_UNDEFINED != color ) 
+        if ( color < 0 &&  MPI_UNDEFINED != color ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
+        }
         
-        if ( NULL == newcomm )
+        if ( NULL == newcomm ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_ARG, 
                                           FUNC_NAME);
+        }
     }
     
     rc = ompi_comm_split ( (ompi_communicator_t*)comm, color, key, 

src/mpi/c/comm_test_inter.c

@@ -17,7 +17,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Comm_test_inter";
+static const char FUNC_NAME[] = "MPI_Comm_test_inter";
 
 
 int MPI_Comm_test_inter(MPI_Comm comm, int *flag) {
@@ -25,13 +25,15 @@ int MPI_Comm_test_inter(MPI_Comm comm, int *flag) {
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
         
-        if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) )
+        if ( MPI_COMM_NULL == comm || ompi_comm_invalid ( comm ) ) {
              return OMPI_ERRHANDLER_INVOKE ( MPI_COMM_WORLD, MPI_ERR_COMM,
                                              FUNC_NAME);
+        }
         
-        if ( NULL == flag ) 
+        if ( NULL == flag ) {
              return OMPI_ERRHANDLER_INVOKE ( comm, MPI_ERR_ARG, 
                                              FUNC_NAME);
+        }
     }
 
     *flag = (comm->c_flags & OMPI_COMM_INTER);

src/mpi/c/dims_create.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Dims_create = PMPI_Dims_create
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_Dims_create(int nnodes, int ndims, int *dims) {
+static const char FUNC_NAME[] = "MPI_Dims_create";
-    return MPI_SUCCESS;
+
+
+int MPI_Dims_create(int nnodes, int ndims, int *dims) 
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/errhandler_c2f.c

@@ -17,12 +17,15 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Errhandler_c2f";
+
 
 MPI_Fint MPI_Errhandler_c2f(MPI_Errhandler errhandler)
 {
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
     if (NULL == errhandler ||
         MPI_ERRHANDLER_NULL == errhandler ||
         OMPI_ERRHANDLER_TYPE_COMM != errhandler->eh_mpi_object_type) {

src/mpi/c/errhandler_create.c

@@ -15,6 +15,9 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Errhandler_create";
+
+
 int MPI_Errhandler_create(MPI_Handler_function *function,
                           MPI_Errhandler *errhandler)
 {

src/mpi/c/errhandler_f2c.c

@@ -17,6 +17,8 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Errhandler_f2c";
+
 
 MPI_Errhandler MPI_Errhandler_f2c(MPI_Fint errhandler_f)
 {
@@ -25,6 +27,8 @@ MPI_Errhandler MPI_Errhandler_f2c(MPI_Fint errhandler_f)
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
     if (0 > eh_index || 
         eh_index >= ompi_pointer_array_get_size(ompi_errhandler_f_to_c_table)) {
       return MPI_ERRHANDLER_NULL;

src/mpi/c/errhandler_free.c

@@ -17,12 +17,15 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Errhandler_free";
+
 
 int MPI_Errhandler_free(MPI_Errhandler *errhandler)
 {
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
     if (NULL == errhandler ||
         ompi_errhandler_is_intrinsic(*errhandler)) {
       return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,

src/mpi/c/errhandler_get.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Errhandler_get = PMPI_Errhandler_get
@@ -15,9 +17,15 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Errhandler_get";
+
 
 int MPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler *errhandler) 
 {
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
   /* This is a deprecated -- just turn around and call the real
      function */
 

src/mpi/c/errhandler_set.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_Errhandler_set = PMPI_Errhandler_set
@@ -15,9 +17,15 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_Errhandler_set";
+
 
 int MPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler)
 {
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
   /* This is a deprecated -- just turn around and call the real
      function */
 

src/mpi/c/error_class.c

@@ -18,18 +18,18 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Error_class";
+static const char FUNC_NAME[] = "MPI_Error_class";
 
 
 int MPI_Error_class(int errorcode, int *errorclass) 
 {
-
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( ompi_mpi_errcode_is_invalid(errorcode))
+        if ( ompi_mpi_errcode_is_invalid(errorcode)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
                                           FUNC_NAME);
+        }
     }
     
     

src/mpi/c/error_string.c

@@ -19,7 +19,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Error_string";
+static const char FUNC_NAME[] = "MPI_Error_string";
 
 
 int MPI_Error_string(int errorcode, char *string, int *resultlen) 
@@ -29,9 +29,10 @@ int MPI_Error_string(int errorcode, char *string, int *resultlen)
     if ( MPI_PARAM_CHECK ) {
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
 
-        if ( ompi_mpi_errcode_is_invalid(errorcode))
+        if ( ompi_mpi_errcode_is_invalid(errorcode)) {
             return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
                                           FUNC_NAME);
+        }
     }
  
     tmpstring = ompi_mpi_errcode_get_string (errorcode);

src/mpi/c/exscan.c

@@ -19,7 +19,7 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-static char FUNC_NAME[] = "MPI_Exscan";
+static const char FUNC_NAME[] = "MPI_Exscan";
 
 
 int MPI_Exscan(void *sendbuf, void *recvbuf, int count,

src/mpi/c/file_c2f.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_c2f = PMPI_File_c2f
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-MPI_Fint MPI_File_c2f(MPI_File file) {
+static const char FUNC_NAME[] = "MPI_File_c2f";
-    return (MPI_Fint)0;
+
+
+MPI_Fint MPI_File_c2f(MPI_File file)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return (MPI_Fint) OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_call_errhandler.c

@@ -18,19 +18,22 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_call_errhandler(MPI_File fh, int errorcode) {
+static const char FUNC_NAME[] = "MPI_File_call_errhandler";
+
+
+int MPI_File_call_errhandler(MPI_File fh, int errorcode) 
+{
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
     if (NULL == fh ||
         MPI_FILE_NULL == fh) {
-      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
+      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME);
-                                   "MPI_File_call_errhandler");
     }
   }
 
   /* Invoke the errhandler */
 
-  return OMPI_ERRHANDLER_INVOKE(fh, errorcode,
+  return OMPI_ERRHANDLER_INVOKE(fh, errorcode, FUNC_NAME);
-                               "MPI_File_call_errhandler");
 }

src/mpi/c/file_close.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_close = PMPI_File_close
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_close(MPI_File *fh) {
+static const char FUNC_NAME[] = "MPI_File_close";
-    return MPI_SUCCESS;
+
+
+int MPI_File_close(MPI_File *fh) 
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_create_errhandler.c

@@ -18,6 +18,9 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_create_errhandler";
+
+
 int MPI_File_create_errhandler(MPI_File_errhandler_fn *function,
 		                        MPI_Errhandler *errhandler) {
   int err = MPI_SUCCESS;
@@ -25,6 +28,7 @@ int MPI_File_create_errhandler(MPI_File_errhandler_fn *function,
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
     if (NULL == function || 
         NULL == errhandler) {
       return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,

src/mpi/c/file_delete.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_delete = PMPI_File_delete
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_delete(char *filename, MPI_Info info) {
+static const char FUNC_NAME[] = "MPI_File_delete";
-    return MPI_SUCCESS;
+
+
+int MPI_File_delete(char *filename, MPI_Info info) 
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_f2c.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_f2c = PMPI_File_f2c
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-MPI_File MPI_File_f2c(MPI_Fint file) {
+static const char FUNC_NAME[] = "MPI_File_f2c";
-    return (MPI_File)0;
+
+
+MPI_File MPI_File_f2c(MPI_Fint file) 
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return (MPI_File) OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_amode.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_amode = PMPI_File_get_amode
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_amode(MPI_File fh, int *amode) {
+static const char FUNC_NAME[] = "MPI_File_get_amode";
-    return MPI_SUCCESS;
+
+
+int MPI_File_get_amode(MPI_File fh, int *amode)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_atomicity.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_atomicity = PMPI_File_get_atomicity
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_atomicity(MPI_File fh, int *flag) {
+static const char FUNC_NAME[] = "MPI_File_get_atomicity";
-    return MPI_SUCCESS;
+
+
+int MPI_File_get_atomicity(MPI_File fh, int *flag)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_byte_offset.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_byte_offset = PMPI_File_get_byte_offset
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_get_byte_offset";
+
+
 int MPI_File_get_byte_offset(MPI_File fh, MPI_Offset offset,
-		                     MPI_Offset *disp) {
+                             MPI_Offset *disp)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_errhandler.c

@@ -18,13 +18,18 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler *errhandler) {
+static const char FUNC_NAME[] = "MPI_File_get_errhandler";
+
+
+int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler *errhandler) 
+{
   /* Error checking */
 
   if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
     if (NULL == file || 
         MPI_FILE_NULL == file) {
-      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
+      return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_FILE,
                                    "MPI_File_get_errhandler");
     } else if (NULL == errhandler) {
       return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG,
@@ -38,5 +43,6 @@ int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler *errhandler) {
   *errhandler = file->error_handler;
 
   /* All done */
+
   return MPI_SUCCESS;
 }

src/mpi/c/file_get_group.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_group = PMPI_File_get_group
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_group(MPI_File fh, MPI_Group *group) {
+static const char FUNC_NAME[] = "MPI_File_get_group";
-    return MPI_SUCCESS;
+
+
+int MPI_File_get_group(MPI_File fh, MPI_Group *group)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_info.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_info = PMPI_File_get_info
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_info(MPI_File fh, MPI_Info *info_used) {
+static const char FUNC_NAME[] = "MPI_File_get_info";
-    return MPI_SUCCESS;
+
+
+int MPI_File_get_info(MPI_File fh, MPI_Info *info_used)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_position.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_position = PMPI_File_get_position
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_position(MPI_File fh, MPI_Offset *offset) {
+static const char FUNC_NAME[] = "MPI_File_get_position";
-    return MPI_SUCCESS;
+
+
+int MPI_File_get_position(MPI_File fh, MPI_Offset *offset)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_position_shared.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_position_shared = PMPI_File_get_position_shared
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset) {
+static const char FUNC_NAME[] = "MPI_File_get_position_shared";
-    return MPI_SUCCESS;
+
+
+int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_size.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_size = PMPI_File_get_size
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_get_size(MPI_File fh, MPI_Offset *size) {
+static const char FUNC_NAME[] = "MPI_File_get_size";
-    return MPI_SUCCESS;
+
+
+int MPI_File_get_size(MPI_File fh, MPI_Offset *size)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_type_extent.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_type_extent = PMPI_File_get_type_extent
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_get_type_extent";
+
+
 int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype,
-		                     MPI_Aint *extent) {
+                             MPI_Aint *extent)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_get_view.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_get_view = PMPI_File_get_view
@@ -15,8 +17,18 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_get_view";
+
+
 int MPI_File_get_view(MPI_File fh, MPI_Offset *disp,
-		              MPI_Datatype *etype,
+                      MPI_Datatype *etype,
-					  MPI_Datatype *filetype, char *datarep) {
+                      MPI_Datatype *filetype, char *datarep)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_iread.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_iread = PMPI_File_iread
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_iread";
+
+
 int MPI_File_iread(MPI_File fh, void *buf, int count, MPI_Datatype
-		                   datatype, MPI_Request *request) {
+                   datatype, MPI_Request *request)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_iread_at.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_iread_at = PMPI_File_iread_at
@@ -15,8 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf,
+static const char FUNC_NAME[] = "MPI_File_iread_at";
-		              int count, MPI_Datatype datatype, MPI_Request *request) {
 
-    return MPI_SUCCESS;
+
+int MPI_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf,
+                      int count, MPI_Datatype datatype, MPI_Request *request)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_iread_shared.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_iread_shared = PMPI_File_iread_shared
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_iread_shared";
+
+
 int MPI_File_iread_shared(MPI_File fh, void *buf, int count,
-		                  MPI_Datatype datatype, MPI_Request *request) {
+                          MPI_Datatype datatype, MPI_Request *request)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_iwrite.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_iwrite = PMPI_File_iwrite
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_iwrite";
+
+
 int MPI_File_iwrite(MPI_File fh, void *buf, int count, MPI_Datatype
-		                    datatype, MPI_Request *request) {
+                    datatype, MPI_Request *request)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_iwrite_at.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_iwrite_at = PMPI_File_iwrite_at
@@ -15,8 +17,18 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_iwrite_at";
+
+
 int MPI_File_iwrite_at(MPI_File fh, MPI_Offset offset, void *buf,
                        int count, MPI_Datatype datatype, 
-                       MPI_Request *request) {
+                       MPI_Request *request)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_iwrite_shared.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_iwrite_shared = PMPI_File_iwrite_shared
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_iwrite_shared";
+
+
 int MPI_File_iwrite_shared(MPI_File fh, void *buf, int count,
-		                   MPI_Datatype datatype, MPI_Request *request) {
+                           MPI_Datatype datatype, MPI_Request *request)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_open.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_open = PMPI_File_open
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_open";
+
+
 int MPI_File_open(MPI_Comm comm, char *filename, int amode,
-		          MPI_Info info, MPI_File *fh) {
+                  MPI_Info info, MPI_File *fh)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_preallocate.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_preallocate = PMPI_File_preallocate
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_preallocate(MPI_File fh, MPI_Offset size) {
+static const char FUNC_NAME[] = "MPI_File_preallocate";
-    return MPI_SUCCESS;
+
+
+int MPI_File_preallocate(MPI_File fh, MPI_Offset size)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_read.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_read = PMPI_File_read
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_read";
+
+
 int MPI_File_read(MPI_File fh, void *buf, int count, MPI_Datatype
-		                   datatype, MPI_Status *status) {
+                  datatype, MPI_Status *status)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_read_all.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_read_all = PMPI_File_read_all
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_read_all";
+
+
 int MPI_File_read_all(MPI_File fh, void *buf, int count, MPI_Datatype
-		                   datatype, MPI_Status *status) {
+                      datatype, MPI_Status *status)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_read_all_begin.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_read_all_begin = PMPI_File_read_all_begin
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_read_all_begin";
+
+
 int MPI_File_read_all_begin(MPI_File fh, void *buf, int count,
-		                    MPI_Datatype datatype) {
+                            MPI_Datatype datatype) 
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_read_all_end.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_read_all_end = PMPI_File_read_all_end
@@ -15,6 +17,16 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
-int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status) {
+static const char FUNC_NAME[] = "MPI_File_read_all_end";
-    return MPI_SUCCESS;
+
+
+int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status)
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_read_at.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_read_at = PMPI_File_read_at
@@ -15,8 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_read_at";
+
+
 int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf,
-		            int count, MPI_Datatype datatype, MPI_Status *status) {
+                     int count, MPI_Datatype datatype, MPI_Status *status)
-								
+{
-    return MPI_SUCCESS;
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_read_at_all.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_read_at_all = PMPI_File_read_at_all
@@ -15,8 +17,18 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_read_at_all";
+
+
 int MPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf,
-		                 int count, MPI_Datatype datatype, 
+                         int count, MPI_Datatype datatype, 
-						 MPI_Status *status) {
+                         MPI_Status *status)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }

src/mpi/c/file_read_at_all_begin.c

@@ -6,6 +6,8 @@
 
 #include "mpi.h"
 #include "mpi/c/bindings.h"
+#include "communicator/communicator.h"
+#include "errhandler/errhandler.h"
 
 #if OMPI_HAVE_WEAK_SYMBOLS && OMPI_PROFILING_DEFINES
 #pragma weak MPI_File_read_at_all_begin = PMPI_File_read_at_all_begin
@@ -15,7 +17,17 @@
 #include "mpi/c/profile/defines.h"
 #endif
 
+static const char FUNC_NAME[] = "MPI_File_read_at_all_begin";
+
+
 int MPI_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf,
-		                       int count, MPI_Datatype datatype) {
+                               int count, MPI_Datatype datatype)
-    return MPI_SUCCESS;
+{
+  if (MPI_PARAM_CHECK) {
+    OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+  }
+
+  /* This function is not yet implemented */
+
+  return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME);
 }