Formats the source and updates the gcc warning pragmas

1 files changed, 158 insertions, 156 deletions

diff --git a/tools/src/h5repack/h5repack_parse.c b/tools/src/h5repack/h5repack_parse.c
index 95cacc1..2147a47 100644
--- a/tools/src/h5repack/h5repack_parse.c
+++ b/tools/src/h5repack/h5repack_parse.c
@@ -37,8 +37,9 @@
  * "A,B:NONE"
  *-------------------------------------------------------------------------
  */
-obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
-        pack_opt_t *options, int *is_glb) {
+obj_list_t *
+parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt, pack_opt_t *options, int *is_glb)
+{
     size_t      i, m, u;
     char        c;
     size_t      len = HDstrlen(str);
@@ -48,7 +49,7 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
     char        scomp[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     char        stype[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     char        smask[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-    obj_list_t* obj_list = NULL;
+    obj_list_t *obj_list  = NULL;
     unsigned    pixels_per_block;
 
     /* initialize compression  info */
@@ -59,7 +60,7 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
     for (i = 0, n = 0; i < len; i++) {
         c = str[i];
         if (c == ':') {
-            end_obj = (int) i;
+            end_obj = (int)i;
             break;
         }
         if (c == ',')
@@ -71,13 +72,13 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
     if (end_obj == -1) {
         /* apply to all objects */
         options->all_filter = 1;
-        *is_glb = 1;
-        *n_objs = 1;
+        *is_glb             = 1;
+        *n_objs             = 1;
     }
     else
         *n_objs = n;
 
-    obj_list = (obj_list_t *) HDmalloc(n * sizeof(obj_list_t));
+    obj_list = (obj_list_t *)HDmalloc(n * sizeof(obj_list_t));
     if (obj_list == NULL) {
         error_msg("could not allocate object list\n");
         return NULL;
@@ -85,10 +86,10 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
 
     /* get object list */
     if (end_obj > 0)
-        for (j = 0, k = 0, n = 0; j < (unsigned) end_obj; j++, k++) {
-            c = str[j];
+        for (j = 0, k = 0, n = 0; j < (unsigned)end_obj; j++, k++) {
+            c       = str[j];
             sobj[k] = c;
-            if (c == ',' || j == (unsigned) (end_obj - 1)) {
+            if (c == ',' || j == (unsigned)(end_obj - 1)) {
                 if (c == ',')
                     sobj[k] = '\0';
                 else
@@ -101,7 +102,7 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
             }
         }
     /* nothing after : */
-    if (end_obj + 1 == (int) len) {
+    if (end_obj + 1 == (int)len) {
         if (obj_list)
             HDfree(obj_list);
         error_msg("input Error: Invalid compression type in <%s>\n", str);
@@ -111,25 +112,25 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
     /* get filter additional parameters */
     m = 0;
     for (i = (size_t)(end_obj + 1), k = 0, j = 0; i < len; i++, k++) {
-        c = str[i];
+        c        = str[i];
         scomp[k] = c;
         if (c == '=' || i == len - 1) {
-            if (c == '=') { /*one more parameter */
+            if (c == '=') {      /*one more parameter */
                 scomp[k] = '\0'; /*cut space */
                 /*-------------------------------------------------------------------------
-                * H5Z_FILTER_SZIP
-                * szip has the format SZIP=<pixels per block,coding>
-                * pixels per block is a even number in 2-32 and coding method is 'EC' or 'NN'
-                * example SZIP=8,NN
-                *-------------------------------------------------------------------------
-                */
+                 * H5Z_FILTER_SZIP
+                 * szip has the format SZIP=<pixels per block,coding>
+                 * pixels per block is a even number in 2-32 and coding method is 'EC' or 'NN'
+                 * example SZIP=8,NN
+                 *-------------------------------------------------------------------------
+                 */
                 if (HDstrcmp(scomp, "SZIP") == 0) {
                     l = -1; /* mask index check */
                     for (m = 0, u = i + 1; u < len; u++, m++) {
                         if (str[u] == ',') {
                             stype[m] = '\0'; /* end digit of szip */
-                            l = 0; /* start EC or NN search */
-                            u++; /* skip ',' */
+                            l        = 0;    /* start EC or NN search */
+                            u++;             /* skip ',' */
                         }
                         c = str[u];
                         if (!HDisdigit(c) && l == -1) {
@@ -145,10 +146,10 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                             l++;
                             if (l == 2) {
                                 smask[l] = '\0';
-                                i = len - 1; /* end */
-                                if (HDstrcmp(smask,"NN") == 0)
+                                i        = len - 1; /* end */
+                                if (HDstrcmp(smask, "NN") == 0)
                                     filt->cd_values[j++] = H5_SZIP_NN_OPTION_MASK;
-                                else if (HDstrcmp(smask,"EC") == 0)
+                                else if (HDstrcmp(smask, "EC") == 0)
                                     filt->cd_values[j++] = H5_SZIP_EC_OPTION_MASK;
                                 else {
                                     error_msg("szip mask must be 'NN' or 'EC' \n");
@@ -157,29 +158,29 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                             }
                         }
                     } /* u */
-                } /*if */
+                }     /*if */
 
                 /*-------------------------------------------------------------------------
-                * H5Z_FILTER_SCALEOFFSET
-                * scaleoffset has the format SOFF=<scale_factor,scale_type>
-                * scale_type can be
-                *   integer datatype, H5Z_SO_INT (IN)
-                *   float datatype using D-scaling method, H5Z_SO_FLOAT_DSCALE  (DS)
-                *   float datatype using E-scaling method, H5Z_SO_FLOAT_ESCALE  (ES) , not yet implemented
-                * for integer datatypes, scale_factor denotes Minimum Bits
-                * for float datatypes, scale_factor denotes decimal scale factor
-                *  examples
-                *  SOFF=31,IN
-                *  SOFF=3,DF
-                *-------------------------------------------------------------------------
-                */
+                 * H5Z_FILTER_SCALEOFFSET
+                 * scaleoffset has the format SOFF=<scale_factor,scale_type>
+                 * scale_type can be
+                 *   integer datatype, H5Z_SO_INT (IN)
+                 *   float datatype using D-scaling method, H5Z_SO_FLOAT_DSCALE  (DS)
+                 *   float datatype using E-scaling method, H5Z_SO_FLOAT_ESCALE  (ES) , not yet implemented
+                 * for integer datatypes, scale_factor denotes Minimum Bits
+                 * for float datatypes, scale_factor denotes decimal scale factor
+                 *  examples
+                 *  SOFF=31,IN
+                 *  SOFF=3,DF
+                 *-------------------------------------------------------------------------
+                 */
                 else if (HDstrcmp(scomp, "SOFF") == 0) {
                     l = -1; /* mask index check */
                     for (m = 0, u = i + 1; u < len; u++, m++) {
                         if (str[u] == ',') {
                             stype[m] = '\0'; /* end digit */
-                            l = 0; /* start 'IN' , 'DS', or 'ES' search */
-                            u++; /* skip ',' */
+                            l        = 0;    /* start 'IN' , 'DS', or 'ES' search */
+                            u++;             /* skip ',' */
                         }
                         c = str[u];
                         if (!HDisdigit(c) && l == -1) {
@@ -195,8 +196,8 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                             l++;
                             if (l == 2) {
                                 smask[l] = '\0';
-                                i = len - 1; /* end */
-                                if (HDstrcmp(smask,"IN") == 0)
+                                i        = len - 1; /* end */
+                                if (HDstrcmp(smask, "IN") == 0)
                                     filt->cd_values[j++] = H5Z_SO_INT;
                                 else if (HDstrcmp(smask, "DS") == H5Z_SO_FLOAT_DSCALE)
                                     filt->cd_values[j++] = H5Z_SO_FLOAT_DSCALE;
@@ -207,15 +208,15 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                             }
                         }
                     } /* u */
-                } /*if */
+                }     /*if */
 
                 /*-------------------------------------------------------------------------
-                * User Defined
-                *   has the format UD=<filter_number,filter_flag,cd_value_count,value_1[,value_2,...,value_N]>
-                *  BZIP2 example
-                *  UD=307,0,1,9
-                *-------------------------------------------------------------------------
-                */
+                 * User Defined
+                 *   has the format
+                 *UD=<filter_number,filter_flag,cd_value_count,value_1[,value_2,...,value_N]> BZIP2 example
+                 *  UD=307,0,1,9
+                 *-------------------------------------------------------------------------
+                 */
                 else if (HDstrcmp(scomp, "UD") == 0) {
                     l = -1; /* filter number index check */
                     f = -1; /* filter flag index check */
@@ -225,15 +226,15 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                             stype[q] = '\0'; /* end digit */
                             if (l == -1) {
                                 filt->filtn = HDatoi(stype);
-                                l = 0;
+                                l           = 0;
                             }
                             else if (f == -1) {
                                 filt->filt_flag = (unsigned)HDstrtoul(stype, NULL, 0);
-                                f = 0;
+                                f               = 0;
                             }
                             else if (p == -1) {
                                 filt->cd_nelmts = HDstrtoull(stype, NULL, 0);
-                                p = 0;
+                                p               = 0;
                             }
                             else {
                                 filt->cd_values[j++] = (unsigned)HDstrtoul(stype, NULL, 0);
@@ -260,9 +261,9 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                 } /*if */
 
                 /*-------------------------------------------------------------------------
-                * all other filters
-                *-------------------------------------------------------------------------
-                */
+                 * all other filters
+                 *-------------------------------------------------------------------------
+                 */
                 else {
                     /* here we could have 1 or 2 digits  */
                     for (m = 0, u = i + 1; u < len; u++, m++) {
@@ -279,36 +280,36 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                     stype[m] = '\0';
                 } /*if */
 
-                filt->cd_values[j++] = (unsigned) HDstrtoul(stype, NULL, 0);
-                if(filt->cd_nelmts == 0)
+                filt->cd_values[j++] = (unsigned)HDstrtoul(stype, NULL, 0);
+                if (filt->cd_nelmts == 0)
                     j = 0;
                 i += m; /* jump */
             }
             else if (i == len - 1) { /*no more parameters */
                 scomp[k + 1] = '\0';
-                no_param = 1;
+                no_param     = 1;
             }
 
             /*-------------------------------------------------------------------------
-            * translate from string to filter symbol
-            *-------------------------------------------------------------------------
-            */
+             * translate from string to filter symbol
+             *-------------------------------------------------------------------------
+             */
 
             /*-------------------------------------------------------------------------
-            * H5Z_FILTER_NONE
-            *-------------------------------------------------------------------------
-            */
+             * H5Z_FILTER_NONE
+             *-------------------------------------------------------------------------
+             */
             if (HDstrcmp(scomp, "NONE") == 0) {
-                filt->filtn = H5Z_FILTER_NONE;
+                filt->filtn     = H5Z_FILTER_NONE;
                 filt->cd_nelmts = 0;
             }
 
             /*-------------------------------------------------------------------------
-            * H5Z_FILTER_DEFLATE
-            *-------------------------------------------------------------------------
-            */
+             * H5Z_FILTER_DEFLATE
+             *-------------------------------------------------------------------------
+             */
             else if (HDstrcmp(scomp, "GZIP") == 0) {
-                filt->filtn = H5Z_FILTER_DEFLATE;
+                filt->filtn     = H5Z_FILTER_DEFLATE;
                 filt->cd_nelmts = 1;
                 if (no_param) { /*no more parameters, GZIP must have parameter */
                     if (obj_list)
@@ -319,11 +320,11 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
             }
 
             /*-------------------------------------------------------------------------
-            * H5Z_FILTER_SZIP
-            *-------------------------------------------------------------------------
-            */
+             * H5Z_FILTER_SZIP
+             *-------------------------------------------------------------------------
+             */
             else if (HDstrcmp(scomp, "SZIP") == 0) {
-                filt->filtn = H5Z_FILTER_SZIP;
+                filt->filtn     = H5Z_FILTER_SZIP;
                 filt->cd_nelmts = 2;
                 if (no_param) { /*no more parameters, SZIP must have parameter */
                     if (obj_list)
@@ -334,11 +335,11 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
             }
 
             /*-------------------------------------------------------------------------
-            * H5Z_FILTER_SHUFFLE
-            *-------------------------------------------------------------------------
-            */
+             * H5Z_FILTER_SHUFFLE
+             *-------------------------------------------------------------------------
+             */
             else if (HDstrcmp(scomp, "SHUF") == 0) {
-                filt->filtn = H5Z_FILTER_SHUFFLE;
+                filt->filtn     = H5Z_FILTER_SHUFFLE;
                 filt->cd_nelmts = 0;
                 if (m > 0) { /*shuffle does not have parameter */
                     if (obj_list)
@@ -348,11 +349,11 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                 }
             }
             /*-------------------------------------------------------------------------
-            * H5Z_FILTER_FLETCHER32
-            *-------------------------------------------------------------------------
-            */
+             * H5Z_FILTER_FLETCHER32
+             *-------------------------------------------------------------------------
+             */
             else if (HDstrcmp(scomp, "FLET") == 0) {
-                filt->filtn = H5Z_FILTER_FLETCHER32;
+                filt->filtn     = H5Z_FILTER_FLETCHER32;
                 filt->cd_nelmts = 0;
                 if (m > 0) { /*shuffle does not have parameter */
                     if (obj_list)
@@ -362,11 +363,11 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                 }
             }
             /*-------------------------------------------------------------------------
-            * H5Z_FILTER_NBIT
-            *-------------------------------------------------------------------------
-            */
+             * H5Z_FILTER_NBIT
+             *-------------------------------------------------------------------------
+             */
             else if (HDstrcmp(scomp, "NBIT") == 0) {
-                filt->filtn = H5Z_FILTER_NBIT;
+                filt->filtn     = H5Z_FILTER_NBIT;
                 filt->cd_nelmts = 0;
                 if (m > 0) { /*nbit does not have parameter */
                     if (obj_list)
@@ -376,11 +377,11 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                 }
             }
             /*-------------------------------------------------------------------------
-            * H5Z_FILTER_SCALEOFFSET
-            *-------------------------------------------------------------------------
-            */
+             * H5Z_FILTER_SCALEOFFSET
+             *-------------------------------------------------------------------------
+             */
             else if (HDstrcmp(scomp, "SOFF") == 0) {
-                filt->filtn = H5Z_FILTER_SCALEOFFSET;
+                filt->filtn     = H5Z_FILTER_SCALEOFFSET;
                 filt->cd_nelmts = 2;
                 if (no_param) { /*no more parameters, SOFF must have parameter */
                     if (obj_list)
@@ -390,9 +391,9 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                 }
             }
             /*-------------------------------------------------------------------------
-            * User Defined Filter
-            *-------------------------------------------------------------------------
-            */
+             * User Defined Filter
+             *-------------------------------------------------------------------------
+             */
             else if (HDstrcmp(scomp, "UD") == 0) {
                 /* parameters does not match count */
                 if (filt->cd_nelmts != j) {
@@ -413,56 +414,55 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
     } /*i*/
 
     /*-------------------------------------------------------------------------
-    * check valid parameters
-    *-------------------------------------------------------------------------
-    */
+     * check valid parameters
+     *-------------------------------------------------------------------------
+     */
 
     switch (filt->filtn) {
-    /*-------------------------------------------------------------------------
-    * H5Z_FILTER_DEFLATE
-    *-------------------------------------------------------------------------
-    */
-    case H5Z_FILTER_DEFLATE:
-        if (filt->cd_values[0] > 9) {
-            if (obj_list)
-                HDfree(obj_list);
-            error_msg("invalid compression parameter in <%s>\n", str);
-            HDexit(EXIT_FAILURE);
-        }
-        break;
         /*-------------------------------------------------------------------------
-        * H5Z_FILTER_SZIP
-        *-------------------------------------------------------------------------
-        */
-    case H5Z_FILTER_SZIP:
-        pixels_per_block = filt->cd_values[0];
-        if ((pixels_per_block % 2) == 1) {
-            if (obj_list)
-                HDfree(obj_list);
-            error_msg("pixels_per_block is not even in <%s>\n", str);
-            HDexit(EXIT_FAILURE);
-        }
-        if (pixels_per_block > H5_SZIP_MAX_PIXELS_PER_BLOCK) {
-            if (obj_list)
-                HDfree(obj_list);
-            error_msg("pixels_per_block is too large in <%s>\n", str);
-            HDexit(EXIT_FAILURE);
-        }
-        if ((HDstrcmp(smask,"NN") != 0) && (HDstrcmp(smask,"EC") != 0)) {
-            if (obj_list)
-                HDfree(obj_list);
-            error_msg("szip mask must be 'NN' or 'EC' \n");
-            HDexit(EXIT_FAILURE);
-        }
-        break;
-    default:
-        break;
+         * H5Z_FILTER_DEFLATE
+         *-------------------------------------------------------------------------
+         */
+        case H5Z_FILTER_DEFLATE:
+            if (filt->cd_values[0] > 9) {
+                if (obj_list)
+                    HDfree(obj_list);
+                error_msg("invalid compression parameter in <%s>\n", str);
+                HDexit(EXIT_FAILURE);
+            }
+            break;
+            /*-------------------------------------------------------------------------
+             * H5Z_FILTER_SZIP
+             *-------------------------------------------------------------------------
+             */
+        case H5Z_FILTER_SZIP:
+            pixels_per_block = filt->cd_values[0];
+            if ((pixels_per_block % 2) == 1) {
+                if (obj_list)
+                    HDfree(obj_list);
+                error_msg("pixels_per_block is not even in <%s>\n", str);
+                HDexit(EXIT_FAILURE);
+            }
+            if (pixels_per_block > H5_SZIP_MAX_PIXELS_PER_BLOCK) {
+                if (obj_list)
+                    HDfree(obj_list);
+                error_msg("pixels_per_block is too large in <%s>\n", str);
+                HDexit(EXIT_FAILURE);
+            }
+            if ((HDstrcmp(smask, "NN") != 0) && (HDstrcmp(smask, "EC") != 0)) {
+                if (obj_list)
+                    HDfree(obj_list);
+                error_msg("szip mask must be 'NN' or 'EC' \n");
+                HDexit(EXIT_FAILURE);
+            }
+            break;
+        default:
+            break;
     };
 
     return obj_list;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: parse_layout
  *
@@ -484,9 +484,11 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
  *
  *-------------------------------------------------------------------------
  */
-obj_list_t* parse_layout(const char *str, unsigned *n_objs, pack_info_t *pack, /* info about layout needed */
-pack_opt_t *options) {
-    obj_list_t* obj_list = NULL;
+obj_list_t *
+parse_layout(const char *str, unsigned *n_objs, pack_info_t *pack, /* info about layout needed */
+             pack_opt_t *options)
+{
+    obj_list_t *obj_list = NULL;
     unsigned    i, j, n;
     char        c;
     size_t      len = HDstrlen(str);
@@ -503,7 +505,7 @@ pack_opt_t *options) {
     for (i = 0, n = 0; i < len; i++) {
         c = str[i];
         if (c == ':')
-            end_obj = (int) i;
+            end_obj = (int)i;
         if (c == ',')
             n++;
     }
@@ -513,7 +515,7 @@ pack_opt_t *options) {
     }
 
     n++;
-    obj_list = (obj_list_t*) HDmalloc(n * sizeof(obj_list_t));
+    obj_list = (obj_list_t *)HDmalloc(n * sizeof(obj_list_t));
     if (obj_list == NULL) {
         error_msg("could not allocate object list\n");
         return NULL;
@@ -522,10 +524,10 @@ pack_opt_t *options) {
 
     /* get object list */
     if (end_obj > 0)
-        for (j = 0, k = 0, n = 0; j < (unsigned) end_obj; j++, k++) {
-            c = str[j];
+        for (j = 0, k = 0, n = 0; j < (unsigned)end_obj; j++, k++) {
+            c       = str[j];
             sobj[k] = c;
-            if (c == ',' || j == (unsigned) (end_obj - 1)) {
+            if (c == ',' || j == (unsigned)(end_obj - 1)) {
                 if (c == ',')
                     sobj[k] = '\0';
                 else
@@ -538,7 +540,7 @@ pack_opt_t *options) {
         }
 
     /* nothing after : */
-    if (end_obj + 1 == (int) len) {
+    if (end_obj + 1 == (int)len) {
         if (obj_list)
             HDfree(obj_list);
         error_msg("in parse layout, no characters after : in <%s>\n", str);
@@ -546,7 +548,7 @@ pack_opt_t *options) {
     }
 
     /* get layout info */
-    for (j = (unsigned) (end_obj + 1), n = 0; n <= 5; j++, n++) {
+    for (j = (unsigned)(end_obj + 1), n = 0; n <= 5; j++, n++) {
         if (n == 5) {
             slayout[n] = '\0'; /*cut string */
             if (HDstrcmp(slayout, "COMPA") == 0)
@@ -561,16 +563,16 @@ pack_opt_t *options) {
             }
         }
         else {
-            c = str[j];
+            c          = str[j];
             slayout[n] = c;
         }
     } /* j */
 
     if (pack->layout == H5D_CHUNKED) {
         /*-------------------------------------------------------------------------
-        * get chunk info
-        *-------------------------------------------------------------------------
-        */
+         * get chunk info
+         *-------------------------------------------------------------------------
+         */
         k = 0;
         if (j > len) {
             if (obj_list)
@@ -580,7 +582,7 @@ pack_opt_t *options) {
         }
 
         for (i = j, c_index = 0; i < len; i++) {
-            c = str[i];
+            c       = str[i];
             sdim[k] = c;
             k++; /*increment sdim index */
 
@@ -593,8 +595,8 @@ pack_opt_t *options) {
 
             if (c == 'x' || i == len - 1) {
                 if (c == 'x') {
-                    sdim[k - 1] = '\0';
-                    k = 0;
+                    sdim[k - 1]                        = '\0';
+                    k                                  = 0;
                     pack->chunk.chunk_lengths[c_index] = HDstrtoull(sdim, NULL, 0);
                     if (pack->chunk.chunk_lengths[c_index] == 0) {
                         if (obj_list)
@@ -606,8 +608,8 @@ pack_opt_t *options) {
                 }
                 else if (i == len - 1) { /*no more parameters */
                     sdim[k] = '\0';
-                    k = 0;
-                    if (HDstrcmp(sdim,"NONE") == 0) {
+                    k       = 0;
+                    if (HDstrcmp(sdim, "NONE") == 0) {
                         pack->chunk.rank = -2;
                     }
                     else {
@@ -621,9 +623,9 @@ pack_opt_t *options) {
                         pack->chunk.rank = c_index + 1;
                     }
                 } /*if */
-            } /*if c=='x' || i==len-1 */
-        } /*i*/
-    } /*H5D_CHUNKED*/
+            }     /*if c=='x' || i==len-1 */
+        }         /*i*/
+    }             /*H5D_CHUNKED*/
 
     return obj_list;
 }