Add .clang-format and bin/format_source from hdf5_1_12_1. (#822)

Reformat source with clang 10.0.1.

1 files changed, 524 insertions, 529 deletions

diff --git a/tools/lib/h5tools_str.c b/tools/lib/h5tools_str.c
index 6515ecd..10cbda8 100644
--- a/tools/lib/h5tools_str.c
+++ b/tools/lib/h5tools_str.c
@@ -15,17 +15,17 @@
  * Purpose: These are string functions for us to use and abuse.
  */
 #include "H5private.h"
-#include "h5tools.h"            /* for h5tool_format_t structure */
+#include "h5tools.h" /* for h5tool_format_t structure */
 #include "h5tools_ref.h"
-#include "h5tools_str.h"        /* function prototypes */
+#include "h5tools_str.h" /* function prototypes */
 
 /* Copied from hl/src/H5LDprivate.h */
 /* Info about the list of comma-separated compound fields */
 typedef struct H5LD_memb_t {
-    size_t    tot_offset;
-    size_t    last_tsize;
-    hid_t     last_tid;
-    char    **names;
+    size_t tot_offset;
+    size_t last_tsize;
+    hid_t  last_tid;
+    char **names;
 } H5LD_memb_t;
 
 /*
@@ -42,12 +42,12 @@ typedef struct H5LD_memb_t {
 #define REPEAT_VERBOSE
 
 /* Variable length string datatype */
-#define STR_INIT_LEN    4096    /*initial length            */
+#define STR_INIT_LEN 4096 /*initial length            */
 
-static char    *h5tools_escape(char *s, size_t size);
-static hbool_t  h5tools_str_is_zero(const void *_mem, size_t size);
-static void     h5tools_print_char(h5tools_str_t *str, const h5tool_format_t *info, char ch);
-void            h5tools_str_indent(h5tools_str_t *str, const h5tool_format_t *info, h5tools_context_t *ctx);
+static char *  h5tools_escape(char *s, size_t size);
+static hbool_t h5tools_str_is_zero(const void *_mem, size_t size);
+static void    h5tools_print_char(h5tools_str_t *str, const h5tool_format_t *info, char ch);
+void           h5tools_str_indent(h5tools_str_t *str, const h5tool_format_t *info, h5tools_context_t *ctx);
 
 /*-------------------------------------------------------------------------
  * Function:    h5tools_str_close
@@ -105,23 +105,23 @@ h5tools_str_len(h5tools_str_t *str)
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_append(h5tools_str_t *str/*in,out*/, const char *fmt, ...)
+h5tools_str_append(h5tools_str_t *str /*in,out*/, const char *fmt, ...)
 {
-    va_list    ap;
+    va_list ap;
 
     /* Make sure we have some memory into which to print */
-    if(!str->s || str->nalloc <= 0)
+    if (!str->s || str->nalloc <= 0)
         h5tools_str_reset(str);
 
-    if(HDstrlen(fmt) == 0)
+    if (HDstrlen(fmt) == 0)
         /* nothing to print */
         return str->s;
 
     /* Format the arguments and append to the value already in `str' */
-    while(1) {
+    while (1) {
         /* How many bytes available for new value, counting the new NUL */
         int    nchars = -1;
-        size_t avail = str->nalloc - str->len;
+        size_t avail  = str->nalloc - str->len;
 
         HDva_start(ap, fmt);
         nchars = HDvsnprintf(str->s + str->len, avail, fmt, ap);
@@ -138,11 +138,11 @@ h5tools_str_append(h5tools_str_t *str/*in,out*/, const char *fmt, ...)
          * to lack of buffer size, so try one more time after realloc more
          * buffer size before return NULL.
          */
-        if(nchars < 0)
+        if (nchars < 0)
             /* failure, such as bad format */
             return NULL;
 
-        if((size_t) nchars >= avail || (0 == nchars && (HDstrcmp(fmt, "%s")))) {
+        if ((size_t)nchars >= avail || (0 == nchars && (HDstrcmp(fmt, "%s")))) {
             /* Truncation return value as documented by C99, or zero return value with either of the
              * following conditions, each of which indicates that the proper C99 return value probably
              *  should have been positive when the format string is
@@ -151,7 +151,7 @@ h5tools_str_append(h5tools_str_t *str/*in,out*/, const char *fmt, ...)
              */
             size_t newsize = MAX(str->len + (size_t)nchars + 1, 2 * str->nalloc);
             HDassert(newsize > str->nalloc); /*overflow*/
-            str->s = (char*)HDrealloc(str->s, newsize);
+            str->s = (char *)HDrealloc(str->s, newsize);
             HDassert(str->s);
             str->nalloc = newsize;
         }
@@ -180,16 +180,16 @@ h5tools_str_append(h5tools_str_t *str/*in,out*/, const char *fmt, ...)
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_reset(h5tools_str_t *str/*in,out*/)
+h5tools_str_reset(h5tools_str_t *str /*in,out*/)
 {
-    if(!str->s || str->nalloc <= 0) {
+    if (!str->s || str->nalloc <= 0) {
         str->nalloc = STR_INIT_LEN;
-        str->s = (char*)HDmalloc(str->nalloc);
+        str->s      = (char *)HDmalloc(str->nalloc);
         HDassert(str->s);
     }
 
     str->s[0] = '\0';
-    str->len = 0;
+    str->len  = 0;
     return str->s;
 }
 
@@ -207,10 +207,10 @@ h5tools_str_reset(h5tools_str_t *str/*in,out*/)
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_trunc(h5tools_str_t *str/*in,out*/, size_t size)
+h5tools_str_trunc(h5tools_str_t *str /*in,out*/, size_t size)
 {
-    if(size < str->len) {
-        str->len = size;
+    if (size < str->len) {
+        str->len     = size;
         str->s[size] = '\0';
     }
 
@@ -235,26 +235,26 @@ h5tools_str_trunc(h5tools_str_t *str/*in,out*/, size_t size)
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_fmt(h5tools_str_t *str/*in,out*/, size_t start, const char *fmt)
+h5tools_str_fmt(h5tools_str_t *str /*in,out*/, size_t start, const char *fmt)
 {
-    char    _temp[1024], *temp = _temp;
+    char _temp[1024], *temp = _temp;
 
     HDassert(str);
     HDassert(fmt);
 
     /* If the format string is simply "%s" then don't bother doing anything */
-    if(!HDstrcmp(fmt, "%s"))
+    if (!HDstrcmp(fmt, "%s"))
         return str->s;
 
     /*
      * Save the input value if there is a `%' anywhere in FMT.  Otherwise
      * don't bother because we don't need a temporary copy.
      */
-    if(HDstrchr(fmt, '%')) {
+    if (HDstrchr(fmt, '%')) {
         size_t n = sizeof(_temp);
-        if(str->len - start + 1 > n) {
-            n = str->len - start + 1;
-            temp = (char*)HDmalloc(n);
+        if (str->len - start + 1 > n) {
+            n    = str->len - start + 1;
+            temp = (char *)HDmalloc(n);
             HDassert(temp);
         }
 
@@ -266,7 +266,7 @@ h5tools_str_fmt(h5tools_str_t *str/*in,out*/, size_t start, const char *fmt)
     h5tools_str_append(str, fmt, temp);
 
     /* Free the temp buffer if we allocated one */
-    if(temp != _temp)
+    if (temp != _temp)
         HDfree(temp);
 
     return str->s;
@@ -286,11 +286,11 @@ h5tools_str_fmt(h5tools_str_t *str/*in,out*/, size_t start, const char *fmt)
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_prefix(h5tools_str_t *str/*in,out*/, const h5tool_format_t *info,
-    hsize_t elmtno, unsigned ndims, h5tools_context_t *ctx)
+h5tools_str_prefix(h5tools_str_t *str /*in,out*/, const h5tool_format_t *info, hsize_t elmtno, unsigned ndims,
+                   h5tools_context_t *ctx)
 {
-    size_t    i = 0;
-    hsize_t   curr_pos = elmtno;
+    size_t  i        = 0;
+    hsize_t curr_pos = elmtno;
 
     H5TOOLS_START_DEBUG("");
 
@@ -298,30 +298,29 @@ h5tools_str_prefix(h5tools_str_t *str/*in,out*/, const h5tool_format_t *info,
     h5tools_str_reset(str);
 
     H5TOOLS_DEBUG("ndims=%d", ndims);
-    if(ndims > 0) {
+    if (ndims > 0) {
         /*
          * Calculate the number of elements represented by a unit change in a
          * certain index position.
          */
-        for(i = 0; i < (size_t) ndims; i++) {
+        for (i = 0; i < (size_t)ndims; i++) {
             H5TOOLS_DEBUG("curr_pos=%ld - ctx->acc[%d]=%ld", curr_pos, i, ctx->acc[i]);
             ctx->pos[i] = curr_pos / ctx->acc[i];
             curr_pos -= ctx->acc[i] * ctx->pos[i];
-            H5TOOLS_DEBUG("curr_pos=%ld - ctx->pos[%d]=%ld - ctx->acc[%d]=%ld", curr_pos, i, ctx->pos[i], i, ctx->acc[i]);
+            H5TOOLS_DEBUG("curr_pos=%ld - ctx->pos[%d]=%ld - ctx->acc[%d]=%ld", curr_pos, i, ctx->pos[i], i,
+                          ctx->acc[i]);
         }
         HDassert(curr_pos == 0);
 
         /* Print the index values */
-        for(i = 0; i < (size_t) ndims; i++) {
+        for (i = 0; i < (size_t)ndims; i++) {
             if (i)
                 h5tools_str_append(str, "%s", OPT(info->idx_sep, ","));
 
-            h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT),
-                    (hsize_t) ctx->pos[i]);
-
+            h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t)ctx->pos[i]);
         }
     }
-    else        /* Scalar */
+    else /* Scalar */
         h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t)elmtno);
     H5TOOLS_DEBUG("str=%s", str->s);
 
@@ -345,45 +344,43 @@ h5tools_str_prefix(h5tools_str_t *str/*in,out*/, const h5tool_format_t *info,
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_region_prefix(h5tools_str_t *str, const h5tool_format_t *info,
-        hsize_t elmtno, hsize_t *ptdata, unsigned ndims, hsize_t max_idx[],
-        h5tools_context_t *ctx)
+h5tools_str_region_prefix(h5tools_str_t *str, const h5tool_format_t *info, hsize_t elmtno, hsize_t *ptdata,
+                          unsigned ndims, hsize_t max_idx[], h5tools_context_t *ctx)
 {
-    size_t    i = 0;
-    hsize_t   curr_pos = elmtno;
-    hsize_t   p_prod[H5S_MAX_RANK];
+    size_t  i        = 0;
+    hsize_t curr_pos = elmtno;
+    hsize_t p_prod[H5S_MAX_RANK];
 
     h5tools_str_reset(str);
 
-    if(ndims > 0) {
+    if (ndims > 0) {
         /*
          * Calculate the number of elements represented by a unit change in a
          * certain index position.
          */
-        for(i = ndims - 1, p_prod[ndims - 1] = 1; i > 0; --i)
+        for (i = ndims - 1, p_prod[ndims - 1] = 1; i > 0; --i)
             p_prod[i - 1] = (max_idx[i]) * p_prod[i];
 
-        for(i = 0; i < (size_t) ndims; i++) {
-            if(curr_pos > 0) {
+        for (i = 0; i < (size_t)ndims; i++) {
+            if (curr_pos > 0) {
                 ctx->pos[i] = curr_pos / p_prod[i];
                 curr_pos -= p_prod[i] * ctx->pos[i];
             }
             else
                 ctx->pos[i] = 0;
-            ctx->pos[i] += (unsigned long) ptdata[ctx->sm_pos+i];
+            ctx->pos[i] += (unsigned long)ptdata[ctx->sm_pos + i];
         }
 
         /* Print the index values */
-        for(i = 0; i < (size_t) ndims; i++) {
-            if(i)
+        for (i = 0; i < (size_t)ndims; i++) {
+            if (i)
                 h5tools_str_append(str, "%s", OPT(info->idx_sep, ","));
 
-            h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t) ctx->pos[i]);
-
+            h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t)ctx->pos[i]);
         }
-    } /* if (ndims > 0) */
-    else        /* Scalar */
-        h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t) 0);
+    }    /* if (ndims > 0) */
+    else /* Scalar */
+        h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t)0);
 
     /* Add prefix and suffix to the index */
     return h5tools_str_fmt(str, (size_t)0, OPT(info->idx_fmt, "%s: "));
@@ -403,15 +400,15 @@ h5tools_str_region_prefix(h5tools_str_t *str, const h5tool_format_t *info,
  *-------------------------------------------------------------------------
  */
 void
-h5tools_str_dump_space_slabs(h5tools_str_t *str, hid_t rspace,
-        const h5tool_format_t *info, h5tools_context_t *ctx)
+h5tools_str_dump_space_slabs(h5tools_str_t *str, hid_t rspace, const h5tool_format_t *info,
+                             h5tools_context_t *ctx)
 {
-    hsize_t   start[H5S_MAX_RANK];
-    hsize_t   stride[H5S_MAX_RANK];
-    hsize_t   count[H5S_MAX_RANK];
-    hsize_t   block[H5S_MAX_RANK];
-    int       j;
-    int       ndims = H5Sget_simple_extent_ndims(rspace);
+    hsize_t start[H5S_MAX_RANK];
+    hsize_t stride[H5S_MAX_RANK];
+    hsize_t count[H5S_MAX_RANK];
+    hsize_t block[H5S_MAX_RANK];
+    int     j;
+    int     ndims = H5Sget_simple_extent_ndims(rspace);
 
     H5Sget_regular_hyperslab(rspace, start, stride, count, block);
 
@@ -419,7 +416,7 @@ h5tools_str_dump_space_slabs(h5tools_str_t *str, hid_t rspace,
 
     /* Start coordinates */
     h5tools_str_append(str, "%s%s ", info->line_indent, START);
-    for(j = 0; j < ndims; j++)
+    for (j = 0; j < ndims; j++)
         h5tools_str_append(str, "%s" HSIZE_T_FORMAT, j ? "," : "(", start[j]);
     h5tools_str_append(str, ")");
     h5tools_str_append(str, "%s", "\n");
@@ -427,7 +424,7 @@ h5tools_str_dump_space_slabs(h5tools_str_t *str, hid_t rspace,
 
     /* Stride coordinates */
     h5tools_str_append(str, "%s ", STRIDE);
-    for(j = 0; j < ndims; j++)
+    for (j = 0; j < ndims; j++)
         h5tools_str_append(str, "%s" HSIZE_T_FORMAT, j ? "," : "(", stride[j]);
     h5tools_str_append(str, ")");
     h5tools_str_append(str, "%s", "\n");
@@ -435,9 +432,9 @@ h5tools_str_dump_space_slabs(h5tools_str_t *str, hid_t rspace,
 
     /* Count coordinates */
     h5tools_str_append(str, "%s ", COUNT);
-    for(j = 0; j < ndims; j++) {
-        if(count[j] == H5S_UNLIMITED)
-            h5tools_str_append(str, "%s%s", j ? "," : "(","H5S_UNLIMITED");
+    for (j = 0; j < ndims; j++) {
+        if (count[j] == H5S_UNLIMITED)
+            h5tools_str_append(str, "%s%s", j ? "," : "(", "H5S_UNLIMITED");
         else
             h5tools_str_append(str, "%s" HSIZE_T_FORMAT, j ? "," : "(", count[j]);
     }
@@ -447,9 +444,9 @@ h5tools_str_dump_space_slabs(h5tools_str_t *str, hid_t rspace,
 
     /* Block coordinates */
     h5tools_str_append(str, "%s ", BLOCK);
-    for(j = 0; j < ndims; j++) {
-        if(block[j] == H5S_UNLIMITED)
-            h5tools_str_append(str, "%s%s", j ? "," : "(","H5S_UNLIMITED");
+    for (j = 0; j < ndims; j++) {
+        if (block[j] == H5S_UNLIMITED)
+            h5tools_str_append(str, "%s%s", j ? "," : "(", "H5S_UNLIMITED");
         else
             h5tools_str_append(str, "%s" HSIZE_T_FORMAT, j ? "," : "(", block[j]);
     }
@@ -468,45 +465,46 @@ h5tools_str_dump_space_slabs(h5tools_str_t *str, hid_t rspace,
  *-------------------------------------------------------------------------
  */
 void
-h5tools_str_dump_space_blocks(h5tools_str_t *str, hid_t rspace,
-        const h5tool_format_t *info)
+h5tools_str_dump_space_blocks(h5tools_str_t *str, hid_t rspace, const h5tool_format_t *info)
 {
-    hssize_t   snblocks;
+    hssize_t snblocks;
 
     /*
      * This function fails if the rspace does not have blocks.
      */
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY
+    {
         snblocks = H5Sget_select_hyper_nblocks(rspace);
-    } H5E_END_TRY;
+    }
+    H5E_END_TRY;
 
     /* Print block information */
-    if(snblocks > 0) {
-        hsize_t    alloc_size;
-        hsize_t    nblocks;
-        hsize_t   *ptdata;
-        hsize_t    u;
-        unsigned   ndims = (unsigned)H5Sget_simple_extent_ndims(rspace);
-
-        nblocks = (hsize_t)snblocks;
+    if (snblocks > 0) {
+        hsize_t  alloc_size;
+        hsize_t  nblocks;
+        hsize_t *ptdata;
+        hsize_t  u;
+        unsigned ndims = (unsigned)H5Sget_simple_extent_ndims(rspace);
+
+        nblocks    = (hsize_t)snblocks;
         alloc_size = nblocks * ndims * 2 * sizeof(ptdata[0]);
-        HDassert(alloc_size == (hsize_t) ((size_t) alloc_size)); /*check for overflow*/
-        ptdata = (hsize_t *)HDmalloc((size_t) alloc_size);
+        HDassert(alloc_size == (hsize_t)((size_t)alloc_size)); /*check for overflow*/
+        ptdata = (hsize_t *)HDmalloc((size_t)alloc_size);
         H5Sget_select_hyper_blocklist(rspace, (hsize_t)0, nblocks, ptdata);
 
-        for(u = 0; u < nblocks; u++) {
+        for (u = 0; u < nblocks; u++) {
             unsigned v;
 
-            h5tools_str_append(str, info->dset_blockformat_pre, u ? "," OPTIONAL_LINE_BREAK " " : "", (unsigned long)u);
+            h5tools_str_append(str, info->dset_blockformat_pre, u ? "," OPTIONAL_LINE_BREAK " " : "",
+                               (unsigned long)u);
 
             /* Start coordinates and opposite corner */
-            for(v = 0; v < ndims; v++)
-                h5tools_str_append(str, "%s" HSIZE_T_FORMAT, v ? "," : "(",
-                                    ptdata[u * 2 * ndims + v]);
+            for (v = 0; v < ndims; v++)
+                h5tools_str_append(str, "%s" HSIZE_T_FORMAT, v ? "," : "(", ptdata[u * 2 * ndims + v]);
 
-            for(v = 0; v < ndims; v++)
+            for (v = 0; v < ndims; v++)
                 h5tools_str_append(str, "%s" HSIZE_T_FORMAT, v ? "," : ")-(",
-                                    ptdata[u * 2 * ndims + v + ndims]);
+                                   ptdata[u * 2 * ndims + v + ndims]);
 
             h5tools_str_append(str, ")");
         }
@@ -527,41 +525,41 @@ h5tools_str_dump_space_blocks(h5tools_str_t *str, hid_t rspace,
  *-------------------------------------------------------------------------
  */
 void
-h5tools_str_dump_space_points(h5tools_str_t *str, hid_t rspace,
-        const h5tool_format_t *info)
+h5tools_str_dump_space_points(h5tools_str_t *str, hid_t rspace, const h5tool_format_t *info)
 {
-    hssize_t   snpoints;
+    hssize_t snpoints;
 
     /*
      * This function fails if the rspace does not have points.
      */
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY
+    {
         snpoints = H5Sget_select_elem_npoints(rspace);
-    } H5E_END_TRY;
+    }
+    H5E_END_TRY;
 
     /* Print point information */
     if (snpoints > 0) {
-        hsize_t    alloc_size;
-        hsize_t    npoints;
-        hsize_t   *ptdata;
-        hsize_t    u;
-        unsigned   ndims = (unsigned)H5Sget_simple_extent_ndims(rspace);
+        hsize_t  alloc_size;
+        hsize_t  npoints;
+        hsize_t *ptdata;
+        hsize_t  u;
+        unsigned ndims = (unsigned)H5Sget_simple_extent_ndims(rspace);
 
-        npoints = (hsize_t)snpoints;
+        npoints    = (hsize_t)snpoints;
         alloc_size = npoints * ndims * sizeof(ptdata[0]);
-        HDassert(alloc_size == (hsize_t) ((size_t) alloc_size)); /*check for overflow*/
-        ptdata = (hsize_t *)HDmalloc((size_t) alloc_size);
+        HDassert(alloc_size == (hsize_t)((size_t)alloc_size)); /*check for overflow*/
+        ptdata = (hsize_t *)HDmalloc((size_t)alloc_size);
         H5Sget_select_elem_pointlist(rspace, (hsize_t)0, npoints, ptdata);
 
-        for(u = 0; u < npoints; u++) {
+        for (u = 0; u < npoints; u++) {
             unsigned v;
 
             h5tools_str_append(str, info->dset_ptformat_pre, u ? "," OPTIONAL_LINE_BREAK " " : "",
                                (unsigned long)u);
 
-            for(v = 0; v < ndims; v++)
-                h5tools_str_append(str, "%s" HSIZE_T_FORMAT, v ? "," : "(",
-                                  (ptdata[u * ndims + v]));
+            for (v = 0; v < ndims; v++)
+                h5tools_str_append(str, "%s" HSIZE_T_FORMAT, v ? "," : "(", (ptdata[u * ndims + v]));
 
             h5tools_str_append(str, ")");
         }
@@ -582,78 +580,77 @@ h5tools_str_dump_space_points(h5tools_str_t *str, hid_t rspace,
 static void
 h5tools_print_char(h5tools_str_t *str, const h5tool_format_t *info, char ch)
 {
-    if(info->str_locale == ESCAPE_HTML) {
-        if(ch <= ' ' || ch > '~')
+    if (info->str_locale == ESCAPE_HTML) {
+        if (ch <= ' ' || ch > '~')
             h5tools_str_append(str, "%%%02x", ch);
         else
             h5tools_str_append(str, "%c", ch);
     }
     else {
-        switch(ch) {
-        case '"':
-            if(!info->do_escape)
-                h5tools_str_append(str, "\"");
-            else
-                h5tools_str_append(str, "\\\"");
-            break;
-        case '\\':
-            if (!info->do_escape)
-                h5tools_str_append(str, "\\");
-            else
-                h5tools_str_append(str, "\\\\");
-            break;
-        case '\b':
-            if(!info->do_escape)
-                h5tools_str_append(str, "\b");
-            else
-                h5tools_str_append(str, "\\b");
-            break;
-        case '\f':
-            if(!info->do_escape)
-                h5tools_str_append(str, "\f");
-            else
-                h5tools_str_append(str, "\\f");
-            break;
-        case '\n':
-            if(!info->do_escape) {
-                h5tools_str_append(str, "\n");
-                h5tools_str_append(str, "           ");
-            }
-            else
-                h5tools_str_append(str, "\\n");
-            break;
-        case '\r':
-            if(!info->do_escape) {
-                h5tools_str_append(str, "\r");
-                h5tools_str_append(str, "           ");
-            }
-            else
-                h5tools_str_append(str, "\\r");
-            break;
-        case '\t':
-            if(!info->do_escape)
-                h5tools_str_append(str, "\t");
-            else
-                h5tools_str_append(str, "\\t");
-            break;
-        default:
-            if(isprint(ch))
-                h5tools_str_append(str, "%c", ch);
-            else
-                h5tools_str_append(str, "\\%03o", ch);
+        switch (ch) {
+            case '"':
+                if (!info->do_escape)
+                    h5tools_str_append(str, "\"");
+                else
+                    h5tools_str_append(str, "\\\"");
+                break;
+            case '\\':
+                if (!info->do_escape)
+                    h5tools_str_append(str, "\\");
+                else
+                    h5tools_str_append(str, "\\\\");
+                break;
+            case '\b':
+                if (!info->do_escape)
+                    h5tools_str_append(str, "\b");
+                else
+                    h5tools_str_append(str, "\\b");
+                break;
+            case '\f':
+                if (!info->do_escape)
+                    h5tools_str_append(str, "\f");
+                else
+                    h5tools_str_append(str, "\\f");
+                break;
+            case '\n':
+                if (!info->do_escape) {
+                    h5tools_str_append(str, "\n");
+                    h5tools_str_append(str, "           ");
+                }
+                else
+                    h5tools_str_append(str, "\\n");
+                break;
+            case '\r':
+                if (!info->do_escape) {
+                    h5tools_str_append(str, "\r");
+                    h5tools_str_append(str, "           ");
+                }
+                else
+                    h5tools_str_append(str, "\\r");
+                break;
+            case '\t':
+                if (!info->do_escape)
+                    h5tools_str_append(str, "\t");
+                else
+                    h5tools_str_append(str, "\\t");
+                break;
+            default:
+                if (isprint(ch))
+                    h5tools_str_append(str, "%c", ch);
+                else
+                    h5tools_str_append(str, "\\%03o", ch);
 
-            break;
+                break;
         }
     }
 }
 void
-h5tools_str_indent(h5tools_str_t *str, const h5tool_format_t *info,
-                      h5tools_context_t *ctx)
+h5tools_str_indent(h5tools_str_t *str, const h5tool_format_t *info, h5tools_context_t *ctx)
 {
     unsigned u, indentlevel = 0;
 
     /* Write new prefix */
-    if(ctx->indent_level > 0)
+    if (ctx->indent_level > 0)
         indentlevel = ctx->indent_level;
     else
         /*
@@ -664,7 +661,7 @@ h5tools_str_indent(h5tools_str_t *str, const h5tool_format_t *info,
          */
         indentlevel = ctx->default_indent_level;
 
-    for(u = 0; u < indentlevel; u++)
+    for (u = 0; u < indentlevel; u++)
         h5tools_str_append(str, "%s", OPT(info->line_indent, ""));
 }
 
@@ -678,24 +675,24 @@ h5tools_str_indent(h5tools_str_t *str, const h5tool_format_t *info,
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t container,
-                   hid_t type, void *vp, h5tools_context_t *ctx)
+h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t container, hid_t type, void *vp,
+                   h5tools_context_t *ctx)
 {
-    size_t         nsize, offset, size=0, nelmts, start;
+    size_t         nsize, offset, size = 0, nelmts, start;
     H5T_sign_t     nsign;
-    char          *name = NULL;
+    char *         name   = NULL;
     unsigned char *ucp_vp = (unsigned char *)vp;
-    char          *cp_vp = (char *)vp;
-    hid_t          memb = H5I_INVALID_HID;
-    hid_t          obj = H5I_INVALID_HID;
+    char *         cp_vp  = (char *)vp;
+    hid_t          memb   = H5I_INVALID_HID;
+    hid_t          obj    = H5I_INVALID_HID;
     static char    fmt_llong[8], fmt_ullong[8];
     H5T_str_t      pad;
     H5T_class_t    type_class;
-    char          *ret_value = NULL;
+    char *         ret_value = NULL;
 
     H5TOOLS_START_DEBUG("");
     /* Build default formats for long long types */
-    if(!fmt_llong[0]) {
+    if (!fmt_llong[0]) {
         HDsnprintf(fmt_llong, sizeof(fmt_llong), "%%%sd", H5_PRINTF_LL_WIDTH);
         HDsnprintf(fmt_ullong, sizeof(fmt_ullong), "%%%su", H5_PRINTF_LL_WIDTH);
     }
@@ -705,40 +702,40 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
 
     nsize = H5Tget_size(type);
     nsign = H5Tget_sign(type);
-    if(info->raw) {
+    if (info->raw) {
         size_t i;
 
-        if(1 == nsize)
+        if (1 == nsize)
             h5tools_str_append(str, OPT(info->fmt_raw, "0x%02x"), ucp_vp[0]);
         else
-            for(i = 0; i < nsize; i++) {
-                if(i)
+            for (i = 0; i < nsize; i++) {
+                if (i)
                     h5tools_str_append(str, ":");
                 h5tools_str_append(str, OPT(info->fmt_raw, "%02x"), ucp_vp[i]);
             }
     }
     else {
-        if((type_class = H5Tget_class(type)) < 0)
+        if ((type_class = H5Tget_class(type)) < 0)
             return NULL;
         switch (type_class) {
             case H5T_FLOAT:
                 H5TOOLS_DEBUG("H5T_FLOAT");
-                if(sizeof(float) == nsize) {
+                if (sizeof(float) == nsize) {
                     /* if (H5Tequal(type, H5T_NATIVE_FLOAT)) */
                     float tempfloat;
 
                     HDmemcpy(&tempfloat, vp, sizeof(float));
                     h5tools_str_append(str, OPT(info->fmt_float, "%g"), (double)tempfloat);
                 }
-                else if(sizeof(double) == nsize) {
+                else if (sizeof(double) == nsize) {
                     /* if (H5Tequal(type, H5T_NATIVE_DOUBLE)) */
                     double tempdouble;
 
                     HDmemcpy(&tempdouble, vp, sizeof(double));
                     h5tools_str_append(str, OPT(info->fmt_double, "%g"), tempdouble);
-#if H5_SIZEOF_LONG_DOUBLE !=0
+#if H5_SIZEOF_LONG_DOUBLE != 0
                 }
-                else if(sizeof(long double) == nsize) {
+                else if (sizeof(long double) == nsize) {
                     /* if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) */
                     long double templdouble;
 
@@ -748,100 +745,100 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                 }
                 break;
 
-            case H5T_STRING:
-                {
-                    unsigned int i;
-                    char         quote = '\0';
-                    char        *s;
-
-                    H5TOOLS_DEBUG("H5T_STRING");
-                    quote = '\0';
-                    if(H5Tis_variable_str(type)) {
-                        /* cp_vp is the pointer into the struct where a `char*' is stored. So we have
-                         * to dereference the pointer to get the `char*' to pass to HDstrlen(). */
-                        s = *(char **)((void *)cp_vp);
-                        if(s != NULL)
-                            size = HDstrlen(s);
-                    }
-                    else {
-                        s = cp_vp;
-                        size = H5Tget_size(type);
-                    }
-                    pad = H5Tget_strpad(type);
+            case H5T_STRING: {
+                unsigned int i;
+                char         quote = '\0';
+                char *       s;
+
+                H5TOOLS_DEBUG("H5T_STRING");
+                quote = '\0';
+                if (H5Tis_variable_str(type)) {
+                    /* cp_vp is the pointer into the struct where a `char*' is stored. So we have
+                     * to dereference the pointer to get the `char*' to pass to HDstrlen(). */
+                    s = *(char **)((void *)cp_vp);
+                    if (s != NULL)
+                        size = HDstrlen(s);
+                }
+                else {
+                    s    = cp_vp;
+                    size = H5Tget_size(type);
+                }
+                pad = H5Tget_strpad(type);
 
-                    /* Check for NULL pointer for string */
-                    if(s == NULL)
-                        h5tools_str_append(str, "NULL");
-                    else {
-                        for(i = 0; i < size && (s[i] || pad != H5T_STR_NULLTERM); i++) {
-                            unsigned j = 1;
-
-                            /*
-                             * Count how many times the next character repeats. If the
-                             * threshold is zero then that means it can repeat any number
-                             * of times.
-                             */
-                            if(info->str_repeat > 0)
-                                while (i + j < size && s[i] == s[i + j])
-                                    j++;
-
-                            /*
-                             * Print the opening quote.  If the repeat count is high enough to
-                             * warrant printing the number of repeats instead of enumerating
-                             * the characters, then make sure the character to be repeated is
-                             * in it's own quote.
-                             */
-                            if(info->str_repeat > 0 && j > info->str_repeat) {
-                                if(quote)
-                                    h5tools_str_append(str, "%c", quote);
-
-                                quote = '\'';
-                                h5tools_str_append(str, "%s%c", i ? " " : "", quote);
-                            }
-                            else if(!quote) {
-                                quote = '"';
-                                h5tools_str_append(str, "%s%c", i ? " " : "", quote);
-                            }
+                /* Check for NULL pointer for string */
+                if (s == NULL)
+                    h5tools_str_append(str, "NULL");
+                else {
+                    for (i = 0; i < size && (s[i] || pad != H5T_STR_NULLTERM); i++) {
+                        unsigned j = 1;
+
+                        /*
+                         * Count how many times the next character repeats. If the
+                         * threshold is zero then that means it can repeat any number
+                         * of times.
+                         */
+                        if (info->str_repeat > 0)
+                            while (i + j < size && s[i] == s[i + j])
+                                j++;
+
+                        /*
+                         * Print the opening quote.  If the repeat count is high enough to
+                         * warrant printing the number of repeats instead of enumerating
+                         * the characters, then make sure the character to be repeated is
+                         * in it's own quote.
+                         */
+                        if (info->str_repeat > 0 && j > info->str_repeat) {
+                            if (quote)
+                                h5tools_str_append(str, "%c", quote);
+
+                            quote = '\'';
+                            h5tools_str_append(str, "%s%c", i ? " " : "", quote);
+                        }
+                        else if (!quote) {
+                            quote = '"';
+                            h5tools_str_append(str, "%s%c", i ? " " : "", quote);
+                        }
 
-                            /* Print the character */
-                            h5tools_print_char(str, info, s[i]);
+                        /* Print the character */
+                        h5tools_print_char(str, info, s[i]);
 
-                            /* Print the repeat count */
-                            if(info->str_repeat && j > info->str_repeat) {
+                        /* Print the repeat count */
+                        if (info->str_repeat && j > info->str_repeat) {
 #ifdef REPEAT_VERBOSE
-                                h5tools_str_append(str, "%c repeats %d times", quote, j - 1);
+                            h5tools_str_append(str, "%c repeats %d times", quote, j - 1);
 #else
-                                h5tools_str_append(str, "%c*%d", quote, j - 1);
-#endif  /* REPEAT_VERBOSE */
-                                quote = '\0';
-                                i += j - 1;
-                            }
+                            h5tools_str_append(str, "%c*%d", quote, j - 1);
+#endif /* REPEAT_VERBOSE */
+                            quote = '\0';
+                            i += j - 1;
                         }
+                    }
 
-                        if(quote)
-                            h5tools_str_append(str, "%c", quote);
+                    if (quote)
+                        h5tools_str_append(str, "%c", quote);
 
-                        if(i == 0)
-                            /*empty string*/
-                            h5tools_str_append(str, "\"\"");
-                    } /* end else */
-                }
-                break;
+                    if (i == 0)
+                        /*empty string*/
+                        h5tools_str_append(str, "\"\"");
+                } /* end else */
+            } break;
 
             case H5T_INTEGER:
                 H5TOOLS_DEBUG("H5T_INTEGER");
-                if(sizeof(char) == nsize) {
-                    if(info->ascii)
-                        h5tools_print_char(str, info, (char) (*ucp_vp));
-                    else if(H5T_SGN_NONE == nsign) {
+                if (sizeof(char) == nsize) {
+                    if (info->ascii)
+                        h5tools_print_char(str, info, (char)(*ucp_vp));
+                    else if (H5T_SGN_NONE == nsign) {
                         unsigned char tempuchar;
 
                         HDmemcpy(&tempuchar, ucp_vp, sizeof(unsigned char));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(unsigned char))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(unsigned char))
                                 tempuchar = 0;
                             else
-                                tempuchar = (unsigned char)((unsigned long long)(tempuchar >> packed_data_offset) & packed_data_mask);
+                                tempuchar =
+                                    (unsigned char)((unsigned long long)(tempuchar >> packed_data_offset) &
+                                                    packed_data_mask);
                         }
                         h5tools_str_append(str, OPT(info->fmt_uchar, "%hhu"), tempuchar);
                     }
@@ -849,22 +846,24 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                         signed char tempchar;
 
                         HDmemcpy(&tempchar, cp_vp, sizeof(char));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(char))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(char))
                                 tempchar = 0;
                             else
-                                tempchar = (signed char)((unsigned long long)(tempchar >> packed_data_offset) & packed_data_mask);
+                                tempchar =
+                                    (signed char)((unsigned long long)(tempchar >> packed_data_offset) &
+                                                  packed_data_mask);
                         }
                         h5tools_str_append(str, OPT(info->fmt_schar, "%hhd"), tempchar);
                     }
                 } /* end if (sizeof(char) == nsize) */
-                else if(sizeof(int) == nsize) {
-                    if(H5T_SGN_NONE == nsign) {
+                else if (sizeof(int) == nsize) {
+                    if (H5T_SGN_NONE == nsign) {
                         unsigned int tempuint;
 
                         HDmemcpy(&tempuint, vp, sizeof(unsigned int));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(unsigned int))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(unsigned int))
                                 tempuint = 0;
                             else
                                 tempuint = (unsigned)((tempuint >> packed_data_offset) & packed_data_mask);
@@ -875,25 +874,28 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                         int tempint;
 
                         HDmemcpy(&tempint, vp, sizeof(int));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(int))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(int))
                                 tempint = 0;
                             else
-                                tempint = (int)((unsigned long long)(tempint >> packed_data_offset) & packed_data_mask);
+                                tempint = (int)((unsigned long long)(tempint >> packed_data_offset) &
+                                                packed_data_mask);
                         }
                         h5tools_str_append(str, OPT(info->fmt_int, "%d"), tempint);
                     }
                 } /* end if (sizeof(int) == nsize) */
-                else if(sizeof(short) == nsize) {
-                    if(H5T_SGN_NONE == nsign) {
+                else if (sizeof(short) == nsize) {
+                    if (H5T_SGN_NONE == nsign) {
                         unsigned short tempushort;
 
                         HDmemcpy(&tempushort, vp, sizeof(unsigned short));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(unsigned short))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(unsigned short))
                                 tempushort = 0;
                             else
-                                tempushort = (unsigned short)((unsigned long long)(tempushort >> packed_data_offset) & packed_data_mask);
+                                tempushort =
+                                    (unsigned short)((unsigned long long)(tempushort >> packed_data_offset) &
+                                                     packed_data_mask);
                         }
                         h5tools_str_append(str, OPT(info->fmt_ushort, "%hu"), tempushort);
                     }
@@ -901,22 +903,23 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                         short tempshort;
 
                         HDmemcpy(&tempshort, vp, sizeof(short));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(short))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(short))
                                 tempshort = 0;
                             else
-                                tempshort = (short)((unsigned long long)(tempshort >> packed_data_offset) & packed_data_mask);
+                                tempshort = (short)((unsigned long long)(tempshort >> packed_data_offset) &
+                                                    packed_data_mask);
                         }
                         h5tools_str_append(str, OPT(info->fmt_short, "%hd"), tempshort);
                     }
                 } /* end if (sizeof(short) == nsize) */
-                else if(sizeof(long) == nsize) {
-                    if(H5T_SGN_NONE == nsign) {
+                else if (sizeof(long) == nsize) {
+                    if (H5T_SGN_NONE == nsign) {
                         unsigned long tempulong;
 
                         HDmemcpy(&tempulong, vp, sizeof(unsigned long));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(unsigned long))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(unsigned long))
                                 tempulong = 0;
                             else
                                 tempulong = (tempulong >> packed_data_offset) & packed_data_mask;
@@ -927,23 +930,24 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                         long templong;
 
                         HDmemcpy(&templong, vp, sizeof(long));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(long))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(long))
                                 templong = 0;
                             else
-                                templong = (long)((unsigned long long)(templong >> packed_data_offset) & packed_data_mask);
+                                templong = (long)((unsigned long long)(templong >> packed_data_offset) &
+                                                  packed_data_mask);
                         }
                         h5tools_str_append(str, OPT(info->fmt_long, "%ld"), templong);
                     }
                 } /* end if (sizeof(long) == nsize) */
 #if H5_SIZEOF_LONG != H5_SIZEOF_LONG_LONG
-                else if(sizeof(long long) == nsize) {
-                    if(H5T_SGN_NONE == nsign) {
+                else if (sizeof(long long) == nsize) {
+                    if (H5T_SGN_NONE == nsign) {
                         unsigned long long tempullong;
 
                         HDmemcpy(&tempullong, vp, sizeof(unsigned long long));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(unsigned long long))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(unsigned long long))
                                 tempullong = 0;
                             else
                                 tempullong = (tempullong >> packed_data_offset) & packed_data_mask;
@@ -954,8 +958,8 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                         long long templlong;
 
                         HDmemcpy(&templlong, vp, sizeof(long long));
-                        if(packed_bits_num) {
-                            if(packed_data_offset >= 8 * sizeof(long long))
+                        if (packed_bits_num) {
+                            if (packed_data_offset >= 8 * sizeof(long long))
                                 templlong = 0;
                             else
                                 templlong = (templlong >> packed_data_offset) & packed_data_mask;
@@ -963,19 +967,19 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                         h5tools_str_append(str, OPT(info->fmt_llong, fmt_llong), templlong);
                     }
                 } /* end if (sizeof(long long) == nsize) */
-#endif /* H5_SIZEOF_LONG != H5_SIZEOF_LONG_LONG */
+#endif            /* H5_SIZEOF_LONG != H5_SIZEOF_LONG_LONG */
                 break;
 
             case H5T_COMPOUND:
                 H5TOOLS_DEBUG("H5T_COMPOUND");
-                if(ctx->cmpd_listv) { /* there is <list_of_fields> */
-                    unsigned    save_indent_level;      /* The indentation level */
-                    size_t curr_field;             /* Current field to display */
-                    int    i = 0;                  /* Local index variable */
-                    unsigned x = 0;                /* Local index variable */
-                    const H5LD_memb_t * const *listv;           /* Vector of information for <list_of_fields> */
-
-                    listv = ctx->cmpd_listv;
+                if (ctx->cmpd_listv) {                           /* there is <list_of_fields> */
+                    unsigned                  save_indent_level; /* The indentation level */
+                    size_t                    curr_field;        /* Current field to display */
+                    int                       i = 0;             /* Local index variable */
+                    unsigned                  x = 0;             /* Local index variable */
+                    const H5LD_memb_t *const *listv; /* Vector of information for <list_of_fields> */
+
+                    listv           = ctx->cmpd_listv;
                     ctx->cmpd_listv = NULL;
 
                     h5tools_str_append(str, "%s", OPT(info->cmpd_pre, "{"));
@@ -986,39 +990,38 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                      *       put in "{", "}", ",", member name and value accordingly.
                      */
                     save_indent_level = ctx->indent_level;
-                    for(curr_field = 0; listv[curr_field] != NULL; curr_field++) {
-                        if(curr_field)
-                            h5tools_str_append(str, "%s", OPT(info->cmpd_sep, ", "OPTIONAL_LINE_BREAK));
+                    for (curr_field = 0; listv[curr_field] != NULL; curr_field++) {
+                        if (curr_field)
+                            h5tools_str_append(str, "%s", OPT(info->cmpd_sep, ", " OPTIONAL_LINE_BREAK));
                         else
                             h5tools_str_append(str, "%s", OPT(info->cmpd_end, ""));
 
-                        if(info->arr_linebreak)
+                        if (info->arr_linebreak)
                             h5tools_str_indent(str, info, ctx);
 
                         /* Process members of each field */
-                        for(i = 0; listv[curr_field]->names[i] != NULL; i++) {
+                        for (i = 0; listv[curr_field]->names[i] != NULL; i++) {
                             h5tools_str_append(str, OPT(info->cmpd_name, ""), listv[curr_field]->names[i]);
-                            if(i) {
+                            if (i) {
                                 ctx->indent_level++;
                                 h5tools_str_append(str, "%s", OPT(info->cmpd_pre, "{"));
                             }
                         }
-                        h5tools_str_sprint(str, info, container, listv[curr_field]->last_tid, cp_vp + listv[curr_field]->tot_offset, ctx);
-                        if(ctx->indent_level > 0)
-                            for(x = ctx->indent_level; x > 0; x--)
+                        h5tools_str_sprint(str, info, container, listv[curr_field]->last_tid,
+                                           cp_vp + listv[curr_field]->tot_offset, ctx);
+                        if (ctx->indent_level > 0)
+                            for (x = ctx->indent_level; x > 0; x--)
                                 h5tools_str_append(str, "%s", OPT(info->cmpd_suf, "}"));
                         ctx->indent_level = save_indent_level;
                     }
 
-
-                    if(info->arr_linebreak) {
+                    if (info->arr_linebreak) {
                         h5tools_str_append(str, "%s", OPT(info->cmpd_end, ""));
                         h5tools_str_indent(str, info, ctx);
                     }
                     h5tools_str_append(str, "%s", OPT(info->cmpd_suf, "}"));
 
                     ctx->cmpd_listv = info->cmpd_listv;
-
                 }
                 else {
                     int retvalue;
@@ -1032,13 +1035,13 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
 
                         ctx->indent_level++;
 
-                        for(j = 0; j < nmembs; j++) {
-                            if(j)
-                                h5tools_str_append(str, "%s", OPT(info->cmpd_sep, ", "OPTIONAL_LINE_BREAK));
+                        for (j = 0; j < nmembs; j++) {
+                            if (j)
+                                h5tools_str_append(str, "%s", OPT(info->cmpd_sep, ", " OPTIONAL_LINE_BREAK));
                             else
                                 h5tools_str_append(str, "%s", OPT(info->cmpd_end, ""));
 
-                            if(info->arr_linebreak)
+                            if (info->arr_linebreak)
                                 h5tools_str_indent(str, info, ctx);
 
                             /* The name */
@@ -1048,7 +1051,7 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
 
                             /* The value */
                             offset = H5Tget_member_offset(type, j);
-                            memb = H5Tget_member_type(type, j);
+                            memb   = H5Tget_member_type(type, j);
 
                             h5tools_str_sprint(str, info, container, memb, cp_vp + offset, ctx);
 
@@ -1056,7 +1059,7 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                         }
                         ctx->indent_level--;
 
-                        if(info->arr_linebreak) {
+                        if (info->arr_linebreak) {
                             h5tools_str_append(str, "%s", OPT(info->cmpd_end, ""));
                             h5tools_str_indent(str, info, ctx);
                         }
@@ -1065,46 +1068,43 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                 }
                 break;
 
-            case H5T_ENUM:
-                {
-                    char enum_name[1024];
+            case H5T_ENUM: {
+                char enum_name[1024];
 
-                    H5TOOLS_DEBUG("H5T_ENUM");
-                    if(H5Tenum_nameof(type, vp, enum_name, sizeof enum_name) >= 0)
-                        h5tools_str_append(str, h5tools_escape(enum_name, sizeof(enum_name)));
-                    else {
-                        size_t i;
-                        if(1 == nsize)
-                            h5tools_str_append(str, "0x%02x", ucp_vp[0]);
-                        else
-                            for(i = 0; i < nsize; i++)
-                                h5tools_str_append(str, "%s%02x", i ? ":" : "", ucp_vp[i]);
-                    }
+                H5TOOLS_DEBUG("H5T_ENUM");
+                if (H5Tenum_nameof(type, vp, enum_name, sizeof enum_name) >= 0)
+                    h5tools_str_append(str, h5tools_escape(enum_name, sizeof(enum_name)));
+                else {
+                    size_t i;
+                    if (1 == nsize)
+                        h5tools_str_append(str, "0x%02x", ucp_vp[0]);
+                    else
+                        for (i = 0; i < nsize; i++)
+                            h5tools_str_append(str, "%s%02x", i ? ":" : "", ucp_vp[i]);
                 }
-                break;
+            } break;
 
             case H5T_REFERENCE:
                 H5TOOLS_DEBUG("H5T_REFERENCE");
-                if(h5tools_str_is_zero(vp, nsize))
+                if (h5tools_str_is_zero(vp, nsize))
                     h5tools_str_append(str, "NULL");
                 else {
                     if (H5Tequal(type, H5T_STD_REF)) {
-                        H5O_type_t obj_type = -1;   /* Object type */
-                        H5R_type_t ref_type;   /* Reference type */
+                        H5O_type_t obj_type = -1; /* Object type */
+                        H5R_type_t ref_type;      /* Reference type */
                         H5R_ref_t *ref_vp = (H5R_ref_t *)vp;
 
                         H5TOOLS_DEBUG("H5T_REFERENCE:H5T_STD_REF");
                         ref_type = H5Rget_type(ref_vp);
                         H5Rget_obj_type3(ref_vp, H5P_DEFAULT, &obj_type);
                         switch (ref_type) {
-                            case H5R_OBJECT1:
-                                {
+                            case H5R_OBJECT1: {
                                 /* Object references -- show the type and OID of the referenced object. */
                                 H5O_info2_t oi;
-                                char *obj_addr_str = NULL;
+                                char *      obj_addr_str = NULL;
 
                                 H5TOOLS_DEBUG("ref_type is H5R_OBJECT1");
-                                if((obj = H5Ropen_object(ref_vp, H5P_DEFAULT, H5P_DEFAULT)) >= 0) {
+                                if ((obj = H5Ropen_object(ref_vp, H5P_DEFAULT, H5P_DEFAULT)) >= 0) {
                                     H5Oget_info3(obj, &oi, H5O_INFO_BASIC);
                                     H5Otoken_to_str(obj, &oi.token, &obj_addr_str);
                                 }
@@ -1114,44 +1114,45 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                                 /* Print object type and close object */
                                 switch (obj_type) {
                                     case H5O_TYPE_GROUP:
-                                        h5tools_str_append(str, "%u-%s", (unsigned) oi.type, H5_TOOLS_GROUP);
+                                        h5tools_str_append(str, "%u-%s", (unsigned)oi.type, H5_TOOLS_GROUP);
                                         break;
 
                                     case H5O_TYPE_DATASET:
-                                        h5tools_str_append(str, "%u-%s", (unsigned) oi.type, H5_TOOLS_DATASET);
+                                        h5tools_str_append(str, "%u-%s", (unsigned)oi.type, H5_TOOLS_DATASET);
                                         break;
 
                                     case H5O_TYPE_NAMED_DATATYPE:
-                                        h5tools_str_append(str, "%u-%s", (unsigned) oi.type, H5_TOOLS_DATATYPE);
+                                        h5tools_str_append(str, "%u-%s", (unsigned)oi.type,
+                                                           H5_TOOLS_DATATYPE);
                                         break;
 
                                     case H5O_TYPE_MAP:
                                     case H5O_TYPE_UNKNOWN:
                                     case H5O_TYPE_NTYPES:
                                     default:
-                                        h5tools_str_append(str, "%u-%s", (unsigned) oi.type, H5_TOOLS_UNKNOWN);
+                                        h5tools_str_append(str, "%u-%s", (unsigned)oi.type, H5_TOOLS_UNKNOWN);
                                         break;
                                 } /* end switch */
 
                                 h5tools_str_sprint_reference(str, ref_vp);
 
                                 /* Print OID */
-                                if(info->obj_hidefileno)
+                                if (info->obj_hidefileno)
                                     h5tools_str_append(str, info->obj_format, obj_addr_str);
                                 else
                                     h5tools_str_append(str, info->obj_format, oi.fileno, obj_addr_str);
 
-                                if(obj_addr_str) {
+                                if (obj_addr_str) {
                                     H5free_memory(obj_addr_str);
                                     obj_addr_str = NULL;
                                 }
 
-                                if(obj >= 0)
-                                    if(H5Oclose(obj) < 0)
+                                if (obj >= 0)
+                                    if (H5Oclose(obj) < 0)
                                         H5TOOLS_ERROR(NULL, "H5Oclose H5R_OBJECT1 failed");
-                                }
+                            }
 
-                                break;
+                            break;
                             case H5R_DATASET_REGION1:
                                 H5TOOLS_DEBUG("ref_type is H5R_DATASET_REGION1");
                                 h5tools_str_append(str, H5_TOOLS_DATASET);
@@ -1209,132 +1210,127 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
                 }
                 break;
 
-            case H5T_ARRAY:
-                {
-                    int        k, ndims;
-                    hsize_t    i, dims[H5S_MAX_RANK], temp_nelmts;
-                    static int is_next_arry_elmt = 0;
-
-                    H5TOOLS_DEBUG("H5T_ARRAY");
-                    /* Get the array's base datatype for each element */
-                    memb = H5Tget_super(type);
-                    size = H5Tget_size(memb);
-                    ndims = H5Tget_array_ndims(type);
-                    H5Tget_array_dims2(type, dims);
-                    HDassert(ndims >= 1 && ndims <= H5S_MAX_RANK);
-
-                    /* Calculate the number of array elements */
-                    for(k = 0, nelmts = 1; k < ndims; k++) {
-                        temp_nelmts = nelmts;
-                        temp_nelmts *= dims[k];
-                        HDassert(temp_nelmts == (hsize_t) ((size_t) temp_nelmts));
-                        nelmts = (size_t) temp_nelmts;
-                    }
-                    /* Print the opening bracket */
-                    h5tools_str_append(str, "%s", OPT(info->arr_pre, "["));
+            case H5T_ARRAY: {
+                int        k, ndims;
+                hsize_t    i, dims[H5S_MAX_RANK], temp_nelmts;
+                static int is_next_arry_elmt = 0;
+
+                H5TOOLS_DEBUG("H5T_ARRAY");
+                /* Get the array's base datatype for each element */
+                memb  = H5Tget_super(type);
+                size  = H5Tget_size(memb);
+                ndims = H5Tget_array_ndims(type);
+                H5Tget_array_dims2(type, dims);
+                HDassert(ndims >= 1 && ndims <= H5S_MAX_RANK);
+
+                /* Calculate the number of array elements */
+                for (k = 0, nelmts = 1; k < ndims; k++) {
+                    temp_nelmts = nelmts;
+                    temp_nelmts *= dims[k];
+                    HDassert(temp_nelmts == (hsize_t)((size_t)temp_nelmts));
+                    nelmts = (size_t)temp_nelmts;
+                }
+                /* Print the opening bracket */
+                h5tools_str_append(str, "%s", OPT(info->arr_pre, "["));
 
-                    ctx->indent_level++;
+                ctx->indent_level++;
 
-                    for(i = 0; i < nelmts; i++) {
-                        if(i)
-                            h5tools_str_append(str, "%s", OPT(info->arr_sep, "," OPTIONAL_LINE_BREAK));
+                for (i = 0; i < nelmts; i++) {
+                    if (i)
+                        h5tools_str_append(str, "%s", OPT(info->arr_sep, "," OPTIONAL_LINE_BREAK));
 
-                        if(info->arr_linebreak && i && i % dims[ndims - 1] == 0) {
-                            h5tools_str_append(str, "%s", "\n");
-                            h5tools_str_indent(str, info, ctx);
+                    if (info->arr_linebreak && i && i % dims[ndims - 1] == 0) {
+                        h5tools_str_append(str, "%s", "\n");
+                        h5tools_str_indent(str, info, ctx);
 
-                        } /* end if */
-                        else if(i && info->arr_sep) {
-                            /* if next element begin, add next line with indent */
-                            if(is_next_arry_elmt) {
-                                is_next_arry_elmt = 0;
+                    } /* end if */
+                    else if (i && info->arr_sep) {
+                        /* if next element begin, add next line with indent */
+                        if (is_next_arry_elmt) {
+                            is_next_arry_elmt = 0;
 
-                                h5tools_str_append(str, "%s", "\n ");
-                                h5tools_str_indent(str, info, ctx);
+                            h5tools_str_append(str, "%s", "\n ");
+                            h5tools_str_indent(str, info, ctx);
+                        }
+                        /* otherwise just add space */
+                        else
+                            h5tools_str_append(str, " ");
 
-                            }
-                            /* otherwise just add space */
-                            else
-                                h5tools_str_append(str, " ");
+                    } /* end else if */
 
-                        } /* end else if */
+                    /* Dump values in an array element */
+                    is_next_arry_elmt = 0; /* dump all values in the array element, so turn it off */
+                    h5tools_str_sprint(str, info, container, memb, cp_vp + i * size, ctx);
+                } /* end for */
 
-                        /* Dump values in an array element */
-                        is_next_arry_elmt = 0; /* dump all values in the array element, so turn it off */
-                        h5tools_str_sprint(str, info, container, memb, cp_vp + i * size, ctx);
-                    } /* end for */
+                ctx->indent_level--;
 
-                    ctx->indent_level--;
+                /* Print the closing bracket */
+                h5tools_str_append(str, "%s", OPT(info->arr_suf, "]"));
+                is_next_arry_elmt = 1; /* set for begining of next array element */
+                H5Tclose(memb);
+            } break;
 
-                    /* Print the closing bracket */
-                    h5tools_str_append(str, "%s", OPT(info->arr_suf, "]"));
-                    is_next_arry_elmt = 1; /* set for begining of next array element */
-                    H5Tclose(memb);
-                }
-                break;
+            case H5T_VLEN: {
+                unsigned int i;
 
-            case H5T_VLEN:
-                {
-                    unsigned int i;
+                H5TOOLS_DEBUG("H5T_VLEN");
+                /* Get the VL sequences's base datatype for each element */
+                memb = H5Tget_super(type);
+                size = H5Tget_size(memb);
 
-                    H5TOOLS_DEBUG("H5T_VLEN");
-                    /* Get the VL sequences's base datatype for each element */
-                    memb = H5Tget_super(type);
-                    size = H5Tget_size(memb);
+                /* Print the opening bracket */
+                h5tools_str_append(str, "%s", OPT(info->vlen_pre, "("));
 
-                    /* Print the opening bracket */
-                    h5tools_str_append(str, "%s", OPT(info->vlen_pre, "("));
+                /* Get the number of sequence elements */
+                nelmts = ((hvl_t *)((void *)cp_vp))->len;
 
-                    /* Get the number of sequence elements */
-                    nelmts = ((hvl_t *)((void *)cp_vp))->len;
-
-                    for(i = 0; i < nelmts; i++) {
-                        if(i) h5tools_str_append(str, "%s", OPT(info->vlen_sep, "," OPTIONAL_LINE_BREAK));
+                for (i = 0; i < nelmts; i++) {
+                    if (i)
+                        h5tools_str_append(str, "%s", OPT(info->vlen_sep, "," OPTIONAL_LINE_BREAK));
 
 #ifdef LATER
-                        /* Need to fix so VL data breaks at correct location on end of line -QAK */
-                        if(info->arr_linebreak && h5tools_str_len(str)>=info->line_ncols) {
-                            int x;
+                    /* Need to fix so VL data breaks at correct location on end of line -QAK */
+                    if (info->arr_linebreak && h5tools_str_len(str) >= info->line_ncols) {
+                        int x;
 
-                            h5tools_str_append(str, "%s", "\n");
+                        h5tools_str_append(str, "%s", "\n");
 
-                            /* need to indent some more here */
-                            if(ctx->indent_level >= 0)
-                                h5tools_str_append(str, "%s", OPT(info->line_pre, ""));
+                        /* need to indent some more here */
+                        if (ctx->indent_level >= 0)
+                            h5tools_str_append(str, "%s", OPT(info->line_pre, ""));
 
-                            for(x = 0; x < ctx->indent_level + 1; x++)
-                                h5tools_str_append(str,"%s",OPT(info->line_indent,""));
-                        } /* end if */
-#endif /* LATER */
+                        for (x = 0; x < ctx->indent_level + 1; x++)
+                            h5tools_str_append(str, "%s", OPT(info->line_indent, ""));
+                    } /* end if */
+#endif                /* LATER */
 
-                        ctx->indent_level++;
+                    ctx->indent_level++;
 
-                        /* Dump the array element */
-                        h5tools_str_sprint(str, info, container, memb, ((char *) (((hvl_t *)((void *)cp_vp))->p)) + i * size, ctx);
+                    /* Dump the array element */
+                    h5tools_str_sprint(str, info, container, memb,
+                                       ((char *)(((hvl_t *)((void *)cp_vp))->p)) + i * size, ctx);
 
-                        ctx->indent_level--;
-                    } /* end for */
+                    ctx->indent_level--;
+                } /* end for */
 
-                    h5tools_str_append(str, "%s", OPT(info->vlen_suf, ")"));
-                    H5Tclose(memb);
-                }
-                break;
+                h5tools_str_append(str, "%s", OPT(info->vlen_suf, ")"));
+                H5Tclose(memb);
+            } break;
 
             case H5T_TIME:
             case H5T_BITFIELD:
-            case H5T_OPAQUE:
-                {
-                    /* All other types get printed as hexadecimal */
-                    size_t i;
-
-                    H5TOOLS_DEBUG("OTHER");
-                    if(1 == nsize)
-                        h5tools_str_append(str, "0x%02x", ucp_vp[0]);
-                    else
-                        for(i = 0; i < nsize; i++)
-                            h5tools_str_append(str, "%s%02x", i ? ":" : "", ucp_vp[i]);
-                }
-                break;
+            case H5T_OPAQUE: {
+                /* All other types get printed as hexadecimal */
+                size_t i;
+
+                H5TOOLS_DEBUG("OTHER");
+                if (1 == nsize)
+                    h5tools_str_append(str, "0x%02x", ucp_vp[0]);
+                else
+                    for (i = 0; i < nsize; i++)
+                        h5tools_str_append(str, "%s%02x", i ? ":" : "", ucp_vp[i]);
+            } break;
 
             case H5T_NO_CLASS:
             case H5T_NCLASSES:
@@ -1350,7 +1346,6 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai
     return ret_value;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5tools_str_sprint_reference
  *
@@ -1426,70 +1421,70 @@ h5tools_str_sprint_reference(h5tools_str_t *str, H5R_ref_t *ref_vp)
  *-------------------------------------------------------------------------
  */
 static char *
-h5tools_escape(char *s/*in,out*/, size_t size)
+h5tools_escape(char *s /*in,out*/, size_t size)
 {
-    register    size_t i;
-    const char *escape;
-    char        octal[8];
-    size_t      n = HDstrlen(s);
+    register size_t i;
+    const char *    escape;
+    char            octal[8];
+    size_t          n = HDstrlen(s);
 
-    for(i = 0; i < n; i++) {
+    for (i = 0; i < n; i++) {
         switch (s[i]) {
-        case '\'':
-            escape = "\\\'";
-            break;
-        case '\"':
-            escape = "\\\"";
-            break;
-        case '\\':
-            escape = "\\\\";
-            break;
-        case '\?':
-            escape = "\\\?";
-            break;
-        case '\a':
-            escape = "\\a";
-            break;
-        case '\b':
-            escape = "\\b";
-            break;
-        case '\f':
-            escape = "\\f";
-            break;
-        case '\n':
-            escape = "\\n";
-            break;
-        case '\r':
-            escape = "\\r";
-            break;
-        case '\t':
-            escape = "\\t";
-            break;
-        case '\v':
-            escape = "\\v";
-            break;
-        default:
-            if(!isprint(s[i])) {
-                HDsnprintf(octal, sizeof(octal), "\\%03o", (unsigned char) s[i]);
-                escape = octal;
-            }
-            else
-                escape = NULL;
+            case '\'':
+                escape = "\\\'";
+                break;
+            case '\"':
+                escape = "\\\"";
+                break;
+            case '\\':
+                escape = "\\\\";
+                break;
+            case '\?':
+                escape = "\\\?";
+                break;
+            case '\a':
+                escape = "\\a";
+                break;
+            case '\b':
+                escape = "\\b";
+                break;
+            case '\f':
+                escape = "\\f";
+                break;
+            case '\n':
+                escape = "\\n";
+                break;
+            case '\r':
+                escape = "\\r";
+                break;
+            case '\t':
+                escape = "\\t";
+                break;
+            case '\v':
+                escape = "\\v";
+                break;
+            default:
+                if (!isprint(s[i])) {
+                    HDsnprintf(octal, sizeof(octal), "\\%03o", (unsigned char)s[i]);
+                    escape = octal;
+                }
+                else
+                    escape = NULL;
 
-            break;
+                break;
         }
 
-        if(escape) {
+        if (escape) {
             size_t esc_size = HDstrlen(escape);
 
-            if(n + esc_size + 1 > size)
+            if (n + esc_size + 1 > size)
                 /*would overflow*/
                 return NULL;
 
             HDmemmove(s + i + esc_size, s + i + 1, n - i); /*make room*/
-            HDmemcpy(s + i, escape, esc_size); /*insert*/
-            n += esc_size - 1; /* adjust total string size */
-            i += esc_size; /* adjust string position */
+            HDmemcpy(s + i, escape, esc_size);             /*insert*/
+            n += esc_size - 1;                             /* adjust total string size */
+            i += esc_size;                                 /* adjust string position */
         }
     }
 
@@ -1510,10 +1505,10 @@ h5tools_escape(char *s/*in,out*/, size_t size)
 static hbool_t
 h5tools_str_is_zero(const void *_mem, size_t size)
 {
-    const unsigned char *mem = (const unsigned char *) _mem;
+    const unsigned char *mem = (const unsigned char *)_mem;
 
-    while(size-- > 0)
-        if(mem[size])
+    while (size-- > 0)
+        if (mem[size])
             return FALSE;
 
     return TRUE;
@@ -1536,30 +1531,31 @@ h5tools_str_is_zero(const void *_mem, size_t size)
  *-------------------------------------------------------------------------
  */
 char *
-h5tools_str_replace ( const char *string, const char *substr, const char *replacement )
+h5tools_str_replace(const char *string, const char *substr, const char *replacement)
 {
     char *tok    = NULL;
     char *newstr = NULL;
     char *head   = NULL;
 
-    if(substr == NULL || replacement == NULL)
+    if (substr == NULL || replacement == NULL)
         return HDstrdup(string);
     newstr = HDstrdup(string);
-    head = newstr;
-    while((tok = HDstrstr(head, substr))) {
+    head   = newstr;
+    while ((tok = HDstrstr(head, substr))) {
         char *oldstr;
 
         oldstr = newstr;
         newstr = (char *)HDmalloc(HDstrlen(oldstr) - HDstrlen(substr) + HDstrlen(replacement) + 1);
 
-        if(newstr == NULL) {
+        if (newstr == NULL) {
             HDfree(oldstr);
             return NULL;
         }
         HDmemcpy(newstr, oldstr, (size_t)(tok - oldstr));
         HDmemcpy(newstr + (tok - oldstr), replacement, HDstrlen(replacement));
-        HDmemcpy(newstr + (tok - oldstr) + HDstrlen(replacement), tok + HDstrlen(substr), HDstrlen(oldstr) - HDstrlen(substr) - (size_t)(tok - oldstr));
-        HDmemset(newstr + HDstrlen (oldstr) - HDstrlen(substr) + HDstrlen(replacement) , 0, 1);
+        HDmemcpy(newstr + (tok - oldstr) + HDstrlen(replacement), tok + HDstrlen(substr),
+                 HDstrlen(oldstr) - HDstrlen(substr) - (size_t)(tok - oldstr));
+        HDmemset(newstr + HDstrlen(oldstr) - HDstrlen(substr) + HDstrlen(replacement), 0, 1);
         /* move back head right after the last replacement */
         head = newstr + (tok - oldstr) + HDstrlen(replacement);
         HDfree(oldstr);
@@ -1567,4 +1563,3 @@ h5tools_str_replace ( const char *string, const char *substr, const char *replac
 
     return newstr;
 }
-