Merge pull request #2624 in HDFFV/hdf5 from ~DEROBINS/hdf5_der:1_10_normalization to hdf5_1_10

* commit 'b699ee19cef1315dd07a331019730f214914331b':
  Normalization of H5T.c with develop.
  Normalization of H5D.c with develop.

2 files changed, 349 insertions, 401 deletions

diff --git a/src/H5D.c b/src/H5D.c
index 7030759..4828aaf 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -21,12 +21,12 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5CXprivate.h"        /* API Contexts                         */
-#include "H5Dpkg.h"		/* Datasets 				*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5FLprivate.h"	/* Free lists                           */
-#include "H5Iprivate.h"		/* IDs			  		*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Dpkg.h"             /* Datasets                                 */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5FLprivate.h"        /* Free lists                               */
+#include "H5Iprivate.h"         /* IDs                                      */
 
 
 /****************/
@@ -73,31 +73,28 @@ H5FL_BLK_EXTERN(type_conv);
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dcreate2
+ * Function:    H5Dcreate2
  *
- * Purpose:	Creates a new dataset named NAME at LOC_ID, opens the
- *		dataset for access, and associates with that dataset constant
- *		and initial persistent properties including the type of each
- *		datapoint as stored in the file (TYPE_ID), the size of the
- *		dataset (SPACE_ID), and other initial miscellaneous
- *		properties (DCPL_ID).
+ * Purpose:     Creates a new dataset named NAME at LOC_ID, opens the
+ *              dataset for access, and associates with that dataset constant
+ *              and initial persistent properties including the type of each
+ *              datapoint as stored in the file (TYPE_ID), the size of the
+ *              dataset (SPACE_ID), and other initial miscellaneous
+ *              properties (DCPL_ID).
  *
- *		All arguments are copied into the dataset, so the caller is
- *		allowed to derive new types, dataspaces, and creation
- *		parameters from the old ones and reuse them in calls to
- *		create other datasets.
+ *              All arguments are copied into the dataset, so the caller is
+ *              allowed to derive new types, dataspaces, and creation
+ *              parameters from the old ones and reuse them in calls to
+ *              create other datasets.
  *
- * Return:	Success:	The object ID of the new dataset.  At this
- *				point, the dataset is ready to receive its
- *				raw data.  Attempting to read raw data from
- *				the dataset will probably return the fill
- *				value.	The dataset should be closed when the
- *				caller is no longer interested in it.
+ * Return:      Success:    The object ID of the new dataset. At this
+ *                          point, the dataset is ready to receive its
+ *                          raw data. Attempting to read raw data from
+ *                          the dataset will probably return the fill
+ *                          value. The dataset should be closed when the
+ *                          caller is no longer interested in it.
  *
- *		Failure:	FAIL
- *
- * Programmer:	Quincey Koziol
- *		Thursday, April 5, 2007
+ *              Failure:    H5I_INVALID_HID
  *
  *-------------------------------------------------------------------------
  */
@@ -106,35 +103,39 @@ H5Dcreate2(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id,
     hid_t lcpl_id, hid_t dcpl_id, hid_t dapl_id)
 {
     H5G_loc_t	   loc;                 /* Object location to insert dataset into */
-    H5D_t	   *dset = NULL;        /* New dataset's info */
+    H5D_t          *dset = NULL;        /* New dataset's info */
     const H5S_t    *space;              /* Dataspace for dataset */
-    hid_t           ret_value;          /* Return value */
+    hid_t               ret_value = H5I_INVALID_HID;    /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE7("i", "i*siiiii", loc_id, name, type_id, space_id, lcpl_id, dcpl_id,
              dapl_id);
 
     /* Check arguments */
+    if(!name)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "name parameter cannot be NULL")
+    if(!*name)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "name parameter cannot be an empty string")
     if(H5G_loc(loc_id, &loc) < 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a location ID")
     if(H5I_DATATYPE != H5I_get_type(type_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a datatype ID")
     if(NULL == (space = (const H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace ID")
 
-    /* Get correct property list */
+    /* Get link creation property list */
     if(H5P_DEFAULT == lcpl_id)
         lcpl_id = H5P_LINK_CREATE_DEFAULT;
     else
         if(TRUE != H5P_isa_class(lcpl_id, H5P_LINK_CREATE))
-            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not link creation property list")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "lcpl_id is not a link creation property list")
 
-    /* Get correct property list */
+    /* Get dataset creation property list */
     if(H5P_DEFAULT == dcpl_id)
         dcpl_id = H5P_DATASET_CREATE_DEFAULT;
     else
         if(TRUE != H5P_isa_class(dcpl_id, H5P_DATASET_CREATE))
-            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not dataset create property list ID")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "dcpl_id is not a dataset create property list ID")
 
     /* Set the DCPL for the API context */
     H5CX_set_dcpl(dcpl_id);
@@ -146,53 +147,52 @@ H5Dcreate2(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id,
     if(H5CX_set_apl(&dapl_id, H5P_CLS_DACC, loc_id, TRUE) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, H5I_INVALID_HID, "can't set access property list info")
 
-    /* Create the new dataset & get its ID */
+    /* Create the dataset */
     if(NULL == (dset = H5D__create_named(&loc, name, type_id, space, lcpl_id, dcpl_id, dapl_id)))
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to create dataset")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, H5I_INVALID_HID, "unable to create dataset")
+
+    /* Get an ID for the dataset */
     if((ret_value = H5I_register(H5I_DATASET, dset, TRUE)) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register dataset")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register dataset")
 
 done:
-    if(ret_value < 0)
+    if(H5I_INVALID_HID == ret_value)
         if(dset && H5D_close(dset) < 0)
-            HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataset")
+            HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
 
     FUNC_LEAVE_API(ret_value)
 } /* end H5Dcreate2() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dcreate_anon
+ * Function:    H5Dcreate_anon
  *
- * Purpose:	Creates a new dataset named NAME at LOC_ID, opens the
- *		dataset for access, and associates with that dataset constant
- *		and initial persistent properties including the type of each
- *		datapoint as stored in the file (TYPE_ID), the size of the
- *		dataset (SPACE_ID), and other initial miscellaneous
- *		properties (DCPL_ID).
+ * Purpose:     Creates a new dataset named NAME at LOC_ID, opens the
+ *              dataset for access, and associates with that dataset constant
+ *              and initial persistent properties including the type of each
+ *              datapoint as stored in the file (TYPE_ID), the size of the
+ *              dataset (SPACE_ID), and other initial miscellaneous
+ *              properties (DCPL_ID).
  *
- *		All arguments are copied into the dataset, so the caller is
- *		allowed to derive new types, dataspaces, and creation
- *		parameters from the old ones and reuse them in calls to
- *		create other datasets.
+ *              All arguments are copied into the dataset, so the caller is
+ *              allowed to derive new types, dataspaces, and creation
+ *              parameters from the old ones and reuse them in calls to
+ *              create other datasets.
  *
  *              The resulting ID should be linked into the file with
  *              H5Olink or it will be deleted when closed.
  *
- * Return:	Success:	The object ID of the new dataset.  At this
- *				point, the dataset is ready to receive its
- *				raw data.  Attempting to read raw data from
- *				the dataset will probably return the fill
- *				value.	The dataset should be linked into
- *                              the group hierarchy before being closed or
- *                              it will be deleted.  The dataset should be
- *                              closed when the caller is no longer interested
- *                              in it.
- *
- *		Failure:	FAIL
+ * Return:      Success:    The object ID of the new dataset. At this
+ *                          point, the dataset is ready to receive its
+ *                          raw data. Attempting to read raw data from
+ *                          the dataset will probably return the fill
+ *                          value. The dataset should be linked into
+ *                          the group hierarchy before being closed or
+ *                          it will be deleted. The dataset should be
+ *                          closed when the caller is no longer interested
+ *                          in it.
  *
- * Programmer:	James Laird
- *		Tuesday, January 24, 2006
+ *              Failure:    H5I_INVALID_HID
  *
  *-------------------------------------------------------------------------
  */
@@ -201,25 +201,25 @@ H5Dcreate_anon(hid_t loc_id, hid_t type_id, hid_t space_id, hid_t dcpl_id,
     hid_t dapl_id)
 {
     H5G_loc_t	   loc;                 /* Object location to insert dataset into */
-    H5D_t	   *dset = NULL;        /* New dataset's info */
+    H5D_t          *dset = NULL;        /* New dataset's info */
     const H5S_t    *space;              /* Dataspace for dataset */
-    hid_t           ret_value;          /* Return value */
+    hid_t               ret_value   = H5I_INVALID_HID;  /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE5("i", "iiiii", loc_id, type_id, space_id, dcpl_id, dapl_id);
 
     /* Check arguments */
     if(H5G_loc(loc_id, &loc) < 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a location ID")
     if(H5I_DATATYPE != H5I_get_type(type_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a datatype ID")
     if(NULL == (space = (const H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace ID")
     if(H5P_DEFAULT == dcpl_id)
         dcpl_id = H5P_DATASET_CREATE_DEFAULT;
     else
         if(TRUE != H5P_isa_class(dcpl_id, H5P_DATASET_CREATE))
-            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not dataset create property list ID")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not dataset create property list ID")
 
     /* Verify access property list and set up collective metadata if appropriate */
     if(H5CX_set_apl(&dapl_id, H5P_CLS_DACC, loc_id, TRUE) < 0)
@@ -227,11 +227,11 @@ H5Dcreate_anon(hid_t loc_id, hid_t type_id, hid_t space_id, hid_t dcpl_id,
 
     /* build and open the new dataset */
     if(NULL == (dset = H5D__create(loc.oloc->file, type_id, space, dcpl_id, dapl_id)))
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to create dataset")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, H5I_INVALID_HID, "unable to create dataset")
 
     /* Register the new dataset to get an ID for it */
     if((ret_value = H5I_register(H5I_DATASET, dset, TRUE)) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register dataset")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register dataset")
 
 done:
     /* Release the dataset's object header, if it was created */
@@ -240,36 +240,34 @@ done:
 
         /* Get the new dataset's object location */
         if(NULL == (oloc = H5D_oloc(dset)))
-            HDONE_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to get object location of dataset")
+            HDONE_ERROR(H5E_DATASET, H5E_CANTGET, H5I_INVALID_HID, "unable to get object location of dataset")
 
         /* Decrement refcount on dataset's object header in memory */
         if(H5O_dec_rc_by_loc(oloc) < 0)
-           HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, FAIL, "unable to decrement refcount on newly created object")
-    } /* end if */
+           HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, H5I_INVALID_HID, "unable to decrement refcount on newly created object")
+    }
 
     /* Cleanup on failure */
-    if(ret_value < 0)
+    if(H5I_INVALID_HID == ret_value)
         if(dset && H5D_close(dset) < 0)
-            HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataset")
+            HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
 
     FUNC_LEAVE_API(ret_value)
 } /* end H5Dcreate_anon() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dopen2
+ * Function:    H5Dopen2
  *
- * Purpose:	Finds a dataset named NAME at LOC_ID, opens it, and returns
- *		its ID.	 The dataset should be close when the caller is no
- *		longer interested in it.
+ * Purpose:     Finds a dataset named NAME at LOC_ID, opens it, and returns
+ *              its ID. The dataset should be close when the caller is no
+ *              longer interested in it.
  *
  *              Takes a dataset access property list
  *
- * Return:	Success:	A new dataset ID
- *		Failure:	FAIL
+ * Return:      Success:    Object ID of the dataset
  *
- * Programmer:	James Laird
- *		Thursday, July 27, 2006
+ *              Failure:    H5I_INVALID_HID
  *
  *-------------------------------------------------------------------------
  */
@@ -278,16 +276,18 @@ H5Dopen2(hid_t loc_id, const char *name, hid_t dapl_id)
 {
     H5D_t       *dset = NULL;
     H5G_loc_t   loc;                    /* Object location of group */
-    hid_t       ret_value;
+    hid_t               ret_value   = H5I_INVALID_HID;  /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE3("i", "i*si", loc_id, name, dapl_id);
 
     /* Check args */
     if(H5G_loc(loc_id, &loc) < 0)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
-    if(!name || !*name)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a location")
+    if(!name)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "name parameter cannot be NULL")
+    if(!*name)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "name parameter cannot be an empty string")
 
     /* Verify access property list and set up collective metadata if appropriate */
     if(H5CX_set_apl(&dapl_id, H5P_CLS_DACC, loc_id, FALSE) < 0)
@@ -295,16 +295,16 @@ H5Dopen2(hid_t loc_id, const char *name, hid_t dapl_id)
 
     /* Open the dataset */
     if(NULL == (dset = H5D__open_name(&loc, name, dapl_id)))
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "unable to open dataset")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, H5I_INVALID_HID, "unable to open dataset")
 
     /* Register an atom for the dataset */
     if((ret_value = H5I_register(H5I_DATASET, dset, TRUE)) < 0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "can't register dataset atom")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, H5I_INVALID_HID, "can't register dataset atom")
 
 done:
-    if(ret_value < 0)
+    if(H5I_INVALID_HID == ret_value)
         if(dset && H5D_close(dset) < 0)
-            HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release dataset")
+            HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, H5I_INVALID_HID, "unable to release dataset")
 
     FUNC_LEAVE_API(ret_value)
 } /* end H5Dopen2() */
@@ -313,15 +313,12 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5Dclose
  *
- * Purpose:     Closes access to a dataset (DATASET_ID) and releases
- *              resources used by it. It is illegal to subsequently use that
- *              same dataset ID in calls to other dataset functions.
+ * Purpose:     Closes access to a dataset and releases resources used by
+ *              it. It is illegal to subsequently use that same dataset
+ *              ID in calls to other dataset functions.
  *
  * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:  Robb Matzke
- *              Thursday, December  4, 1997
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -334,10 +331,9 @@ H5Dclose(hid_t dset_id)
 
     /* Check args */
     if(NULL == H5I_object_verify(dset_id, H5I_DATASET))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset ID")
 
-    /*
-     * Decrement the counter on the dataset.  It will be freed if the count
+    /* Decrement the counter on the dataset.  It will be freed if the count
      * reaches zero.
      */
     if(H5I_dec_app_ref_always_close(dset_id) < 0)
@@ -349,36 +345,34 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dget_space
+ * Function:    H5Dget_space
  *
- * Purpose:	Returns a copy of the file dataspace for a dataset.
+ * Purpose:     Returns a copy of the file dataspace for a dataset.
  *
- * Return:	Success:	ID for a copy of the dataspace.  The data
- *				space should be released by calling
- *				H5Sclose().
+ * Return:      Success:    ID for a copy of the dataspace.  The data
+ *                          space should be released by calling
+ *                          H5Sclose().
  *
- *		Failure:	FAIL
- *
- * Programmer:	Robb Matzke
- *		Wednesday, January 28, 1998
+ *              Failure:    H5I_INVALID_HID
  *
  *-------------------------------------------------------------------------
  */
 hid_t
 H5Dget_space(hid_t dset_id)
 {
-    H5D_t	*dset = NULL;
-    hid_t	ret_value;
+    H5D_t           *dset = NULL;
+    hid_t           ret_value = H5I_INVALID_HID;    /* Return value         */
 
     FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE1("i", "i", dset_id);
 
     /* Check args */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "invalid dataset identifier")
 
+    /* Get the dataspace */
     if((ret_value = H5D__get_space(dset)) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, H5I_INVALID_HID, "unable to get dataspace")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, H5I_INVALID_HID, "unable to get dataspace")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -386,35 +380,30 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dget_space_status
- *
- * Purpose:	Returns the status of dataspace allocation.
- *
- * Return:
- *		Success:	Non-negative
+ * Function:    H5Dget_space_status
  *
- *		Failture:	Negative
+ * Purpose:     Returns the status of dataspace allocation.
  *
- * Programmer:	Raymond Lu
+ * Return:      Non-negative on success/Negative on failure
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Dget_space_status(hid_t dset_id, H5D_space_status_t *allocation)
 {
-    H5D_t 	*dset = NULL;
-    herr_t 	ret_value = SUCCEED;
+    H5D_t 	        *dset = NULL;
+    herr_t          ret_value = SUCCEED;            /* Return value         */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "i*Ds", dset_id, allocation);
 
-    /* Check arguments */
+    /* Check args */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid dataset identifier")
 
-    /* Read dataspace address and return */
+    /* Get dataspace status */
     if(H5D__get_space_status(dset, allocation) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get space status")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to get space status")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -422,18 +411,15 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dget_type
+ * Function:    H5Dget_type
  *
- * Purpose:	Returns a copy of the file datatype for a dataset.
+ * Purpose:     Returns a copy of the file datatype for a dataset.
  *
- * Return:	Success:	ID for a copy of the datatype.	 The data
- *				type should be released by calling
- *				H5Tclose().
+ * Return:      Success:    ID for a copy of the datatype. The data
+ *                          type should be released by calling
+ *                          H5Tclose().
  *
- *		Failure:	FAIL
- *
- * Programmer:	Robb Matzke
- *		Tuesday, February  3, 1998
+ *              Failure:    H5I_INVALID_HID
  *
  *-------------------------------------------------------------------------
  */
@@ -441,17 +427,18 @@ hid_t
 H5Dget_type(hid_t dset_id)
 {
     H5D_t	*dset;                  /* Dataset */
-    hid_t	ret_value;              /* Return value */
+    hid_t           ret_value = H5I_INVALID_HID;    /* Return value         */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE1("i", "i", dset_id);
 
     /* Check args */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "invalid dataset identifier")
 
+    /* Get the datatype */
     if((ret_value = H5D__get_type(dset)) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get dataspace")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, H5I_INVALID_HID, "unable to get datatype")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -459,18 +446,18 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dget_create_plist
+ * Function:    H5Dget_create_plist
  *
- * Purpose:	Returns a copy of the dataset creation property list.
+ * Purpose:     Returns a copy of the dataset creation property list.
  *
- * Return:	Success:	ID for a copy of the dataset creation
- *				property list.  The template should be
- *				released by calling H5P_close().
+ * Return:      Success:    ID for a copy of the dataset creation
+ *                          property list.  The template should be
+ *                          released by calling H5P_close().
  *
- *		Failure:	FAIL
+ *              Failure:    H5I_INVALID_HID
  *
- * Programmer:	Robb Matzke
- *		Tuesday, February  3, 1998
+ * Programmer:  Robb Matzke
+ *              Tuesday, February  3, 1998
  *
  *-------------------------------------------------------------------------
  */
@@ -478,17 +465,18 @@ hid_t
 H5Dget_create_plist(hid_t dset_id)
 {
     H5D_t	*dataset;               /* Dataset structure */
-    hid_t	ret_value;    		/* Return value */
+    hid_t           ret_value = H5I_INVALID_HID;    /* Return value         */
 
     FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE1("i", "i", dset_id);
 
     /* Check args */
     if(NULL == (dataset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "invalid dataset identifier")
 
+    /* Get the dataset creation property list */
     if((ret_value = H5D_get_create_plist(dataset)) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, H5I_INVALID_HID, "Can't get creation plist")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, H5I_INVALID_HID, "unable to get dataset creation properties")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -496,35 +484,35 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dget_access_plist
+ * Function:    H5Dget_access_plist
  *
- * Purpose:	Returns a copy of the dataset creation property list.
+ * Purpose:     Returns a copy of the dataset access property list.
  *
  * Description: H5Dget_access_plist returns the dataset access property
- *      list identifier of the specified dataset.
+ *              list identifier of the specified dataset.
  *
- *      The chunk cache parameters in the returned property lists will be
- *      those used by the dataset.  If the properties in the file access
- *      property list were used to determine the dataset’s chunk cache
- *      configuration, then those properties will be present in the
- *      returned dataset access property list.  If the dataset does not
- *      use a chunked layout, then the chunk cache properties will be set
- *      to the default.  The chunk cache properties in the returned list
- *      are considered to be “set”, and any use of this list will override
- *      the corresponding properties in the file’s file access property
- *      list.
+ *              The chunk cache parameters in the returned property lists will be
+ *              those used by the dataset.  If the properties in the file access
+ *              property list were used to determine the dataset’s chunk cache
+ *              configuration, then those properties will be present in the
+ *              returned dataset access property list.  If the dataset does not
+ *              use a chunked layout, then the chunk cache properties will be set
+ *              to the default.  The chunk cache properties in the returned list
+ *              are considered to be “set”, and any use of this list will override
+ *              the corresponding properties in the file’s file access property
+ *              list.
  *
- *      All link access properties in the returned list will be set to the
- *      default values.
+ *              All link access properties in the returned list will be set to the
+ *              default values.
  *
- * Return:	Success:	ID for a copy of the dataset access
- *				property list.  The template should be
- *				released by calling H5Pclose().
+ * Return:      Success:    ID for a copy of the dataset access
+ *                          property list.  The template should be
+ *                          released by calling H5Pclose().
  *
- *		Failure:	FAIL
+ *              Failure:    H5I_INVALID_HID
  *
- * Programmer:	Neil Fortner
- *		Wednesday, October 29, 2008
+ * Programmer:  Neil Fortner
+ *              Wednesday, October 29, 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -532,17 +520,18 @@ hid_t
 H5Dget_access_plist(hid_t dset_id)
 {
     H5D_t           *dset;          /* Dataset structure */
-    hid_t           ret_value;      /* Return value */
+    hid_t           ret_value = H5I_INVALID_HID;    /* Return value         */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE1("i", "i", dset_id);
 
     /* Check args */
-    if (NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+    if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "invalid dataset identifier")
 
+    /* Get the dataset access property list */
     if((ret_value = H5D_get_access_plist(dset)) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "Can't get access plist")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, H5I_INVALID_HID, "unable to get dataset access properties")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -550,20 +539,17 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dget_storage_size
- *
- * Purpose:	Returns the amount of storage that is required for the
- *		dataset. For chunked datasets this is the number of allocated
- *		chunks times the chunk size.
+ * Function:    H5Dget_storage_size
  *
- * Return:	Success:	The amount of storage space allocated for the
- *				dataset, not counting meta data. The return
- *				value may be zero if no data has been stored.
+ * Purpose:     Returns the amount of storage that is required for the
+ *              dataset. For chunked datasets this is the number of allocated
+ *              chunks times the chunk size.
  *
- *		Failure:	Zero
+ * Return:      Success:    The amount of storage space allocated for the
+ *                          dataset, not counting meta data. The return
+ *                          value may be zero if no data has been stored.
  *
- * Programmer:	Robb Matzke
- *              Wednesday, April 21, 1999
+ *              Failure:    Zero
  *
  *-------------------------------------------------------------------------
  */
@@ -571,18 +557,18 @@ hsize_t
 H5Dget_storage_size(hid_t dset_id)
 {
     H5D_t	*dset;          /* Dataset to query */
-    hsize_t	ret_value;      /* Return value */
+    hsize_t         ret_value = 0;                  /* Return value                 */
 
     FUNC_ENTER_API(0)
     H5TRACE1("h", "i", dset_id);
 
     /* Check args */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "invalid dataset identifier")
 
-    /* Set return value */
+    /* Get the storage size */
     if(H5D__get_storage_size(dset, &ret_value) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of dataset's storage")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "unable to get storage size")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -590,16 +576,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dget_offset
+ * Function:    H5Dget_offset
  *
- * Purpose:	Returns the address of dataset in file.
+ * Purpose:     Returns the address of dataset in file.
  *
- * Return:	Success:        the address of dataset
+ * Return:      Success:    The address of dataset
  *
- *		Failure:	HADDR_UNDEF
- *
- * Programmer:  Raymond Lu
- *              November 6, 2002
+ *              Failure:    HADDR_UNDEF (can also be a valid return value!)
  *
  *-------------------------------------------------------------------------
  */
@@ -607,7 +590,7 @@ haddr_t
 H5Dget_offset(hid_t dset_id)
 {
     H5D_t	*dset;          /* Dataset to query */
-    haddr_t	ret_value;      /* Return value */
+    haddr_t         ret_value = HADDR_UNDEF;        /* Return value                 */
 
     FUNC_ENTER_API(HADDR_UNDEF)
     H5TRACE1("a", "i", dset_id);
@@ -616,7 +599,7 @@ H5Dget_offset(hid_t dset_id)
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, HADDR_UNDEF, "not a dataset")
 
-    /* Set return value */
+    /* Get the offset */
     ret_value = H5D__get_offset(dset);
 
 done:
@@ -625,9 +608,9 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Diterate
+ * Function:    H5Diterate
  *
- * Purpose:	This routine iterates over all the elements selected in a memory
+ * Purpose: This routine iterates over all the elements selected in a memory
  *      buffer.  The callback function is called once for each element selected
  *      in the dataspace.  The selection in the dataspace is modified so
  *      that any elements already iterated over are removed from the selection
@@ -674,11 +657,11 @@ done:
  *              indicating failure. The iterator can be restarted at the next
  *              element.
  *
- * Return:	Returns the return value of the last operator if it was non-zero,
+ * Return:  Returns the return value of the last operator if it was non-zero,
  *          or zero if all elements were processed. Otherwise returns a
  *          negative value.
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Friday, June 11, 1999
  *
  *-------------------------------------------------------------------------
@@ -771,9 +754,9 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dvlen_get_buf_size
+ * Function:    H5Dvlen_get_buf_size
  *
- * Purpose:	This routine checks the number of bytes required to store the VL
+ * Purpose: This routine checks the number of bytes required to store the VL
  *      data from the dataset, using the space_id for the selection in the
  *      dataset on disk and the type_id for the memory representation of the
  *      VL data, in memory.  The *size value is modified according to how many
@@ -787,16 +770,15 @@ done:
  *      Kinda kludgy, but easier than the other method of trying to figure out
  *      the sizes without actually reading the data in... - QAK
  *
- * Return:	Non-negative on success, negative on failure
+ * Return:  Non-negative on success, negative on failure
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Wednesday, August 11, 1999
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Dvlen_get_buf_size(hid_t dataset_id, hid_t type_id, hid_t space_id,
-        hsize_t *size)
+H5Dvlen_get_buf_size(hid_t dataset_id, hid_t type_id, hid_t space_id, hsize_t *size)
 {
     H5D_vlen_bufsize_t vlen_bufsize = {0, 0, 0, 0, 0, 0};
     H5D_t *dset;                /* Dataset for operation */
@@ -816,7 +798,7 @@ H5Dvlen_get_buf_size(hid_t dataset_id, hid_t type_id, hid_t space_id,
             H5I_DATATYPE != H5I_get_type(type_id) || size == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid argument")
     if(NULL == (dset = (H5D_t *)H5I_object(dataset_id)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
     if(NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an valid base datatype")
     if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
@@ -872,20 +854,17 @@ done:
         vlen_bufsize.vl_tbuf = H5FL_BLK_FREE(vlen_vl_buf, vlen_bufsize.vl_tbuf);
 
     FUNC_LEAVE_API(ret_value)
-}   /* end H5Dvlen_get_buf_size() */
+} /* end H5Dvlen_get_buf_size() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dset_extent
+ * Function:    H5Dset_extent
  *
- * Purpose:	Modifies the dimensions of a dataset.
- *		Can change to a smaller dimension.
+ * Purpose:     Modifies the dimensions of a dataset.
+ *              Can change to a smaller dimension.
  *
  * Return:	Non-negative on success, negative on failure
  *
- * Programmer:  Pedro Vicente, pvn@ncsa.uiuc.edu
- *              April 9, 2002
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -899,17 +878,17 @@ H5Dset_extent(hid_t dset_id, const hsize_t size[])
 
     /* Check args */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "dset_id parameter is not a valid dataset identifier")
     if(!size)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no size specified")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size array cannot be NULL")
 
     /* Set up collective metadata if appropriate */
     if(H5CX_set_loc(dset_id) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set collective metadata read info")
 
-    /* Private function */
+    /* Set the extent */
     if(H5D__set_extent(dset, size) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to set extend dataset")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "unable to set dataset extent")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -923,9 +902,6 @@ done:
  *
  * Return:      Non-negative on success, negative on failure
  *
- * Programmer:  Mike McGreevy
- *              May 19, 2010
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -947,7 +923,7 @@ H5Dflush(hid_t dset_id)
 
     /* Flush dataset information cached in memory */
     if(H5D__flush(dset, dset_id) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTFLUSH, FAIL, "unable to flush cached dataset info")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTFLUSH, FAIL, "unable to flush dataset")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -961,29 +937,26 @@ done:
  *
  * Return:      Non-negative on success, negative on failure
  *
- * Programmer:  Mike McGreevy
- *              July 21, 2010
- *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Drefresh(hid_t dset_id)
 {
     H5D_t *dset;                   /* Dataset to refresh */
-    herr_t ret_value = SUCCEED;    /* return value */
+    herr_t          ret_value = SUCCEED;    /* Return value                 */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "i", dset_id);
 
     /* Check args */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "dset_id parameter is not a valid dataset identifier")
 
     /* Set up collective metadata if appropriate */
     if(H5CX_set_loc(dset_id) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set collective metadata read info")
 
-    /* Call private function to refresh the dataset object */
+    /* Refresh the dataset object */
     if((H5D__refresh(dset_id, dset)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTLOAD, FAIL, "unable to refresh dataset")
 
@@ -996,10 +969,11 @@ done:
  * Function:    H5Dformat_convert (Internal)
  *
  * Purpose:     For chunked:
- *		  Convert the chunk indexing type to version 1 B-tree if not
- *		For compact/contiguous:
- *		  Downgrade layout version to 3 if greater than 3
- *		For virtual: no conversion
+ *                  Convert the chunk indexing type to version 1 B-tree if not
+ *              For compact/contiguous:
+ *                  Downgrade layout version to 3 if greater than 3
+ *              For virtual:
+ *                  No conversion
  *
  * Return:      Non-negative on success, negative on failure
  *
@@ -1012,7 +986,7 @@ herr_t
 H5Dformat_convert(hid_t dset_id)
 {
     H5D_t *dset;                /* Dataset to refresh */
-    herr_t ret_value = SUCCEED; /* return value */
+    herr_t          ret_value = SUCCEED;    /* Return value                 */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "i", dset_id);
@@ -1112,23 +1086,23 @@ herr_t
 H5Dget_chunk_storage_size(hid_t dset_id, const hsize_t *offset, hsize_t *chunk_nbytes)
 {
     H5D_t       *dset = NULL;
-    herr_t      ret_value = SUCCEED;
+    herr_t          ret_value = SUCCEED;    /* Return value                 */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "i*h*h", dset_id, offset, chunk_nbytes);
 
     /* Check arguments */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
-    if( NULL == offset )
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid argument (null)")
-    if( NULL == chunk_nbytes )
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid argument (null)")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "dset_id parameter is not a valid dataset identifier")
+    if(NULL == offset)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "offset parameter cannot be NULL")
+    if(NULL == chunk_nbytes)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "chunk_nbytes parameter cannot be NULL")
 
     if(H5D_CHUNKED != dset->shared->layout.type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a chunked dataset")
 
-    /* Call private function */
+    /* Get the dataset creation property list */
     if(H5D__get_chunk_storage_size(dset, offset, chunk_nbytes) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get storage size of chunk")
 
@@ -1140,7 +1114,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5Dget_num_chunks
  *
- * Purpose:     Retrieves the number of chunks that have nonempty intersection
+ * Purpose:     Retrieves the number of chunks that have non-empty intersection
  *              with a specified selection.
  *
  * Note:        Currently, this function only gets the number of all written
@@ -1149,7 +1123,7 @@ done:
  * Parameters:
  *              hid_t dset_id;      IN: Chunked dataset ID
  *              hid_t fspace_id;    IN: File dataspace ID
- *              hsize_t *nchunks;   OUT:: Number of non-empty chunks
+ *              hsize_t *nchunks;   OUT: Number of non-empty chunks
  *
  * Return:      Non-negative on success, negative on failure
  *
@@ -1163,16 +1137,16 @@ H5Dget_num_chunks(hid_t dset_id, hid_t fspace_id, hsize_t *nchunks)
 {
     H5D_t       *dset = NULL;
     const H5S_t *space;              /* Dataspace for dataset */
-    herr_t      ret_value = SUCCEED;
+    herr_t          ret_value = SUCCEED;
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "ii*h", dset_id, fspace_id, nchunks);
 
     /* Check arguments */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid dataset identifier")
     if(NULL == (space = (const H5S_t *)H5I_object_verify(fspace_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid dataspace identifier")
     if(NULL == nchunks)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid argument (null)")
 
@@ -1181,7 +1155,7 @@ H5Dget_num_chunks(hid_t dset_id, hid_t fspace_id, hsize_t *nchunks)
 
     /* Get the number of written chunks */
     if(H5D__get_num_chunks(dset, space, nchunks) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error getting number of chunks")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "Can't get number of chunks")
 
 done:
     FUNC_LEAVE_API(ret_value);
@@ -1196,9 +1170,10 @@ done:
  * Parameters:
  *              hid_t dset_id;          IN: Chunked dataset ID
  *              hid_t fspace_id;        IN: File dataspace ID
- *              hsize_t chk_idx;        IN: Index of allocated/written chunk
- *              hsize_t *offset         OUT: Offset coordinates of the chunk
- *              unsigned *filter_mask   OUT: Filter mask
+ *              hsize_t index;          IN: Index of written chunk
+ *              hsize_t *offset         OUT: Logical position of the chunk’s
+ *                                           first element in the dataspace
+ *              unsigned *filter_mask   OUT: Mask for identifying the filters in use
  *              haddr_t *addr           OUT: Address of the chunk
  *              hsize_t *size           OUT: Size of the chunk
  *
@@ -1210,15 +1185,15 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Dget_chunk_info(hid_t dset_id, hid_t fspace_id, hsize_t chk_idx, hsize_t *offset, unsigned *filter_mask, haddr_t *addr, hsize_t *size)
+H5Dget_chunk_info(hid_t dset_id, hid_t fspace_id, hsize_t chk_index, hsize_t *offset, unsigned *filter_mask, haddr_t *addr, hsize_t *size)
 {
     H5D_t       *dset = NULL;
     const H5S_t *space;              /* Dataspace for dataset */
-    herr_t      ret_value = SUCCEED;
+    herr_t         ret_value = SUCCEED;
 
     FUNC_ENTER_API(FAIL)
-    H5TRACE7("e", "iih*h*Iu*a*h", dset_id, fspace_id, chk_idx, offset, filter_mask,
-             addr, size);
+    H5TRACE7("e", "iih*h*Iu*a*h", dset_id, fspace_id, chk_index, offset,
+             filter_mask, addr, size);
 
     /* Check arguments */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
@@ -1232,8 +1207,8 @@ H5Dget_chunk_info(hid_t dset_id, hid_t fspace_id, hsize_t chk_idx, hsize_t *offs
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a chunked dataset")
 
     /* Call private function to get the chunk info given the chunk's index */
-    if(H5D__get_chunk_info(dset, space, chk_idx, offset, filter_mask, addr, size) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info")
+    if(H5D__get_chunk_info(dset, space, chk_index, offset, filter_mask, addr, size) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "Can't get chunk info by index")
 
 done:
     FUNC_LEAVE_API(ret_value);
@@ -1243,13 +1218,14 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5Dget_chunk_info_by_coord
  *
- * Purpose:     Retrieves information about a chunk specified by its offset
+ * Purpose:     Retrieves information about a chunk specified by its logical
  *              coordinates.
  *
  * Parameters:
- *              hid_t dset_id           IN: Chunked dataset ID
- *              hsize_t *offset         IN: Offset coordinates of the chunk
- *              unsigned *filter_mask   OUT: Filter mask
+ *              hid_t dset_id;          IN: Chunked dataset ID
+ *              hsize_t *offset         IN: Logical position of the chunk’s
+ *                                           first element in the dataspace
+ *              unsigned *filter_mask   OUT: Mask for identifying the filters in use
  *              haddr_t *addr           OUT: Address of the chunk
  *              hsize_t *size           OUT: Size of the chunk
  *
diff --git a/src/H5T.c b/src/H5T.c
index b4015ff..b472269 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -28,24 +28,19 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"      /* Generic Functions        */
-#include "H5ACprivate.h"    /* Metadata cache           */
-#include "H5CXprivate.h"    /* API Contexts             */
-#include "H5Dprivate.h"     /* Datasets                 */
-#include "H5Eprivate.h"     /* Error handling           */
-#include "H5Fprivate.h"     /* Files                    */
-#include "H5FLprivate.h"    /* Free Lists               */
-#include "H5FOprivate.h"    /* File objects             */
-#include "H5Gprivate.h"     /* Groups                   */
-#include "H5Iprivate.h"     /* IDs                      */
-#include "H5MMprivate.h"    /* Memory management        */
-#include "H5Pprivate.h"     /* Property lists           */
-#include "H5Tpkg.h"         /* Datatypes                */
-
-/* Check for header needed for SGI floating-point code */
-#ifdef H5_HAVE_SYS_FPU_H
-#include <sys/fpu.h>
-#endif /* H5_HAVE_SYS_FPU_H */
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5ACprivate.h"        /* Metadata cache                           */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Dprivate.h"         /* Datasets                                 */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5Fprivate.h"         /* Files                                    */
+#include "H5FLprivate.h"        /* Free Lists                               */
+#include "H5FOprivate.h"        /* File objects                             */
+#include "H5Gprivate.h"         /* Groups                                   */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
+#include "H5Pprivate.h"         /* Property lists                           */
+#include "H5Tpkg.h"             /* Datatypes                                */
 
 
 /****************/
@@ -1633,15 +1628,15 @@ H5Tcreate(H5T_class_t type, size_t size)
 
     /* check args. We support string (fixed-size or variable-length) now. */
     if(size <= 0 && size != H5T_VARIABLE)
-    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size must be positive")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size must be positive")
 
     /* create the type */
     if(NULL == (dt = H5T__create(type, size)))
-    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to create type")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to create type")
 
     /* Get an ID for the datatype */
     if((ret_value = H5I_register(H5I_DATATYPE, dt, TRUE)) < 0)
-    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register datatype ID")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register datatype ID")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1651,55 +1646,51 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5Tcopy
  *
- * Purpose:    Copies a datatype.  The resulting datatype is not locked.
- *        The datatype should be closed when no longer needed by
- *        calling H5Tclose().
+ * Purpose:     Copies a datatype.  The resulting datatype is not locked.
+ *              The datatype should be closed when no longer needed by
+ *              calling H5Tclose().
  *
- * Return:    Success:    The ID of a new datatype.
+ * Return:      Success:    The ID of a new datatype
  *
- *            Failure:    Negative
+ *              Failure:    H5I_INVALID_HID
  *
- * Programmer:    Robb Matzke
- *        Tuesday, December  9, 1997
- *
- * Modifications:
- *
- *     Robb Matzke, 4 Jun 1998
- *    The returned type is always transient and unlocked.  If the TYPE_ID
- *    argument is a dataset instead of a datatype then this function
- *    returns a transient, modifiable datatype which is a copy of the
- *    dataset's datatype.
+ * Note:        The returned type is always transient and unlocked. If the
+ *              TYPE_ID argument is a dataset instead of a datatype then
+ *              this function returns a transient, modifiable datatype
+ *              which is a copy of the dataset's datatype.
  *
  *-------------------------------------------------------------------------
  */
 hid_t
-H5Tcopy(hid_t type_id)
+H5Tcopy(hid_t obj_id)
 {
-    H5T_t    *dt;                    /* Pointer to the datatype to copy */
-    H5T_t    *new_dt = NULL;
-    hid_t    ret_value;              /* Return value */
+    H5T_t  *dt          = NULL;     /* Pointer to the datatype to copy */
+    H5T_t  *new_dt      = NULL;     /* Pointer to the new datatype */
+    hid_t   ret_value   = H5I_INVALID_HID;  /* Return value */
 
     FUNC_ENTER_API(H5I_INVALID_HID)
-    H5TRACE1("i", "i", type_id);
+    H5TRACE1("i", "i", obj_id);
 
-    switch(H5I_get_type(type_id)) {
+    switch(H5I_get_type(obj_id)) {
         case H5I_DATATYPE:
             /* The argument is a datatype handle */
-            if(NULL == (dt = (H5T_t *)H5I_object(type_id)))
-                HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a datatype")
+            if(NULL == (dt = (H5T_t *)H5I_object(obj_id)))
+                HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "obj_id is not a datatype ID")
             break;
 
         case H5I_DATASET:
-            {
-                H5D_t    *dset;          /* Dataset for datatype */
+        {
+            H5D_t    *dset;          /* Dataset structure */
 
-                /* The argument is a dataset handle */
-                if(NULL == (dset = (H5D_t *)H5I_object(type_id)))
-                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataset")
-                if(NULL == (dt = H5D_typeof(dset)))
-                    HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, H5I_INVALID_HID, "unable to get the dataset datatype")
-            }
-            break;
+            /* The argument is a dataset handle */
+            if(NULL == (dset = (H5D_t *)H5I_object(obj_id)))
+                HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataset")
+
+            /* Get the datatype from the dataset */
+            if(NULL == (dt = H5D_typeof(dset)))
+                HGOTO_ERROR(H5E_DATATYPE, H5E_CANTGET, H5I_INVALID_HID, "unable to get the dataset datatype")
+        }
+        break;
 
         case H5I_UNINIT:
         case H5I_BADID:
@@ -1723,12 +1714,13 @@ H5Tcopy(hid_t type_id)
     if(NULL == (new_dt = H5T_copy(dt, H5T_COPY_TRANSIENT)))
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, H5I_INVALID_HID, "unable to copy");
 
-    /* Atomize result */
+    /* Get an ID for the copied datatype */
     if((ret_value = H5I_register(H5I_DATATYPE, new_dt, TRUE)) < 0)
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register datatype atom")
 
 done:
-    if(ret_value < 0)
+    /* Close the new datatype on errors */
+    if(H5I_INVALID_HID == ret_value)
         if(new_dt && H5T_close_real(new_dt) < 0)
             HDONE_ERROR(H5E_DATATYPE, H5E_CANTRELEASE, H5I_INVALID_HID, "unable to release datatype info")
 
@@ -1842,9 +1834,9 @@ H5Tlock(hid_t type_id)
     H5TRACE1("e", "i", type_id);
 
     /* Check args */
-    if(NULL == (dt = (H5T_t *)H5I_object_verify(type_id,H5I_DATATYPE)))
+    if(NULL == (dt = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
-    if(H5T_STATE_NAMED==dt->shared->state || H5T_STATE_OPEN==dt->shared->state)
+    if(H5T_STATE_NAMED == dt->shared->state || H5T_STATE_OPEN == dt->shared->state)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to lock named datatype")
 
     if(H5T_lock(dt, TRUE) < 0)
@@ -1979,15 +1971,6 @@ done:
  * Programmer:    Quincey Koziol
  *        Wednesday, November 29, 2000
  *
- * Modifications:
- *              Raymond Lu
- *              4 December 2009
- *              Added a flag as a parameter to indicate whether the caller is
- *              H5Tdetect_class.  I also added the check for VL string type
- *              just like the public function.  Because we want to tell users
- *              VL string is a string type but we treat it as a VL type
- *              internally, H5T_detect_class needs to know where the caller
- *              is from.
  *-------------------------------------------------------------------------
  */
 htri_t
@@ -2220,7 +2203,7 @@ H5Tget_super(hid_t type)
 {
     H5T_t    *dt;            /* Datatype to query */
     H5T_t    *super = NULL;  /* Supertype */
-    hid_t    ret_value;      /* Return value */
+    hid_t    ret_value = H5I_INVALID_HID;      /* Return value */
 
     FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE1("i", "i", type);
@@ -2233,7 +2216,7 @@ H5Tget_super(hid_t type)
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register parent datatype")
 
 done:
-    if(ret_value < 0)
+    if(H5I_INVALID_HID == ret_value)
         if(super && H5T_close_real(super) < 0)
             HDONE_ERROR(H5E_DATATYPE, H5E_CANTRELEASE, H5I_INVALID_HID, "unable to release super datatype info")
 
@@ -2249,30 +2232,30 @@ done:
  *            the return value is an integer type.
  *
  * Return:    Success:    Data type for base data type.
- *
  *            Failure:        NULL
  *
  * Programmer:    Raymond Lu
- *              October 9, 2002
+ *                October 9, 2002
+ *
  *-------------------------------------------------------------------------
  */
 H5T_t *
 H5T_get_super(const H5T_t *dt)
 {
-    H5T_t    *ret_value=NULL;
+    H5T_t *ret_value = NULL;
 
     FUNC_ENTER_NOAPI(NULL)
 
     HDassert(dt);
 
-    if (!dt->shared->parent)
+    if(!dt->shared->parent)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "not a derived data type");
-    if (NULL==(ret_value=H5T_copy(dt->shared->parent, H5T_COPY_ALL)))
+    if(NULL == (ret_value = H5T_copy(dt->shared->parent, H5T_COPY_ALL)))
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "unable to copy parent data type");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5T_get_super() */
 
 
 /*-------------------------------------------------------------------------
@@ -2296,7 +2279,7 @@ H5T__register_int(H5T_pers_t pers, const char *name, H5T_t *src, H5T_t *dst,
     FUNC_ENTER_STATIC
 
     /* Check args */
-    HDassert(H5T_PERS_HARD==pers || H5T_PERS_SOFT==pers);
+    HDassert(H5T_PERS_HARD == pers || H5T_PERS_SOFT == pers);
     HDassert(name && *name);
     HDassert(src);
     HDassert(dst);
@@ -2361,8 +2344,7 @@ H5T__register(H5T_pers_t pers, const char *name, H5T_t *src, H5T_t *dst,
             if(NULL == (new_path = H5T__path_find_real(src, dst, name, conv)))
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to locate/allocate conversion path")
 
-            /*
-             * Notify all other functions to recalculate private data since some
+            /* Notify all other functions to recalculate private data since some
              * functions might cache a list of conversion functions.  For
              * instance, the compound type converter caches a list of conversion
              * functions for the members, so adding a new function should cause
@@ -2452,7 +2434,7 @@ H5T__register(H5T_pers_t pers, const char *name, H5T_t *src, H5T_t *dst,
                 if((old_path->conv.u.app_func)(tmp_sid, tmp_did, &(old_path->cdata), (size_t)0, (size_t)0, (size_t)0, NULL, NULL, H5CX_get_dxpl()) < 0) {
 #ifdef H5T_DEBUG
                     if(H5DEBUG(T))
-                        HDfprintf (H5DEBUG(T), "H5T: conversion function 0x%08lx "
+                        HDfprintf(H5DEBUG(T), "H5T: conversion function 0x%08lx "
                             "failed to free private data for %s (ignored)\n",
                             (unsigned long)(old_path->conv.u.app_func), old_path->name);
 #endif
@@ -3158,7 +3140,7 @@ H5T__create(H5T_class_t type, size_t size)
         case H5T_REFERENCE:
         case H5T_NCLASSES:
         default:
-            HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, NULL, "unknown data type class")
+            HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, NULL, "unknown data type class")
     } /* end switch */
 
     /* Set the size except VL string */
@@ -3173,13 +3155,13 @@ done:
         if(dt) {
             dt->shared = H5FL_FREE(H5T_shared_t, dt->shared);
             dt = H5FL_FREE(H5T_t, dt);
-        } /* end if */
-    } /* end if */
+        }
+    }
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5T__create() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:  H5T__initiate_copy
  *
@@ -3223,12 +3205,12 @@ done:
             if(new_dt->shared)
                 new_dt->shared = H5FL_FREE(H5T_shared_t, new_dt->shared);
             new_dt = H5FL_FREE(H5T_t, new_dt);
-        }
+        } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5T__initiate_copy() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:  H5T__copy_transient
  *
@@ -3257,7 +3239,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5T__copy_transient() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:  H5T__copy_all
  *
@@ -3286,7 +3268,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5T__copy_transient() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:  H5T__complete_copy
  *
@@ -3475,7 +3457,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5T__complete_copy() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:  H5T_copy
  *
@@ -3483,7 +3465,6 @@ done:
  *            locked and is a transient type.
  *
  * Return:    Success:    Pointer to a new copy of the OLD_DT argument.
- *
  *            Failure:    NULL
  *
  * Programmer:    Robb Matzke
@@ -3551,7 +3532,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5T_copy() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:  H5T_copy_reopen
  *
@@ -3653,7 +3634,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5T_copy_reopen() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:  H5T_lock
  *
@@ -3671,9 +3652,9 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5T_lock (H5T_t *dt, hbool_t immutable)
+H5T_lock(H5T_t *dt, hbool_t immutable)
 {
-    herr_t ret_value=SUCCEED;   /* Return value */
+    herr_t ret_value = SUCCEED;   /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -3684,7 +3665,8 @@ H5T_lock (H5T_t *dt, hbool_t immutable)
             dt->shared->state = immutable ? H5T_STATE_IMMUTABLE : H5T_STATE_RDONLY;
             break;
         case H5T_STATE_RDONLY:
-            if (immutable) dt->shared->state = H5T_STATE_IMMUTABLE;
+            if(immutable)
+                dt->shared->state = H5T_STATE_IMMUTABLE;
             break;
         case H5T_STATE_IMMUTABLE:
         case H5T_STATE_NAMED:
@@ -3774,10 +3756,8 @@ H5T__free(H5T_t *dt)
     /* Free the ID to name info */
     H5G_name_free(&(dt->path));
 
-    /*
-     * Don't free locked datatypes.
-     */
-    if(H5T_STATE_IMMUTABLE==dt->shared->state)
+    /* Don't free locked datatypes */
+    if(H5T_STATE_IMMUTABLE == dt->shared->state)
         HGOTO_ERROR(H5E_DATATYPE, H5E_CLOSEERROR, FAIL, "unable to close immutable datatype")
 
     /* Close the datatype */
@@ -3786,7 +3766,7 @@ H5T__free(H5T_t *dt)
             for(i = 0; i < dt->shared->u.compnd.nmembs; i++) {
                 dt->shared->u.compnd.memb[i].name = (char *)H5MM_xfree(dt->shared->u.compnd.memb[i].name);
                 (void)H5T_close_real(dt->shared->u.compnd.memb[i].type);
-            } /* end for */
+            }
             dt->shared->u.compnd.memb = (H5T_cmemb_t *)H5MM_xfree(dt->shared->u.compnd.memb);
             dt->shared->u.compnd.nmembs = 0;
             break;
@@ -3834,7 +3814,7 @@ done:
  *
  * Purpose:   Frees a datatype and all associated memory.
  *
- * Hote:      Does _not_ deal with open hamed datatypes, etc.
+ * Note:      Does _not_ deal with open named datatypes, etc.
  *
  * Return:    Non-negative on success/Negative on failure
  *
@@ -3902,12 +3882,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:  H5T_close
+ * Function:    H5T_close
  *
- * Purpose:   Frees a data type and all associated memory.  Deals with
- *            open named datatypes appropriately.
+ * Purpose:     Frees a data type and all associated memory.  Deals with
+ *              open named datatypes appropriately.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  * Programmer:  Robb Matzke
  *              Monday, December  8, 1997
@@ -3922,7 +3902,8 @@ H5T_close(H5T_t *dt)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity check */
-    HDassert(dt && dt->shared);
+    HDassert(dt);
+    HDassert(dt->shared);
 
     /* Named datatype cleanups */
     if(dt->shared->state == H5T_STATE_OPEN) {
@@ -3934,8 +3915,7 @@ H5T_close(H5T_t *dt)
         HDassert(H5F_addr_defined(dt->sh_loc.u.loc.oh_addr));
         HDassert(H5F_addr_defined(dt->oloc.addr));
 
-        /*
-         * If a named type is being closed then close the object header and
+        /* If a named type is being closed then close the object header and
          * remove from the list of open objects in the file.
          */
 
@@ -4035,7 +4015,7 @@ H5T__set_size(H5T_t *dt, size_t size)
             dt->shared->size = dt->shared->parent->shared->size * dt->shared->u.array.nelem;
         else if(dt->shared->type!=H5T_VLEN)
             dt->shared->size = dt->shared->parent->shared->size;
-    } /* end if */
+    }
     else {
         if (H5T_IS_ATOMIC(dt->shared)) {
             offset = dt->shared->u.atomic.offset;
@@ -4049,7 +4029,7 @@ H5T__set_size(H5T_t *dt, size_t size)
                     offset = 8 * size - prec;
             if (prec > 8*size)
                 prec = 8 * size;
-        } /* end if */
+        }
         else
             prec = offset = 0;
 
@@ -4147,7 +4127,7 @@ H5T__set_size(H5T_t *dt, size_t size)
                         dt->shared->u.atomic.u.f.epos + dt->shared->u.atomic.u.f.esize > prec+offset ||
                         dt->shared->u.atomic.u.f.mpos + dt->shared->u.atomic.u.f.msize > prec+offset) {
                     HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "adjust sign, mantissa, and exponent fields first");
-                } /* end if */
+                }
                 break;
 
             case H5T_ENUM:
@@ -4173,7 +4153,7 @@ H5T__set_size(H5T_t *dt, size_t size)
             if (H5T_IS_ATOMIC(dt->shared)) {
                 dt->shared->u.atomic.offset = offset;
                 dt->shared->u.atomic.prec = prec;
-            } /* end if */
+            }
         } /* end if */
 
         /* Check if the new compound type is packed */
@@ -4211,7 +4191,7 @@ H5T_get_size(const H5T_t *dt)
     HDassert(dt);
 
     FUNC_LEAVE_NOAPI(dt->shared->size)
-}
+} /* end H5T_get_size() */
 
 
 /*-------------------------------------------------------------------------
@@ -4796,8 +4776,7 @@ H5T__path_find_real(const H5T_t *src, const H5T_t *dst, const char *name,
         H5T_g.npaths = 1;
     } /* end if */
 
-    /*
-     * Find the conversion path.  If source and destination types are equal
+    /* Find the conversion path.  If source and destination types are equal
      * then use entry[0], otherwise do a binary search over the
      * remaining entries.
      *
@@ -4836,8 +4815,7 @@ H5T__path_find_real(const H5T_t *src, const H5T_t *dst, const char *name,
      */
     old_npaths = H5T_g.npaths;
 
-    /*
-     * If we didn't find the path, if the caller is an API function specifying
+    /* If we didn't find the path, if the caller is an API function specifying
      * a new hard conversion function, or if the caller is a private function
      * specifying a new hard conversion and the path is a soft conversion, then
      * create a new path and add the new function to the path.
@@ -4859,8 +4837,7 @@ H5T__path_find_real(const H5T_t *src, const H5T_t *dst, const char *name,
     else
         path = table;
 
-    /*
-     * If a hard conversion function is specified and none is defined for the
+    /* If a hard conversion function is specified and none is defined for the
      * path, or the caller is an API function, or the caller is a private function but
      * the existing path is a soft function, then add the new conversion to the path
      * and initialize its conversion data.
@@ -5201,7 +5178,7 @@ H5T_convert(H5T_path_t *tpath, hid_t src_id, hid_t dst_id, size_t nelmts,
         H5_timer_end(&(tpath->stats.timer), &timer);
         tpath->stats.ncalls++;
         tpath->stats.nelmts += nelmts;
-    } /* end if */
+    }
 #endif
 
 done:
@@ -5323,14 +5300,10 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5T_is_named
  *
- * Purpose:     Check if a datatype is named.
- *
- * Return:      TRUE
+ * Purpose:     Check if a datatype is named/committed.
  *
- *              FALSE
+ * Return:      TRUE/FALSE/FAIL
  *
- * Programmer:  Pedro Vicente
- *              Tuesday, Sep 3, 2002
  *-------------------------------------------------------------------------
  */
 htri_t
@@ -5342,8 +5315,7 @@ H5T_is_named(const H5T_t *dt)
 
     HDassert(dt);
 
-    if(dt->shared->state == H5T_STATE_OPEN || dt->shared->state == H5T_STATE_NAMED)
-        ret_value = TRUE;
+    ret_value = (H5T_STATE_OPEN == dt->shared->state || H5T_STATE_NAMED == dt->shared->state);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -5966,7 +5938,7 @@ done:
  * Function:    H5T_patch_vlen_file
  *
  * Purpose:     Patch the top-level file pointer contained in (dt->shared->u.vlen.f)
- *              to point to f.  This is possible because
+ *              to point to file.  This is possible because
  *              the top-level file pointer can be closed out from under
  *              dt while dt is contained in the shared file's cache.
  *
@@ -5975,17 +5947,17 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5T_patch_vlen_file(H5T_t *dt, H5F_t *f)
+H5T_patch_vlen_file(H5T_t *dt, H5F_t *file)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Sanity check */
     HDassert(dt);
     HDassert(dt->shared);
-    HDassert(f);
+    HDassert(file);
 
-    if((dt->shared->type == H5T_VLEN) && dt->shared->u.vlen.f != f)
-        dt->shared->u.vlen.f = f;
+    if((dt->shared->type == H5T_VLEN) && dt->shared->u.vlen.f != file)
+        dt->shared->u.vlen.f = file;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5T_patch_vlen_file() */