[svn-r30118] Sync with trunk.

1 files changed, 451 insertions, 385 deletions

diff --git a/src/H5Znbit.c b/src/H5Znbit.c
index e2fb300..04e8869 100644
--- a/src/H5Znbit.c
+++ b/src/H5Znbit.c
@@ -29,10 +29,10 @@
  * one nbit atomic datatype: integer or floating-point
  */
 typedef struct {
-   size_t size;   /* size of datatype */
-   int order;     /* datatype endianness order */
-   int precision; /* datatype precision */
-   int offset;    /* datatype offset */
+   unsigned size;         /* size of datatype */
+   unsigned order;      /* datatype endianness order */
+   unsigned precision;  /* datatype precision */
+   unsigned offset;     /* datatype offset */
 } parms_atomic;
 
 /* Local function prototypes */
@@ -41,41 +41,50 @@ static herr_t H5Z_set_local_nbit(hid_t dcpl_id, hid_t type_id, hid_t space_id);
 static size_t H5Z_filter_nbit(unsigned flags, size_t cd_nelmts, const unsigned cd_values[],
                               size_t nbytes, size_t *buf_size, void **buf);
 
-static void H5Z_calc_parms_nooptype(void);
-static void H5Z_calc_parms_atomic(void);
-static herr_t H5Z_calc_parms_array(const H5T_t *type);
-static herr_t H5Z_calc_parms_compound(const H5T_t *type);
-
-static herr_t H5Z_set_parms_nooptype(const H5T_t *type, unsigned cd_values[]);
-static herr_t H5Z_set_parms_atomic(const H5T_t *type, unsigned cd_values[]);
-static herr_t H5Z_set_parms_array(const H5T_t *type, unsigned cd_values[]);
-static herr_t H5Z_set_parms_compound(const H5T_t *type, unsigned cd_values[]);
-
-static void H5Z_nbit_next_byte(size_t *j, int *buf_len);
-static void H5Z_nbit_decompress_one_byte(unsigned char *data, size_t data_offset, int k, int begin_i,
-int end_i, unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p, int datatype_len);
-static void H5Z_nbit_compress_one_byte(unsigned char *data, size_t data_offset, int k, int begin_i,
-int end_i, unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p, int datatype_len);
+static void H5Z_calc_parms_nooptype(size_t *cd_values_actual_nparms);
+static void H5Z_calc_parms_atomic(size_t *cd_values_actual_nparms);
+static herr_t H5Z_calc_parms_array(const H5T_t *type, size_t *cd_values_actual_nparms);
+static herr_t H5Z_calc_parms_compound(const H5T_t *type, size_t *cd_values_actual_nparms);
+
+static herr_t H5Z_set_parms_nooptype(const H5T_t *type, unsigned *cd_values_index,
+    unsigned cd_values[]);
+static herr_t H5Z_set_parms_atomic(const H5T_t *type, unsigned *cd_values_index,
+    unsigned cd_values[], hbool_t *need_not_compress);
+static herr_t H5Z_set_parms_array(const H5T_t *type, unsigned *cd_values_index,
+    unsigned cd_values[], hbool_t *need_not_compress);
+static herr_t H5Z_set_parms_compound(const H5T_t *type, unsigned *cd_values_index,
+    unsigned cd_values[], hbool_t *need_not_compress);
+
+static void H5Z_nbit_next_byte(size_t *j, size_t *buf_len);
+static void H5Z_nbit_decompress_one_byte(unsigned char *data, size_t data_offset,
+    unsigned k, unsigned begin_i, unsigned end_i, unsigned char *buffer, size_t *j,
+    size_t *buf_len, const parms_atomic *p, size_t datatype_len);
+static void H5Z_nbit_compress_one_byte(unsigned char *data, size_t data_offset, unsigned k, unsigned begin_i,
+    unsigned end_i, unsigned char *buffer, size_t *j, size_t *buf_len, const parms_atomic *p, size_t datatype_len);
 static void H5Z_nbit_decompress_one_nooptype(unsigned char *data, size_t data_offset,
-                       unsigned char *buffer, size_t *j, int *buf_len, unsigned size);
+    unsigned char *buffer, size_t *j, size_t *buf_len, unsigned size);
 static void H5Z_nbit_decompress_one_atomic(unsigned char *data, size_t data_offset,
-                    unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p);
+    unsigned char *buffer, size_t *j, size_t *buf_len, const parms_atomic *p);
 static void H5Z_nbit_decompress_one_array(unsigned char *data, size_t data_offset,
-           unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[]);
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index);
 static void H5Z_nbit_decompress_one_compound(unsigned char *data, size_t data_offset,
-              unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[]);
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index);
 static void H5Z_nbit_decompress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
-                                const unsigned parms[]);
+    const unsigned parms[]);
 static void H5Z_nbit_compress_one_nooptype(unsigned char *data, size_t data_offset,
-                     unsigned char *buffer, size_t *j, int *buf_len, unsigned size);
+    unsigned char *buffer, size_t *j, size_t *buf_len, unsigned size);
 static void H5Z_nbit_compress_one_atomic(unsigned char *data, size_t data_offset,
-                  unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p);
+    unsigned char *buffer, size_t *j, size_t *buf_len, const parms_atomic *p);
 static void H5Z_nbit_compress_one_array(unsigned char *data, size_t data_offset,
-         unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[]);
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index);
 static void H5Z_nbit_compress_one_compound(unsigned char *data, size_t data_offset,
-            unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[]);
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index);
 static void H5Z_nbit_compress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
-                              size_t *buffer_size, const unsigned parms[]);
+    size_t *buffer_size, const unsigned parms[]);
 
 /* This message derives from H5Z */
 H5Z_class2_t H5Z_NBIT[1] = {{
@@ -99,16 +108,6 @@ H5Z_class2_t H5Z_NBIT[1] = {{
 #define H5Z_NBIT_ORDER_BE        1     /* Big endian for datatype byte order */
 
 /* Local variables */
-/*
- * cd_values_index: index of array cd_values inside function H5Z_set_local_nbit
- * cd_values_actual_nparms: number of parameters in array cd_values[]
- * need_not_compress: flag if TRUE indicating no need to do nbit compression
- * parms_index: index of array parms used by compression/decompression functions
- */
-static unsigned cd_values_index = 0;
-static size_t cd_values_actual_nparms = 0;
-static unsigned char need_not_compress = FALSE;
-static unsigned parms_index = 0;
 
 
 /*-------------------------------------------------------------------------
@@ -166,13 +165,14 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static void H5Z_calc_parms_nooptype(void)
+static void
+H5Z_calc_parms_nooptype(size_t *cd_values_actual_nparms)
 {
     /* Store datatype class code */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Store datatype size */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 }
 
 
@@ -190,22 +190,23 @@ static void H5Z_calc_parms_nooptype(void)
  *
  *-------------------------------------------------------------------------
  */
-static void H5Z_calc_parms_atomic(void)
+static void
+H5Z_calc_parms_atomic(size_t *cd_values_actual_nparms)
 {
     /* Store datatype class code */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Store datatype size */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Store datatype endianness */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Store datatype's precision */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Store datatype's offset */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 }
 
 
@@ -227,7 +228,7 @@ static void H5Z_calc_parms_atomic(void)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_calc_parms_array(const H5T_t *type)
+H5Z_calc_parms_array(const H5T_t *type, size_t *cd_values_actual_nparms)
 {
     H5T_t *dtype_base = NULL;      /* Array datatype's base datatype */
     H5T_class_t dtype_base_class;  /* Array datatype's base datatype's class */
@@ -236,10 +237,10 @@ H5Z_calc_parms_array(const H5T_t *type)
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Store datatype class code */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Store array datatype's size */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Get array datatype's base datatype */
     if(NULL == (dtype_base = H5T_get_super(type)))
@@ -253,16 +254,16 @@ H5Z_calc_parms_array(const H5T_t *type)
     switch(dtype_base_class) {
         case H5T_INTEGER:
         case H5T_FLOAT:
-            H5Z_calc_parms_atomic();
+            H5Z_calc_parms_atomic(cd_values_actual_nparms);
             break;
 
         case H5T_ARRAY:
-            if(H5Z_calc_parms_array(dtype_base) == FAIL)
+            if(H5Z_calc_parms_array(dtype_base, cd_values_actual_nparms) == FAIL)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot compute parameters for datatype")
             break;
 
         case H5T_COMPOUND:
-            if(H5Z_calc_parms_compound(dtype_base) == FAIL)
+            if(H5Z_calc_parms_compound(dtype_base, cd_values_actual_nparms) == FAIL)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot compute parameters for datatype")
             break;
 
@@ -274,7 +275,7 @@ H5Z_calc_parms_array(const H5T_t *type)
         case H5T_ENUM:
         case H5T_VLEN:
             /* Other datatype classes: nbit does no compression */
-            H5Z_calc_parms_nooptype();
+            H5Z_calc_parms_nooptype(cd_values_actual_nparms);
             break;
 
         case H5T_NO_CLASS:
@@ -312,31 +313,32 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_calc_parms_compound(const H5T_t *type)
+H5Z_calc_parms_compound(const H5T_t *type, size_t *cd_values_actual_nparms)
 {
     int         nmembers;           /* Compound datatype's number of members */
     H5T_t *dtype_member = NULL;     /* Compound datatype's member datatype */
-    H5T_class_t dtype_member_class; /* Compound datatype's member datatype's class */
     unsigned    u;                  /* Local index variable */
     herr_t ret_value = SUCCEED;     /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Store compound datatype class code */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Store compound datatype's size */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* Get number of members */
     if((nmembers = H5T_get_nmembers(type)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype number of members")
 
     /* Store number of members */
-    ++cd_values_actual_nparms;
+    *cd_values_actual_nparms += 1;
 
     /* For each member, calculate parameters */
     for(u = 0; u < (unsigned)nmembers; u++) {
+        H5T_class_t dtype_member_class; /* Compound datatype's member datatype's class */
+
         /* Get member datatype */
         if(NULL == (dtype_member = H5T_get_member_type(type, u, H5T_COPY_TRANSIENT)))
             HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad member datatype")
@@ -346,22 +348,22 @@ H5Z_calc_parms_compound(const H5T_t *type)
             HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad member datatype class")
 
         /* Store member offset */
-        ++cd_values_actual_nparms;
+        *cd_values_actual_nparms += 1;
 
         /* Calculate parameters according to member's datatype class */
         switch(dtype_member_class) {
             case H5T_INTEGER:
             case H5T_FLOAT:
-                H5Z_calc_parms_atomic();
+                H5Z_calc_parms_atomic(cd_values_actual_nparms);
                 break;
 
             case H5T_ARRAY:
-                if(H5Z_calc_parms_array(dtype_member) == FAIL)
+                if(H5Z_calc_parms_array(dtype_member, cd_values_actual_nparms) == FAIL)
                     HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot compute parameters for datatype")
                 break;
 
             case H5T_COMPOUND:
-                if(H5Z_calc_parms_compound(dtype_member) == FAIL)
+                if(H5Z_calc_parms_compound(dtype_member, cd_values_actual_nparms) == FAIL)
                     HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot compute parameters for datatype")
                 break;
 
@@ -373,7 +375,7 @@ H5Z_calc_parms_compound(const H5T_t *type)
             case H5T_ENUM:
             case H5T_VLEN:
                 /* Other datatype classes: nbit does no compression */
-                H5Z_calc_parms_nooptype();
+                H5Z_calc_parms_nooptype(cd_values_actual_nparms);
                 break;
 
             case H5T_NO_CLASS:
@@ -418,7 +420,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_set_parms_nooptype(const H5T_t *type, unsigned cd_values[])
+H5Z_set_parms_nooptype(const H5T_t *type, unsigned *cd_values_index, unsigned cd_values[])
 {
     size_t dtype_size;          /* No-op datatype's size (in bytes) */
     herr_t ret_value = SUCCEED; /* Return value */
@@ -426,14 +428,15 @@ H5Z_set_parms_nooptype(const H5T_t *type, unsigned cd_values[])
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Set datatype class code */
-    cd_values[cd_values_index++] = H5Z_NBIT_NOOPTYPE;
+    cd_values[(*cd_values_index)++] = H5Z_NBIT_NOOPTYPE;
 
     /* Get datatype's size */
     if((dtype_size = H5T_get_size(type)) == 0)
 	HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype size")
 
     /* Set "local" parameter for datatype size */
-    cd_values[cd_values_index++] = dtype_size;
+    H5_CHECK_OVERFLOW(dtype_size, size_t, unsigned);
+    cd_values[(*cd_values_index)++] = (unsigned)dtype_size;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -457,25 +460,28 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_set_parms_atomic(const H5T_t *type, unsigned cd_values[])
+H5Z_set_parms_atomic(const H5T_t *type, unsigned *cd_values_index,
+    unsigned cd_values[], hbool_t *need_not_compress)
 {
     H5T_order_t dtype_order;    /* Atomic datatype's endianness order */
     size_t dtype_size;          /* Atomic datatype's size (in bytes) */
     size_t dtype_precision;     /* Atomic datatype's precision (in bits) */
-    int dtype_offset;           /* Atomic datatype's offset (in bits) */
+    int sdtype_offset;          /* Atomic datatype's offset (in bits) */
+    unsigned dtype_offset;      /* Atomic datatype's offset (in bits) */
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Set datatype class code */
-    cd_values[cd_values_index++] = H5Z_NBIT_ATOMIC;
+    cd_values[(*cd_values_index)++] = H5Z_NBIT_ATOMIC;
 
     /* Get datatype's size */
     if((dtype_size = H5T_get_size(type)) == 0)
         HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype size")
 
     /* Set "local" parameter for datatype size */
-    cd_values[cd_values_index++] = dtype_size;
+    H5_CHECK_OVERFLOW(dtype_size, size_t, unsigned);
+    cd_values[(*cd_values_index)++] = (unsigned)dtype_size;
 
     /* Get datatype's endianness order */
     if((dtype_order = H5T_get_order(type)) == H5T_ORDER_ERROR)
@@ -484,11 +490,11 @@ H5Z_set_parms_atomic(const H5T_t *type, unsigned cd_values[])
     /* Set "local" parameter for datatype endianness */
     switch(dtype_order) {
         case H5T_ORDER_LE:      /* Little-endian byte order */
-            cd_values[cd_values_index++] = H5Z_NBIT_ORDER_LE;
+            cd_values[(*cd_values_index)++] = H5Z_NBIT_ORDER_LE;
             break;
 
         case H5T_ORDER_BE:      /* Big-endian byte order */
-            cd_values[cd_values_index++] = H5Z_NBIT_ORDER_BE;
+            cd_values[(*cd_values_index)++] = H5Z_NBIT_ORDER_BE;
             break;
 
         case H5T_ORDER_VAX:
@@ -504,27 +510,28 @@ H5Z_set_parms_atomic(const H5T_t *type, unsigned cd_values[])
         HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype precision")
 
     /* Get datatype's offset */
-    if((dtype_offset = H5T_get_offset(type)) < 0)
+    if((sdtype_offset = H5T_get_offset(type)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype offset")
+    dtype_offset = (unsigned)sdtype_offset;
 
     /* Check values of precision and offset */
-    if(dtype_precision > dtype_size * 8 || (dtype_precision + dtype_offset) > dtype_size * 8
-            || dtype_precision <= 0 || dtype_offset < 0)
+    if(dtype_precision > dtype_size * 8 || (dtype_precision + dtype_offset) > dtype_size * 8)
         HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "invalid datatype precision/offset")
 
     /* Set "local" parameter for datatype precision */
-    cd_values[cd_values_index++] = dtype_precision;
+    H5_CHECK_OVERFLOW(dtype_precision, size_t, unsigned);
+    cd_values[(*cd_values_index)++] = (unsigned)dtype_precision;
 
     /* Set "local" parameter for datatype offset */
-    cd_values[cd_values_index++] = dtype_offset;
+    cd_values[(*cd_values_index)++] = dtype_offset;
 
     /* If before this point, there is no need to compress, check the need to
      * compress at this point. If current datatype is not full-precision,
      * flag need_not_compress should be set to FALSE.
      */
-    if(need_not_compress) /* so far no need to compress */
+    if(*need_not_compress) /* so far no need to compress */
        if(dtype_offset != 0 || dtype_precision != dtype_size * 8)
-          need_not_compress = FALSE;
+          *need_not_compress = FALSE;
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5Z_set_parms_atomic() */
@@ -547,7 +554,8 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_set_parms_array(const H5T_t *type, unsigned cd_values[])
+H5Z_set_parms_array(const H5T_t *type, unsigned *cd_values_index,
+    unsigned cd_values[], hbool_t *need_not_compress)
 {
     H5T_t *dtype_base = NULL;      /* Array datatype's base datatype */
     H5T_class_t dtype_base_class;  /* Array datatype's base datatype's class */
@@ -558,14 +566,15 @@ H5Z_set_parms_array(const H5T_t *type, unsigned cd_values[])
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Set datatype class code */
-    cd_values[cd_values_index++] = H5Z_NBIT_ARRAY;
+    cd_values[(*cd_values_index)++] = H5Z_NBIT_ARRAY;
 
     /* Get array datatype's size */
     if((dtype_size = H5T_get_size(type)) == 0)
 	HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype size")
 
     /* Set "local" parameter for array datatype's size */
-    cd_values[cd_values_index++]=dtype_size;
+    H5_CHECK_OVERFLOW(dtype_size, size_t, unsigned);
+    cd_values[(*cd_values_index)++] = (unsigned)dtype_size;
 
     /* Get array datatype's base datatype */
     if(NULL == (dtype_base = H5T_get_super(type)))
@@ -579,17 +588,17 @@ H5Z_set_parms_array(const H5T_t *type, unsigned cd_values[])
     switch(dtype_base_class) {
         case H5T_INTEGER:
         case H5T_FLOAT:
-            if(H5Z_set_parms_atomic(dtype_base, cd_values) == FAIL)
+            if(H5Z_set_parms_atomic(dtype_base, cd_values_index, cd_values, need_not_compress) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
         case H5T_ARRAY:
-            if(H5Z_set_parms_array(dtype_base, cd_values) == FAIL)
+            if(H5Z_set_parms_array(dtype_base, cd_values_index, cd_values, need_not_compress) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
         case H5T_COMPOUND:
-            if(H5Z_set_parms_compound(dtype_base, cd_values) == FAIL)
+            if(H5Z_set_parms_compound(dtype_base, cd_values_index, cd_values, need_not_compress) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
@@ -602,7 +611,7 @@ H5Z_set_parms_array(const H5T_t *type, unsigned cd_values[])
             if(dtype_base_class == H5T_VLEN || is_vlstring)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "datatype not supported by nbit")
 
-            if(H5Z_set_parms_nooptype(dtype_base, cd_values) == FAIL)
+            if(H5Z_set_parms_nooptype(dtype_base, cd_values_index, cd_values) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
@@ -612,7 +621,7 @@ H5Z_set_parms_array(const H5T_t *type, unsigned cd_values[])
         case H5T_OPAQUE:
         case H5T_REFERENCE:
         case H5T_ENUM:
-            if(H5Z_set_parms_nooptype(dtype_base, cd_values) == FAIL)
+            if(H5Z_set_parms_nooptype(dtype_base, cd_values_index, cd_values) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
@@ -650,9 +659,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_set_parms_compound(const H5T_t *type, unsigned cd_values[])
+H5Z_set_parms_compound(const H5T_t *type, unsigned *cd_values_index,
+    unsigned cd_values[], hbool_t *need_not_compress)
 {
-    int         nmembers;           /* Compound datatype's number of members */
+    int snmembers;                  /* Compound datatype's number of members */
+    unsigned nmembers;              /* Compound datatype's number of members */
     H5T_t *dtype_member = NULL;     /* Compound datatype's member datatype */
     H5T_class_t dtype_member_class; /* Compound datatype's member datatype's class */
     size_t dtype_member_offset;     /* Compound datatype's current member datatype's offset (in bytes) */
@@ -665,24 +676,26 @@ H5Z_set_parms_compound(const H5T_t *type, unsigned cd_values[])
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Set "local" parameter for compound datatype class code */
-    cd_values[cd_values_index++] = H5Z_NBIT_COMPOUND;
+    cd_values[(*cd_values_index)++] = H5Z_NBIT_COMPOUND;
 
     /* Get datatype's size */
     if((dtype_size = H5T_get_size(type)) == 0)
 	HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype size")
 
     /* Set "local" parameter for compound datatype size */
-    cd_values[cd_values_index++] = dtype_size;
+    H5_CHECK_OVERFLOW(dtype_size, size_t, unsigned);
+    cd_values[(*cd_values_index)++] = (unsigned)dtype_size;
 
     /* Get number of members */
-    if((nmembers = H5T_get_nmembers(type)) < 0)
+    if((snmembers = H5T_get_nmembers(type)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad datatype number of members")
+    nmembers = (unsigned)snmembers;
 
     /* Set "local" parameter for number of members */
-    cd_values[cd_values_index++] = nmembers;
+    cd_values[(*cd_values_index)++] = nmembers;
 
     /* For each member, set parameters */
-    for(u = 0; u < (unsigned)nmembers; u++) {
+    for(u = 0; u < nmembers; u++) {
         /* Get member datatype */
         if(NULL == (dtype_member = H5T_get_member_type(type, u, H5T_COPY_TRANSIENT)))
             HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "bad member datatype")
@@ -695,23 +708,24 @@ H5Z_set_parms_compound(const H5T_t *type, unsigned cd_values[])
         dtype_member_offset =  H5T_get_member_offset(type, u);
 
         /* Set "local" parameter for member offset */
-        cd_values[cd_values_index++] = dtype_member_offset;
+        H5_CHECK_OVERFLOW(dtype_member_offset, size_t, unsigned);
+        cd_values[(*cd_values_index)++] = (unsigned)dtype_member_offset;
 
         /* Call appropriate function according to member's datatype class */
         switch(dtype_member_class) {
             case H5T_INTEGER:
             case H5T_FLOAT:
-                if(H5Z_set_parms_atomic(dtype_member, cd_values) == FAIL)
+                if(H5Z_set_parms_atomic(dtype_member, cd_values_index, cd_values, need_not_compress) < 0)
                     HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
                 break;
 
             case H5T_ARRAY:
-                if(H5Z_set_parms_array(dtype_member, cd_values) == FAIL)
+                if(H5Z_set_parms_array(dtype_member, cd_values_index, cd_values, need_not_compress) < 0)
                     HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
                 break;
 
             case H5T_COMPOUND:
-                if(H5Z_set_parms_compound(dtype_member, cd_values) == FAIL)
+                if(H5Z_set_parms_compound(dtype_member, cd_values_index, cd_values, need_not_compress) < 0)
                     HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
                 break;
 
@@ -721,22 +735,24 @@ H5Z_set_parms_compound(const H5T_t *type, unsigned cd_values[])
                     HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot determine if datatype is a variable-length string")
 
                 /* Because for some no-op datatype (VL datatype and VL string datatype), its
-		         * size can not be retrieved correctly by using function call H5T_get_size,
-		         * special handling is needed for getting the size. Here the difference between
+                 * size can not be retrieved correctly by using function call H5T_get_size,
+                 * special handling is needed for getting the size. Here the difference between
                  * adjacent member offset is used (if alignment is present, the result can be
-		         * larger, but it does not affect the nbit filter's correctness).
+                 * larger, but it does not affect the nbit filter's correctness).
                  */
                 if(dtype_member_class == H5T_VLEN || is_vlstring) {
                     /* Set datatype class code */
-                    cd_values[cd_values_index++] = H5Z_NBIT_NOOPTYPE;
+                    cd_values[(*cd_values_index)++] = H5Z_NBIT_NOOPTYPE;
 
-                    if(u != (unsigned)nmembers - 1)
+                    if(u != nmembers - 1)
                         dtype_next_member_offset = H5T_get_member_offset(type, u + 1);
                     else /* current member is the last member */
                         dtype_next_member_offset = dtype_size;
 
                     /* Set "local" parameter for datatype size */
-                    cd_values[cd_values_index++] = dtype_next_member_offset - dtype_member_offset;
+                    H5_CHECK_OVERFLOW(dtype_member_offset, size_t, unsigned);
+                    H5_CHECK_OVERFLOW(dtype_next_member_offset, size_t, unsigned);
+                    cd_values[(*cd_values_index)++] = (unsigned)dtype_next_member_offset - (unsigned)dtype_member_offset;
                 } 
                 break;
 
@@ -747,7 +763,7 @@ H5Z_set_parms_compound(const H5T_t *type, unsigned cd_values[])
             case H5T_REFERENCE:
             case H5T_ENUM:
                 /* other datatype that nbit does no compression */
-                if(H5Z_set_parms_nooptype(dtype_member, cd_values) == FAIL)
+                if(H5Z_set_parms_nooptype(dtype_member, cd_values_index, cd_values) < 0)
                     HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
                 break;
 
@@ -796,10 +812,13 @@ H5Z_set_local_nbit(hid_t dcpl_id, hid_t type_id, hid_t space_id)
     const H5T_t	*type;              /* Datatype */
     const H5S_t	*ds;                /* Dataspace */
     unsigned flags;                 /* Filter flags */
+    unsigned cd_values_index;       /* Index of array cd_values */
+    size_t cd_values_actual_nparms; /* Number of parameters in array cd_values[] */
     size_t cd_nelmts = H5Z_NBIT_USER_NPARMS;  /* Number of filter parameters */
     unsigned *cd_values = NULL;     /* Filter parameters */
     hssize_t npoints;               /* Number of points in the dataspace */
     H5T_class_t dtype_class;        /* Datatype's class */
+    hbool_t need_not_compress;      /* Flag if TRUE indicating no need to do nbit compression */
     herr_t ret_value = SUCCEED;     /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
@@ -822,16 +841,16 @@ H5Z_set_local_nbit(hid_t dcpl_id, hid_t type_id, hid_t space_id)
     switch(dtype_class) {
         case H5T_INTEGER:
         case H5T_FLOAT:
-            H5Z_calc_parms_atomic();
+            H5Z_calc_parms_atomic(&cd_values_actual_nparms);
             break;
 
         case H5T_ARRAY:
-            if(H5Z_calc_parms_array(type) == FAIL)
+            if(H5Z_calc_parms_array(type, &cd_values_actual_nparms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot compute parameters for datatype")
             break;
 
         case H5T_COMPOUND:
-            if(H5Z_calc_parms_compound(type) == FAIL)
+            if(H5Z_calc_parms_compound(type, &cd_values_actual_nparms) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot compute parameters for datatype")
             break;
 
@@ -882,7 +901,8 @@ H5Z_set_local_nbit(hid_t dcpl_id, hid_t type_id, hid_t space_id)
     cd_values_index = 2;
 
     /* Set "local" parameter for number of elements in the chunk */
-    H5_CHECKED_ASSIGN(cd_values[cd_values_index++], unsigned, npoints, hssize_t);
+    H5_CHECK_OVERFLOW(npoints, hssize_t, unsigned);
+    cd_values[cd_values_index++] = (unsigned)npoints;
 
     /* Assume no need to compress now, will be changed to FALSE later if not */
     need_not_compress = TRUE;
@@ -891,17 +911,17 @@ H5Z_set_local_nbit(hid_t dcpl_id, hid_t type_id, hid_t space_id)
     switch(dtype_class) {
         case H5T_INTEGER:
         case H5T_FLOAT:
-            if(H5Z_set_parms_atomic(type, cd_values) < 0)
+            if(H5Z_set_parms_atomic(type, &cd_values_index, cd_values, &need_not_compress) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
         case H5T_ARRAY:
-            if(H5Z_set_parms_array(type, cd_values) < 0)
+            if(H5Z_set_parms_array(type, &cd_values_index, cd_values, &need_not_compress) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
         case H5T_COMPOUND:
-            if(H5Z_set_parms_compound(type, cd_values) < 0)
+            if(H5Z_set_parms_compound(type, &cd_values_index, cd_values, &need_not_compress) < 0)
                 HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "nbit cannot set parameters for datatype")
             break;
 
@@ -927,8 +947,9 @@ H5Z_set_local_nbit(hid_t dcpl_id, hid_t type_id, hid_t space_id)
     HDassert(cd_values_actual_nparms == cd_values_index);
 
     /* Finally set the first two entries of cd_values[] */
-    cd_values[0] = cd_values_actual_nparms;
-    cd_values[1] = need_not_compress;
+    H5_CHECK_OVERFLOW(cd_values_actual_nparms, size_t, unsigned);
+    cd_values[0] = (unsigned)cd_values_actual_nparms;
+    cd_values[1] = (unsigned)need_not_compress;
 
     /* Modify the filter's parameters for this dataset */
     if(H5P_modify_filter(dcpl_plist, H5Z_FILTER_NBIT, flags, cd_values_actual_nparms, cd_values) < 0)
@@ -957,7 +978,7 @@ done:
  */
 static size_t
 H5Z_filter_nbit(unsigned flags, size_t cd_nelmts, const unsigned cd_values[],
-                size_t nbytes, size_t *buf_size, void **buf)
+    size_t nbytes, size_t *buf_size, void **buf)
 {
     unsigned char *outbuf;      /* pointer to new output buffer */
     size_t size_out  = 0;       /* size of output buffer */
@@ -1027,63 +1048,64 @@ done:
  */
 
 static void
-H5Z_nbit_next_byte(size_t *j, int *buf_len)
+H5Z_nbit_next_byte(size_t *j, size_t *buf_len)
 {
    ++(*j);
    *buf_len = 8 * sizeof(unsigned char);
 }
 
 static void
-H5Z_nbit_decompress_one_byte(unsigned char *data, size_t data_offset, int k,
-    int begin_i, int end_i, unsigned char *buffer, size_t *j, int *buf_len,
-    parms_atomic p, int datatype_len)
+H5Z_nbit_decompress_one_byte(unsigned char *data, size_t data_offset, unsigned k,
+    unsigned begin_i, unsigned end_i, unsigned char *buffer, size_t *j, size_t *buf_len,
+    const parms_atomic *p, size_t datatype_len)
 {
-   int dat_len; /* dat_len is the number of bits to be copied in each data byte */
-   int uchar_offset;
+   size_t dat_len; /* dat_len is the number of bits to be copied in each data byte */
+   size_t dat_offset;
    unsigned char val; /* value to be copied in each data byte */
 
    /* initialize value and bits of unsigned char to be copied */
    val = buffer[*j];
-   uchar_offset = 0;
+   dat_offset = 0;
 
    if(begin_i != end_i) { /* significant bits occupy >1 unsigned char */
       if(k == begin_i)
-         dat_len = 8 - (datatype_len - p.precision - p.offset) % 8;
+         dat_len = 8 - (datatype_len - p->precision - p->offset) % 8;
       else if(k == end_i) {
-         dat_len = 8 - p.offset %8;
-         uchar_offset = 8 - dat_len;
+         dat_len = 8 - p->offset % 8;
+         dat_offset = 8 - dat_len;
       }
       else
          dat_len = 8;
    } else { /* all significant bits in one unsigned char */
-      uchar_offset = p.offset % 8;
-      dat_len = p.precision;
+      dat_offset = p->offset % 8;
+      dat_len = p->precision;
    }
 
    if(*buf_len > dat_len) {
-      data[data_offset + k] =
-      ((val >> (*buf_len - dat_len)) & ~(~0 << dat_len)) << uchar_offset;
+      data[data_offset + k] = (unsigned char)(
+          ((unsigned)(val >> (*buf_len - dat_len)) & (unsigned)(~((unsigned)(~0) << dat_len))) << dat_offset);
       *buf_len -= dat_len;
    } else {
-      data[data_offset + k] =
-      ((val & ~(~0 << *buf_len)) << (dat_len - *buf_len)) << uchar_offset;
+      data[data_offset + k] = (unsigned char)(
+          ((val & ~((unsigned)(~0) << *buf_len)) << (dat_len - *buf_len)) << dat_offset);
       dat_len -= *buf_len;
       H5Z_nbit_next_byte(j, buf_len);
-      if(dat_len == 0) return;
+      if(dat_len == 0)
+          return;
 
       val = buffer[*j];
-      data[data_offset + k] |=
-      ((val >> (*buf_len - dat_len)) & ~(~0 << dat_len)) << uchar_offset;
+      data[data_offset + k] |= (unsigned char)(
+          ((unsigned)(val >> (*buf_len - dat_len)) & (unsigned)(~((unsigned)(~0) << dat_len))) << dat_offset);
       *buf_len -= dat_len;
    }
 }
 
 static void
 H5Z_nbit_decompress_one_nooptype(unsigned char *data, size_t data_offset,
-                       unsigned char *buffer, size_t *j, int *buf_len, unsigned size)
+    unsigned char *buffer, size_t *j, size_t *buf_len, unsigned size)
 {
    unsigned i;        /* index */
-   unsigned dat_len;  /* dat_len is the number of bits to be copied in each data byte */
+   size_t dat_len;  /* dat_len is the number of bits to be copied in each data byte */
    unsigned char val; /* value to be copied in each data byte */
 
    for(i = 0; i < size; i++) {
@@ -1091,99 +1113,109 @@ H5Z_nbit_decompress_one_nooptype(unsigned char *data, size_t data_offset,
       val = buffer[*j];
       dat_len = sizeof(unsigned char) * 8;
 
-      data[data_offset + i] = ((val & ~(~0 << *buf_len)) << (dat_len - *buf_len));
+      data[data_offset + i] = (unsigned char)(((val & ~((unsigned)(~0) << *buf_len)) << (dat_len - *buf_len)));
       dat_len -= *buf_len;
       H5Z_nbit_next_byte(j, buf_len);
-      if(dat_len == 0) continue;
+      if(dat_len == 0)
+          continue;
 
       val = buffer[*j];
-      data[data_offset + i] |= ((val >> (*buf_len - dat_len)) & ~(~0 << dat_len));
+      data[data_offset + i] |= (unsigned char)((unsigned)(val >> (*buf_len - dat_len)) & (unsigned)(~((unsigned)(~0) << dat_len)));
       *buf_len -= dat_len;
    }
 }
 
 static void
 H5Z_nbit_decompress_one_atomic(unsigned char *data, size_t data_offset,
-                    unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p)
+    unsigned char *buffer, size_t *j, size_t *buf_len, const parms_atomic *p)
 {
-   /* begin_i: the index of byte having first significant bit
-      end_i: the index of byte having last significant bit */
-   int k, begin_i, end_i, datatype_len;
-
-   datatype_len = p.size * 8;
-
-   if(p.order == H5Z_NBIT_ORDER_LE) { /* little endian */
-      /* calculate begin_i and end_i */
-      if((p.precision + p.offset) % 8 != 0)
-         begin_i = (p.precision + p.offset) / 8;
-      else
-         begin_i = (p.precision + p.offset) / 8 - 1;
-      end_i = p.offset / 8;
-
-      for(k = begin_i; k >= end_i; k--)
-         H5Z_nbit_decompress_one_byte(data, data_offset, k, begin_i, end_i,
-                                      buffer, j, buf_len, p, datatype_len);
-   }
-
-   if(p.order == H5Z_NBIT_ORDER_BE) { /* big endian */
-      /* calculate begin_i and end_i */
-      begin_i = (datatype_len - p.precision - p.offset) / 8;
-      if(p.offset % 8 != 0)
-         end_i = (datatype_len - p.offset) / 8;
-      else
-         end_i = (datatype_len - p.offset) / 8 - 1;
-
-      for(k = begin_i; k <= end_i; k++)
-         H5Z_nbit_decompress_one_byte(data, data_offset, k, begin_i, end_i,
-                                      buffer, j, buf_len, p, datatype_len);
-   }
+    /* begin_i: the index of byte having first significant bit
+       end_i: the index of byte having last significant bit */
+    int k;
+    unsigned begin_i, end_i;
+    size_t datatype_len;
+
+    datatype_len = p->size * 8;
+
+    if(p->order == H5Z_NBIT_ORDER_LE) { /* little endian */
+        /* calculate begin_i and end_i */
+        if((p->precision + p->offset) % 8 != 0)
+           begin_i = (p->precision + p->offset) / 8;
+        else
+           begin_i = (p->precision + p->offset) / 8 - 1;
+        end_i = p->offset / 8;
+
+        for(k = (int)begin_i; k >= (int)end_i; k--)
+            H5Z_nbit_decompress_one_byte(data, data_offset, (unsigned)k, begin_i, end_i,
+                                         buffer, j, buf_len, p, datatype_len);
+    }
+    else { /* big endian */
+        /* Sanity check */
+        HDassert(p->order == H5Z_NBIT_ORDER_BE);
+
+        /* calculate begin_i and end_i */
+        begin_i = ((unsigned)datatype_len - p->precision - p->offset) / 8;
+        if(p->offset % 8 != 0)
+           end_i = ((unsigned)datatype_len - p->offset) / 8;
+        else
+           end_i = ((unsigned)datatype_len - p->offset) / 8 - 1;
+
+        for(k = (int)begin_i; k <= (int)end_i; k++)
+            H5Z_nbit_decompress_one_byte(data, data_offset, (unsigned)k, begin_i, end_i,
+                                         buffer, j, buf_len, p, datatype_len);
+    }
 }
 
 static void
 H5Z_nbit_decompress_one_array(unsigned char *data, size_t data_offset,
-           unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[])
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index)
 {
    unsigned i, total_size, base_class, base_size, n, begin_index;
    parms_atomic p;
 
-   total_size = parms[parms_index++];
-   base_class = parms[parms_index++];
+   total_size = parms[(*parms_index)++];
+   base_class = parms[(*parms_index)++];
 
    switch(base_class) {
       case H5Z_NBIT_ATOMIC:
-           p.size = parms[parms_index++];
-           p.order = parms[parms_index++];
-           p.precision = parms[parms_index++];
-           p.offset = parms[parms_index++];
-           n = total_size/p.size;
+           p.size = parms[(*parms_index)++];
+           p.order = parms[(*parms_index)++];
+           p.precision = parms[(*parms_index)++];
+           p.offset = parms[(*parms_index)++];
+           n = total_size / p.size;
            for(i = 0; i < n; i++)
-              H5Z_nbit_decompress_one_atomic(data, data_offset + i*p.size,
-                                             buffer, j, buf_len, p);
+              H5Z_nbit_decompress_one_atomic(data, data_offset + i * p.size,
+                                             buffer, j, buf_len, &p);
            break;
+
       case H5Z_NBIT_ARRAY:
-           base_size = parms[parms_index]; /* read in advance */
-           n = total_size/base_size; /* number of base_type elements inside the array datatype */
-           begin_index = parms_index;
+           base_size = parms[*parms_index]; /* read in advance */
+           n = total_size / base_size; /* number of base_type elements inside the array datatype */
+           begin_index = *parms_index;
            for(i = 0; i < n; i++) {
-              H5Z_nbit_decompress_one_array(data, data_offset + i*base_size,
-                                            buffer, j, buf_len, parms);
-              parms_index = begin_index;
+              H5Z_nbit_decompress_one_array(data, data_offset + i * base_size,
+                                            buffer, j, buf_len, parms, parms_index);
+              *parms_index = begin_index;
            }
            break;
+
       case H5Z_NBIT_COMPOUND:
-           base_size = parms[parms_index]; /* read in advance */
-           n = total_size/base_size; /* number of base_type elements inside the array datatype */
-           begin_index = parms_index;
+           base_size = parms[*parms_index]; /* read in advance */
+           n = total_size / base_size; /* number of base_type elements inside the array datatype */
+           begin_index = *parms_index;
            for(i = 0; i < n; i++) {
-              H5Z_nbit_decompress_one_compound(data, data_offset + i*base_size,
-                                               buffer, j, buf_len, parms);
-              parms_index = begin_index;
+              H5Z_nbit_decompress_one_compound(data, data_offset + i * base_size,
+                                               buffer, j, buf_len, parms, parms_index);
+              *parms_index = begin_index;
            }
            break;
+
       case H5Z_NBIT_NOOPTYPE:
-           parms_index++; /* skip size of no-op type */
+           (*parms_index)++; /* skip size of no-op type */
            H5Z_nbit_decompress_one_nooptype(data, data_offset, buffer, j, buf_len, total_size);
            break;
+
       default:
           HDassert(0 && "This Should never be executed!");
    } /* end switch */
@@ -1191,39 +1223,44 @@ H5Z_nbit_decompress_one_array(unsigned char *data, size_t data_offset,
 
 static void
 H5Z_nbit_decompress_one_compound(unsigned char *data, size_t data_offset,
-              unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[])
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index)
 {
    unsigned i, nmembers, member_offset, member_class, size;
    parms_atomic p;
 
-   parms_index++; /* skip total size of compound datatype */
-   nmembers = parms[parms_index++];
+   (*parms_index)++; /* skip total size of compound datatype */
+   nmembers = parms[(*parms_index)++];
 
    for(i = 0; i < nmembers; i++) {
-      member_offset = parms[parms_index++];
-      member_class = parms[parms_index++];
+      member_offset = parms[(*parms_index)++];
+      member_class = parms[(*parms_index)++];
       switch(member_class) {
          case H5Z_NBIT_ATOMIC:
-              p.size = parms[parms_index++];
-              p.order = parms[parms_index++];
-              p.precision = parms[parms_index++];
-              p.offset = parms[parms_index++];
+              p.size = parms[(*parms_index)++];
+              p.order = parms[(*parms_index)++];
+              p.precision = parms[(*parms_index)++];
+              p.offset = parms[(*parms_index)++];
               H5Z_nbit_decompress_one_atomic(data, data_offset + member_offset,
-                                             buffer, j, buf_len, p);
+                                             buffer, j, buf_len, &p);
               break;
+
          case H5Z_NBIT_ARRAY:
               H5Z_nbit_decompress_one_array(data, data_offset + member_offset,
-                                            buffer, j, buf_len, parms);
+                                            buffer, j, buf_len, parms, parms_index);
               break;
+
          case H5Z_NBIT_COMPOUND:
               H5Z_nbit_decompress_one_compound(data, data_offset+member_offset,
-                                               buffer, j, buf_len, parms);
+                                               buffer, j, buf_len, parms, parms_index);
               break;
+
          case H5Z_NBIT_NOOPTYPE:
-              size = parms[parms_index++];
+              size = parms[(*parms_index)++];
               H5Z_nbit_decompress_one_nooptype(data, data_offset+member_offset,
                                                buffer, j, buf_len, size);
               break;
+
           default:
               HDassert(0 && "This Should never be executed!");
       } /* end switch */
@@ -1232,94 +1269,101 @@ H5Z_nbit_decompress_one_compound(unsigned char *data, size_t data_offset,
 
 static void
 H5Z_nbit_decompress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
-                                const unsigned parms[])
+    const unsigned parms[])
 {
-   /* i: index of data, j: index of buffer,
-      buf_len: number of bits to be filled in current byte */
-   size_t i, j, size;
-   int buf_len;
-   parms_atomic p;
+    /* i: index of data, j: index of buffer,
+       buf_len: number of bits to be filled in current byte */
+    unsigned i;
+    size_t j, size;
+    size_t buf_len;
+    parms_atomic p;
+    unsigned parms_index; /* index in array parms used by compression/decompression functions */
+
+    /* may not have to initialize to zeros */
+    HDmemset(data, 0, d_nelmts * parms[4]);
+
+    /* initialization before the loop */
+    j = 0;
+    buf_len = sizeof(unsigned char) * 8;
+
+    switch(parms[3]) {
+       case H5Z_NBIT_ATOMIC:
+            p.size = parms[4];
+            p.order = parms[5];
+            p.precision = parms[6];
+            p.offset = parms[7];
+            for(i = 0; i < d_nelmts; i++)
+               H5Z_nbit_decompress_one_atomic(data, i * p.size, buffer, &j, &buf_len, &p);
+            break;
 
-   /* may not have to initialize to zeros */
-   for(i = 0; i < d_nelmts*parms[4]; i++) data[i] = 0;
+       case H5Z_NBIT_ARRAY:
+            size = parms[4];
+            parms_index = 4;    /* set the index before goto function call */
+            for(i = 0; i < d_nelmts; i++) {
+                H5Z_nbit_decompress_one_array(data, i * size, buffer, &j, &buf_len, parms, &parms_index);
+                parms_index = 4;
+            }
+            break;
 
-   /* initialization before the loop */
-   j = 0;
-   buf_len = sizeof(unsigned char) * 8;
+       case H5Z_NBIT_COMPOUND:
+            size = parms[4];
+            parms_index = 4;    /* set the index before goto function call */
+            for(i = 0; i < d_nelmts; i++) {
+                H5Z_nbit_decompress_one_compound(data, i * size, buffer, &j, &buf_len, parms, &parms_index);
+                parms_index = 4;
+            }
+            break;
 
-   switch(parms[3]) {
-      case H5Z_NBIT_ATOMIC:
-           /* set the index before goto function call */
-           p.size = parms[4];
-           p.order = parms[5];
-           p.precision = parms[6];
-           p.offset = parms[7];
-           for(i = 0; i < d_nelmts; i++) {
-              H5Z_nbit_decompress_one_atomic(data, i*p.size, buffer, &j, &buf_len, p);
-           }
-           break;
-      case H5Z_NBIT_ARRAY:
-           size = parms[4];
-           parms_index = 4;
-           for(i = 0; i < d_nelmts; i++) {
-              H5Z_nbit_decompress_one_array(data, i*size, buffer, &j, &buf_len, parms);
-              parms_index = 4;
-           }
-           break;
-      case H5Z_NBIT_COMPOUND:
-           size = parms[4];
-           parms_index = 4;
-           for(i = 0; i < d_nelmts; i++) {
-              H5Z_nbit_decompress_one_compound(data, i*size, buffer, &j, &buf_len, parms);
-              parms_index = 4;
-           }
-           break;
-      default:
-          HDassert(0 && "This Should never be executed!");
-   } /* end switch */
+       default:
+           HDassert(0 && "This Should never be executed!");
+    } /* end switch */
 }
 
-static void H5Z_nbit_compress_one_byte(unsigned char *data, size_t data_offset, int k, int begin_i,
-int end_i, unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p, int datatype_len)
+static void
+H5Z_nbit_compress_one_byte(unsigned char *data, size_t data_offset, unsigned k,
+    unsigned begin_i, unsigned end_i, unsigned char *buffer, size_t *j, size_t *buf_len,
+    const parms_atomic *p, size_t datatype_len)
 {
-   int dat_len; /* dat_len is the number of bits to be copied in each data byte */
+   size_t dat_len; /* dat_len is the number of bits to be copied in each data byte */
    unsigned char val; /* value to be copied in each data byte */
 
    /* initialize value and bits of unsigned char to be copied */
    val = data[data_offset + k];
    if(begin_i != end_i) { /* significant bits occupy >1 unsigned char */
       if(k == begin_i)
-         dat_len = 8 - (datatype_len - p.precision - p.offset) % 8;
+         dat_len = 8 - (datatype_len - p->precision - p->offset) % 8;
       else if(k == end_i) {
-         dat_len = 8 - p.offset % 8;
-         val >>= 8 - dat_len;
+         dat_len = 8 - p->offset % 8;
+         val = (unsigned char)(val >> (8 - dat_len));
       }
       else
          dat_len = 8;
    } else { /* all significant bits in one unsigned char */
-      val >>= p.offset % 8;
-      dat_len = p.precision;
+      val = (unsigned char)(val >> (p->offset % 8));
+      dat_len = p->precision;
    }
 
    if(*buf_len > dat_len) {
-      buffer[*j] |= (val & ~(~0 << dat_len)) << (*buf_len - dat_len);
+      buffer[*j] |= (unsigned char)((val & ~((unsigned)(~0) << dat_len)) << (*buf_len - dat_len));
       *buf_len -= dat_len;
    } else {
-      buffer[*j] |= (val >> (dat_len - *buf_len)) & ~(~0 << *buf_len);
+      buffer[*j] |= (unsigned char)((unsigned)(val >> (dat_len - *buf_len)) & ~((unsigned)(~0) << *buf_len));
       dat_len -= *buf_len;
       H5Z_nbit_next_byte(j, buf_len);
-      if(dat_len == 0) return;
+      if(dat_len == 0)
+          return;
 
-      buffer[*j] = (val & ~(~0 << dat_len)) << (*buf_len - dat_len);
+      buffer[*j] = (unsigned char)((val & ~((unsigned)(~0) << dat_len)) << (*buf_len - dat_len));
       *buf_len -= dat_len;
    }
 }
 
-static void H5Z_nbit_compress_one_nooptype(unsigned char *data, size_t data_offset,
-                     unsigned char *buffer, size_t *j, int *buf_len, unsigned size)
+static void
+H5Z_nbit_compress_one_nooptype(unsigned char *data, size_t data_offset,
+    unsigned char *buffer, size_t *j, size_t *buf_len, unsigned size)
 {
    unsigned i;        /* index */
-   unsigned dat_len;  /* dat_len is the number of bits to be copied in each data byte */
+   size_t dat_len;  /* dat_len is the number of bits to be copied in each data byte */
    unsigned char val; /* value to be copied in each data byte */
 
    for(i = 0; i < size; i++) {
@@ -1327,192 +1371,214 @@ static void H5Z_nbit_compress_one_nooptype(unsigned char *data, size_t data_offs
       val = data[data_offset + i];
       dat_len = sizeof(unsigned char) * 8;
 
-      buffer[*j] |= (val >> (dat_len - *buf_len)) & ~(~0 << *buf_len);
+      buffer[*j] |= (unsigned char)((unsigned)(val >> (dat_len - *buf_len)) & ~((unsigned)(~0) << *buf_len));
       dat_len -= *buf_len;
       H5Z_nbit_next_byte(j, buf_len);
-      if(dat_len == 0) continue;
+      if(dat_len == 0)
+          continue;
 
-      buffer[*j] = (val & ~(~0 << dat_len)) << (*buf_len - dat_len);
+      buffer[*j] = (unsigned char)((val & ~((unsigned)(~0) << dat_len)) << (*buf_len - dat_len));
       *buf_len -= dat_len;
    }
 }
 
-static void H5Z_nbit_compress_one_atomic(unsigned char *data, size_t data_offset,
-                  unsigned char *buffer, size_t *j, int *buf_len, parms_atomic p)
+static void
+H5Z_nbit_compress_one_atomic(unsigned char *data, size_t data_offset,
+    unsigned char *buffer, size_t *j, size_t *buf_len, const parms_atomic *p)
 {
-   /* begin_i: the index of byte having first significant bit
-      end_i: the index of byte having last significant bit */
-   int k, begin_i, end_i, datatype_len;
-
-   datatype_len = p.size * 8;
-
-   if(p.order == H5Z_NBIT_ORDER_LE) { /* little endian */
-      /* calculate begin_i and end_i */
-      if((p.precision + p.offset) % 8 != 0)
-         begin_i = (p.precision + p.offset) / 8;
-      else
-         begin_i = (p.precision + p.offset) / 8 - 1;
-      end_i = p.offset / 8;
-
-      for(k = begin_i; k >= end_i; k--)
-         H5Z_nbit_compress_one_byte(data, data_offset, k, begin_i, end_i,
-                                    buffer, j, buf_len, p, datatype_len);
-   }
-
-   if(p.order == H5Z_NBIT_ORDER_BE) { /* big endian */
-      /* calculate begin_i and end_i */
-      begin_i = (datatype_len - p.precision - p.offset) / 8;
-      if(p.offset % 8 != 0)
-         end_i = (datatype_len - p.offset) / 8;
-      else
-         end_i = (datatype_len - p.offset) / 8 - 1;
-
-      for(k = begin_i; k <= end_i; k++)
-         H5Z_nbit_compress_one_byte(data, data_offset, k, begin_i, end_i,
-                                    buffer, j, buf_len, p, datatype_len);
-   }
+    /* begin_i: the index of byte having first significant bit
+       end_i: the index of byte having last significant bit */
+    int k;
+    unsigned begin_i, end_i;
+    size_t datatype_len;
+
+    datatype_len = p->size * 8;
+
+    if(p->order == H5Z_NBIT_ORDER_LE) { /* little endian */
+        /* calculate begin_i and end_i */
+        if((p->precision + p->offset) % 8 != 0)
+           begin_i = (p->precision + p->offset) / 8;
+        else
+           begin_i = (p->precision + p->offset) / 8 - 1;
+        end_i = p->offset / 8;
+
+        for(k = (int)begin_i; k >= (int)end_i; k--)
+            H5Z_nbit_compress_one_byte(data, data_offset, (unsigned)k, begin_i, end_i,
+                                       buffer, j, buf_len, p, datatype_len);
+    }
+    else { /* big endian */
+        /* Sanity check */
+        HDassert(p->order == H5Z_NBIT_ORDER_BE);
+
+        /* calculate begin_i and end_i */
+        begin_i = ((unsigned)datatype_len - p->precision - p->offset) / 8;
+        if(p->offset % 8 != 0)
+           end_i = ((unsigned)datatype_len - p->offset) / 8;
+        else
+           end_i = ((unsigned)datatype_len - p->offset) / 8 - 1;
+
+        for(k = (int)begin_i; k <= (int)end_i; k++)
+            H5Z_nbit_compress_one_byte(data, data_offset, (unsigned)k, begin_i, end_i,
+                                       buffer, j, buf_len, p, datatype_len);
+    }
 }
 
-static void H5Z_nbit_compress_one_array(unsigned char *data, size_t data_offset, unsigned char *buffer,
-                                 size_t *j, int *buf_len, const unsigned parms[])
+static void
+H5Z_nbit_compress_one_array(unsigned char *data, size_t data_offset,
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index)
 {
    unsigned i, total_size, base_class, base_size, n, begin_index;
    parms_atomic p;
 
-   total_size = parms[parms_index++];
-   base_class = parms[parms_index++];
+   total_size = parms[(*parms_index)++];
+   base_class = parms[(*parms_index)++];
 
    switch(base_class) {
       case H5Z_NBIT_ATOMIC:
-           p.size = parms[parms_index++];
-           p.order = parms[parms_index++];
-           p.precision = parms[parms_index++];
-           p.offset = parms[parms_index++];
-           n = total_size/p.size;
+           p.size = parms[(*parms_index)++];
+           p.order = parms[(*parms_index)++];
+           p.precision = parms[(*parms_index)++];
+           p.offset = parms[(*parms_index)++];
+           n = total_size / p.size;
            for(i = 0; i < n; i++)
-              H5Z_nbit_compress_one_atomic(data, data_offset + i*p.size,
-                                           buffer, j, buf_len, p);
+              H5Z_nbit_compress_one_atomic(data, data_offset + i * p.size,
+                                           buffer, j, buf_len, &p);
            break;
+
       case H5Z_NBIT_ARRAY:
-           base_size = parms[parms_index]; /* read in advance */
-           n = total_size/base_size; /* number of base_type elements inside the array datatype */
-           begin_index = parms_index;
+           base_size = parms[*parms_index]; /* read in advance */
+           n = total_size / base_size; /* number of base_type elements inside the array datatype */
+           begin_index = *parms_index;
            for(i = 0; i < n; i++) {
-              H5Z_nbit_compress_one_array(data, data_offset + i*base_size,
-                                          buffer, j, buf_len, parms);
-              parms_index = begin_index;
+              H5Z_nbit_compress_one_array(data, data_offset + i * base_size,
+                                          buffer, j, buf_len, parms, parms_index);
+              *parms_index = begin_index;
            }
            break;
+
       case H5Z_NBIT_COMPOUND:
-           base_size = parms[parms_index]; /* read in advance */
-           n = total_size/base_size; /* number of base_type elements inside the array datatype */
-           begin_index = parms_index;
+           base_size = parms[*parms_index]; /* read in advance */
+           n = total_size / base_size; /* number of base_type elements inside the array datatype */
+           begin_index = *parms_index;
            for(i = 0; i < n; i++) {
-              H5Z_nbit_compress_one_compound(data, data_offset + i*base_size,
-                                             buffer, j, buf_len, parms);
-              parms_index = begin_index;
+              H5Z_nbit_compress_one_compound(data, data_offset + i * base_size,
+                                             buffer, j, buf_len, parms, parms_index);
+              *parms_index = begin_index;
            }
            break;
+
       case H5Z_NBIT_NOOPTYPE:
-           parms_index++; /* skip size of no-op type */
+           (*parms_index)++; /* skip size of no-op type */
            H5Z_nbit_compress_one_nooptype(data, data_offset, buffer, j, buf_len, total_size);
            break;
+
       default:
           HDassert(0 && "This Should never be executed!");
    } /* end switch */
 }
 
-static void H5Z_nbit_compress_one_compound(unsigned char *data, size_t data_offset,
-            unsigned char *buffer, size_t *j, int *buf_len, const unsigned parms[])
+static void
+H5Z_nbit_compress_one_compound(unsigned char *data, size_t data_offset,
+    unsigned char *buffer, size_t *j, size_t *buf_len, const unsigned parms[],
+    unsigned *parms_index)
 {
    unsigned i, nmembers, member_offset, member_class, size;
    parms_atomic p;
 
-   parms_index++; /* skip size of compound datatype */
-   nmembers = parms[parms_index++];
+   (*parms_index)++; /* skip size of compound datatype */
+   nmembers = parms[(*parms_index)++];
 
    for(i = 0; i < nmembers; i++) {
-      member_offset = parms[parms_index++];
-      member_class = parms[parms_index++];
+      member_offset = parms[(*parms_index)++];
+      member_class = parms[(*parms_index)++];
 
       switch(member_class) {
          case H5Z_NBIT_ATOMIC:
-              p.size = parms[parms_index++];
-              p.order = parms[parms_index++];
-              p.precision = parms[parms_index++];
-              p.offset = parms[parms_index++];
+              p.size = parms[(*parms_index)++];
+              p.order = parms[(*parms_index)++];
+              p.precision = parms[(*parms_index)++];
+              p.offset = parms[(*parms_index)++];
               H5Z_nbit_compress_one_atomic(data, data_offset + member_offset,
-                                           buffer, j, buf_len, p);
+                                           buffer, j, buf_len, &p);
               break;
+
          case H5Z_NBIT_ARRAY:
               H5Z_nbit_compress_one_array(data, data_offset + member_offset,
-                                          buffer, j, buf_len, parms);
+                                          buffer, j, buf_len, parms, parms_index);
               break;
+
          case H5Z_NBIT_COMPOUND:
               H5Z_nbit_compress_one_compound(data, data_offset+member_offset,
-                                             buffer, j, buf_len, parms);
+                                             buffer, j, buf_len, parms, parms_index);
               break;
+
          case H5Z_NBIT_NOOPTYPE:
-              size = parms[parms_index++];
+              size = parms[(*parms_index)++];
               H5Z_nbit_compress_one_nooptype(data, data_offset+member_offset,
                                              buffer, j, buf_len, size);
               break;
+
          default:
              HDassert(0 && "This Should never be executed!");
       } /* end switch */
    }
 }
 
-static void H5Z_nbit_compress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
-                              size_t *buffer_size, const unsigned parms[])
+static void
+H5Z_nbit_compress(unsigned char *data, unsigned d_nelmts, unsigned char *buffer,
+    size_t *buffer_size, const unsigned parms[])
 {
-   /* i: index of data, new_size: index of buffer,
-      buf_len: number of bits to be filled in current byte */
-   size_t i, size;
-   size_t new_size = 0;
-   int buf_len;
-   parms_atomic p;
+    /* i: index of data, new_size: index of buffer,
+       buf_len: number of bits to be filled in current byte */
+    unsigned i;
+    size_t size;
+    size_t new_size = 0;
+    size_t buf_len;
+    parms_atomic p;
+    unsigned parms_index; /* index in array parms used by compression/decompression functions */
+
+    /* must initialize buffer to be zeros */
+    HDmemset(buffer, 0, *buffer_size);
+
+    /* initialization before the loop */
+    buf_len = sizeof(unsigned char) * 8;
+
+    switch(parms[3]) {
+       case H5Z_NBIT_ATOMIC:
+            p.size = parms[4];
+            p.order = parms[5];
+            p.precision = parms[6];
+            p.offset = parms[7];
+
+            for(i = 0; i < d_nelmts; i++)
+                H5Z_nbit_compress_one_atomic(data, i * p.size, buffer, &new_size, &buf_len, &p);
+            break;
 
-   /* must initialize buffer to be zeros */
-   HDmemset(buffer, 0, *buffer_size);
+       case H5Z_NBIT_ARRAY:
+            size = parms[4];
+            parms_index = 4;
+            for(i = 0; i < d_nelmts; i++) {
+                H5Z_nbit_compress_one_array(data, i * size, buffer, &new_size, &buf_len, parms, &parms_index);
+                parms_index = 4;
+            }
+            break;
 
-   /* initialization before the loop */
-   buf_len = sizeof(unsigned char) * 8;
+       case H5Z_NBIT_COMPOUND:
+            size = parms[4];
+            parms_index = 4;
+            for(i = 0; i < d_nelmts; i++) {
+                H5Z_nbit_compress_one_compound(data, i * size, buffer, &new_size, &buf_len, parms, &parms_index);
+                parms_index = 4;
+            }
+            break;
 
-   switch(parms[3]) {
-      case H5Z_NBIT_ATOMIC:
-           /* set the index before goto function call */
-           p.size = parms[4];
-           p.order = parms[5];
-           p.precision = parms[6];
-           p.offset = parms[7];
-
-           for(i = 0; i < d_nelmts; i++) {
-              H5Z_nbit_compress_one_atomic(data, i*p.size, buffer, &new_size, &buf_len, p);
-           }
-           break;
-      case H5Z_NBIT_ARRAY:
-           size = parms[4];
-           parms_index = 4;
-           for(i = 0; i < d_nelmts; i++) {
-              H5Z_nbit_compress_one_array(data, i*size, buffer, &new_size, &buf_len, parms);
-              parms_index = 4;
-           }
-           break;
-      case H5Z_NBIT_COMPOUND:
-           size = parms[4];
-           parms_index = 4;
-           for(i = 0; i < d_nelmts; i++) {
-              H5Z_nbit_compress_one_compound(data, i*size, buffer, &new_size, &buf_len, parms);
-              parms_index = 4;
-           }
-           break;
-       default:
-           HDassert(0 && "This Should never be executed!");
-   } /* end switch */
+        default:
+            HDassert(0 && "This Should never be executed!");
+    } /* end switch */
 
-   /* Update the size to the new value after compression.  If there are any bits hanging over in
-    * the last byte, increment the value by 1. */
-   *buffer_size = new_size + 1;
+    /* Update the size to the new value after compression.  If there are any bits hanging over in
+     * the last byte, increment the value by 1. */
+    *buffer_size = new_size + 1;
 }