[svn-r21981] Correct HD prefix in tools for fprintf

Checked for HD support.

10 files changed, 685 insertions, 685 deletions

diff --git a/tools/h5copy/h5copy.c b/tools/h5copy/h5copy.c
index fb8bb81..dcc21ee 100644
--- a/tools/h5copy/h5copy.c
+++ b/tools/h5copy/h5copy.c
@@ -75,7 +75,7 @@ leave(int ret)
 static void
 usage (void)
 {
-    fprintf(stdout, "\
+    HDfprintf(stdout, "\
 usage: h5copy [OPTIONS] [OBJECTS...]\n\
    OBJECTS\n\
       -i, --input        input file name\n\
diff --git a/tools/h5diff/h5diff_common.c b/tools/h5diff/h5diff_common.c
index 35c3956..f7532f2 100644
--- a/tools/h5diff/h5diff_common.c
+++ b/tools/h5diff/h5diff_common.c
@@ -355,7 +355,7 @@ check_n_input( const char *str )
     unsigned i;
     char c;
 
-    for ( i = 0; i < HDstrlen(str); i++)
+    for ( i = 0; i < strlen(str); i++)
     {
         c = str[i];
         if ( i==0 )
@@ -394,7 +394,7 @@ check_p_input( const char *str )
     the atof return value on a hexadecimal input is different
     on some systems; we do a character check for this
     */
-    if (HDstrlen(str)>2 && str[0]=='0' && str[1]=='x')
+    if (strlen(str)>2 && str[0]=='0' && str[1]=='x')
         return -1;
 
     x=atof(str);
@@ -428,7 +428,7 @@ check_d_input( const char *str )
     the atof return value on a hexadecimal input is different
     on some systems; we do a character check for this
     */
-    if (HDstrlen(str)>2 && str[0]=='0' && str[1]=='x')
+    if (strlen(str)>2 && str[0]=='0' && str[1]=='x')
         return -1;
 
     x=atof(str);
diff --git a/tools/h5dump/h5dump.c b/tools/h5dump/h5dump.c
index ac9d1d3..80351d1 100644
--- a/tools/h5dump/h5dump.c
+++ b/tools/h5dump/h5dump.c
@@ -231,34 +231,34 @@ static void
 usage(const char *prog)
 {
     fflush(stdout);
-    fprintf(stdout, "usage: %s [OPTIONS] file\n", prog);
-    fprintf(stdout, "  OPTIONS\n");
-    fprintf(stdout, "     -h, --help           Print a usage message and exit\n");
-    fprintf(stdout, "     -n, --contents       Print a list of the file contents and exit\n");
-    fprintf(stdout, "     -B, --superblock     Print the content of the super block\n");
-    fprintf(stdout, "     -H, --header         Print the header only; no data is displayed\n");
-    fprintf(stdout, "     -A, --onlyattr       Print the header and value of attributes\n");
-    fprintf(stdout, "     -i, --object-ids     Print the object ids\n");
-    fprintf(stdout, "     -r, --string         Print 1-byte integer datasets as ASCII\n");
-    fprintf(stdout, "     -e, --escape         Escape non printing characters\n");
-    fprintf(stdout, "     -V, --version        Print version number and exit\n");
-    fprintf(stdout, "     -a P, --attribute=P  Print the specified attribute\n");
-    fprintf(stdout, "     -d P, --dataset=P    Print the specified dataset\n");
-    fprintf(stdout, "     -y, --noindex        Do not print array indices with the data\n");
-    fprintf(stdout, "     -p, --properties     Print dataset filters, storage layout and fill value\n");
-    fprintf(stdout, "     -f D, --filedriver=D Specify which driver to open the file with\n");
-    fprintf(stdout, "     -g P, --group=P      Print the specified group and all members\n");
-    fprintf(stdout, "     -l P, --soft-link=P  Print the value(s) of the specified soft link\n");
-    fprintf(stdout, "     -o F, --output=F     Output raw data into file F\n");
-    fprintf(stdout, "     -b B, --binary=B     Binary file output, of form B\n");
-    fprintf(stdout, "     -t P, --datatype=P   Print the specified named datatype\n");
-    fprintf(stdout, "     -w N, --width=N      Set the number of columns of output. A value of 0 (zero)\n");
-    fprintf(stdout, "                          sets the number of columns to the maximum (65535).\n");
-    fprintf(stdout, "                          Default width is 80 columns.\n");
-    fprintf(stdout, "     -m T, --format=T     Set the floating point output format\n");
-    fprintf(stdout, "     -q Q, --sort_by=Q    Sort groups and attributes by index Q\n");
-    fprintf(stdout, "     -z Z, --sort_order=Z Sort groups and attributes by order Z\n");
-    fprintf(stdout,
+    HDfprintf(stdout, "usage: %s [OPTIONS] file\n", prog);
+    HDfprintf(stdout, "  OPTIONS\n");
+    HDfprintf(stdout, "     -h, --help           Print a usage message and exit\n");
+    HDfprintf(stdout, "     -n, --contents       Print a list of the file contents and exit\n");
+    HDfprintf(stdout, "     -B, --superblock     Print the content of the super block\n");
+    HDfprintf(stdout, "     -H, --header         Print the header only; no data is displayed\n");
+    HDfprintf(stdout, "     -A, --onlyattr       Print the header and value of attributes\n");
+    HDfprintf(stdout, "     -i, --object-ids     Print the object ids\n");
+    HDfprintf(stdout, "     -r, --string         Print 1-byte integer datasets as ASCII\n");
+    HDfprintf(stdout, "     -e, --escape         Escape non printing characters\n");
+    HDfprintf(stdout, "     -V, --version        Print version number and exit\n");
+    HDfprintf(stdout, "     -a P, --attribute=P  Print the specified attribute\n");
+    HDfprintf(stdout, "     -d P, --dataset=P    Print the specified dataset\n");
+    HDfprintf(stdout, "     -y, --noindex        Do not print array indices with the data\n");
+    HDfprintf(stdout, "     -p, --properties     Print dataset filters, storage layout and fill value\n");
+    HDfprintf(stdout, "     -f D, --filedriver=D Specify which driver to open the file with\n");
+    HDfprintf(stdout, "     -g P, --group=P      Print the specified group and all members\n");
+    HDfprintf(stdout, "     -l P, --soft-link=P  Print the value(s) of the specified soft link\n");
+    HDfprintf(stdout, "     -o F, --output=F     Output raw data into file F\n");
+    HDfprintf(stdout, "     -b B, --binary=B     Binary file output, of form B\n");
+    HDfprintf(stdout, "     -t P, --datatype=P   Print the specified named datatype\n");
+    HDfprintf(stdout, "     -w N, --width=N      Set the number of columns of output. A value of 0 (zero)\n");
+    HDfprintf(stdout, "                          sets the number of columns to the maximum (65535).\n");
+    HDfprintf(stdout, "                          Default width is 80 columns.\n");
+    HDfprintf(stdout, "     -m T, --format=T     Set the floating point output format\n");
+    HDfprintf(stdout, "     -q Q, --sort_by=Q    Sort groups and attributes by index Q\n");
+    HDfprintf(stdout, "     -z Z, --sort_order=Z Sort groups and attributes by order Z\n");
+    HDfprintf(stdout,
   "     -M L, --packedbits=L Print packed bits as unsigned integers, using mask\n"
   "                          format L for an integer dataset specified with\n"
   "                          option -d. L is a list of offset,length values,\n"
@@ -266,69 +266,69 @@ usage(const char *prog)
   "                          the data value and length is the number of bits of\n"
   "                          the mask.\n"
   );
-    fprintf(stdout, "     -R, --region         Print dataset pointed by region references\n");
-    fprintf(stdout, "     -x, --xml            Output in XML using Schema\n");
-    fprintf(stdout, "     -u, --use-dtd        Output in XML using DTD\n");
-    fprintf(stdout, "     -D U, --xml-dtd=U    Use the DTD or schema at U\n");
-    fprintf(stdout, "     -X S, --xml-ns=S      (XML Schema) Use qualified names n the XML\n");
-    fprintf(stdout, "                          \":\": no namespace, default: \"hdf5:\"\n");
-    fprintf(stdout, "                          E.g., to dump a file called `-f', use h5dump -- -f\n");
-    fprintf(stdout, "     --enable-error-stack Prints messages from the HDF5 error stack as they\n");
-    fprintf(stdout, "                          occur.\n");
-    fprintf(stdout, "     --no-compact-subset  Disable compact form of subsetting and allow the use\n");
-    fprintf(stdout, "                          of \"[\" in datset names.\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, " Subsetting is available by using the following options with a dataset\n");
-    fprintf(stdout, " attribute. Subsetting is done by selecting a hyperslab from the data.\n");
-    fprintf(stdout, " Thus, the options mirror those for performing a hyperslab selection.\n");
-    fprintf(stdout, " One of the START, COUNT, STRIDE, or BLOCK parameters are mandatory if you do subsetting.\n");
-    fprintf(stdout, " The STRIDE, COUNT, and BLOCK parameters are optional and will default to 1 in\n");
-    fprintf(stdout, " each dimension. START is optional and will default to 0 in each dimension.\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "      -s START,  --start=START    Offset of start of subsetting selection\n");
-    fprintf(stdout, "      -S STRIDE, --stride=STRIDE  Hyperslab stride\n");
-    fprintf(stdout, "      -c COUNT,  --count=COUNT    Number of blocks to include in selection\n");
-    fprintf(stdout, "      -k BLOCK,  --block=BLOCK    Size of block in hyperslab\n");
-    fprintf(stdout, "  START, COUNT, STRIDE, and BLOCK - is a list of integers the number of which are equal to the\n");
-    fprintf(stdout, "        number of dimensions in the dataspace being queried\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "  D - is the file driver to use in opening the file. Acceptable values\n");
-    fprintf(stdout, "        are \"sec2\", \"family\", \"split\", \"multi\", \"direct\", and \"stream\". Without\n");
-    fprintf(stdout, "        the file driver flag, the file will be opened with each driver in\n");
-    fprintf(stdout, "        turn and in the order specified above until one driver succeeds\n");
-    fprintf(stdout, "        in opening the file.\n");
-    fprintf(stdout, "  F - is a filename.\n");
-    fprintf(stdout, "  P - is the full path from the root group to the object.\n");
-    fprintf(stdout, "  N - is an integer greater than 1.\n");
-    fprintf(stdout, "  T - is a string containing the floating point format, e.g '%%.3f'\n");
-    fprintf(stdout, "  U - is a URI reference (as defined in [IETF RFC 2396],\n");
-    fprintf(stdout, "        updated by [IETF RFC 2732])\n");
-    fprintf(stdout, "  B - is the form of binary output: NATIVE for a memory type, FILE for the\n");
-    fprintf(stdout, "        file type, LE or BE for pre-existing little or big endian types.\n");
-    fprintf(stdout, "        Must be used with -o (output file) and it is recommended that\n");
-    fprintf(stdout, "        -d (dataset) is used. B is an optional argument, defaults to NATIVE\n");
-    fprintf(stdout, "  Q - is the sort index type. It can be \"creation_order\" or \"name\" (default)\n");
-    fprintf(stdout, "  Z - is the sort order type. It can be \"descending\" or \"ascending\" (default)\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "  Examples:\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "  1) Attribute foo of the group /bar_none in file quux.h5\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "      h5dump -a /bar_none/foo quux.h5\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "  2) Selecting a subset from dataset /foo in file quux.h5\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "      h5dump -d /foo -s \"0,1\" -S \"1,1\" -c \"2,3\" -k \"2,2\" quux.h5\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "  3) Saving dataset 'dset' in file quux.h5 to binary file 'out.bin'\n");
-    fprintf(stdout, "        using a little-endian type\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "      h5dump -d /dset -b LE -o out.bin quux.h5\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "  4) Display two packed bits (bits 0-1 and bits 4-6) in the dataset /dset\n");
-    fprintf(stdout, "\n");
-    fprintf(stdout, "      h5dump -d /dset -M 0,1,4,3 quux.h5\n");
-    fprintf(stdout, "\n");
+    HDfprintf(stdout, "     -R, --region         Print dataset pointed by region references\n");
+    HDfprintf(stdout, "     -x, --xml            Output in XML using Schema\n");
+    HDfprintf(stdout, "     -u, --use-dtd        Output in XML using DTD\n");
+    HDfprintf(stdout, "     -D U, --xml-dtd=U    Use the DTD or schema at U\n");
+    HDfprintf(stdout, "     -X S, --xml-ns=S      (XML Schema) Use qualified names n the XML\n");
+    HDfprintf(stdout, "                          \":\": no namespace, default: \"hdf5:\"\n");
+    HDfprintf(stdout, "                          E.g., to dump a file called `-f', use h5dump -- -f\n");
+    HDfprintf(stdout, "     --enable-error-stack Prints messages from the HDF5 error stack as they\n");
+    HDfprintf(stdout, "                          occur.\n");
+    HDfprintf(stdout, "     --no-compact-subset  Disable compact form of subsetting and allow the use\n");
+    HDfprintf(stdout, "                          of \"[\" in datset names.\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, " Subsetting is available by using the following options with a dataset\n");
+    HDfprintf(stdout, " attribute. Subsetting is done by selecting a hyperslab from the data.\n");
+    HDfprintf(stdout, " Thus, the options mirror those for performing a hyperslab selection.\n");
+    HDfprintf(stdout, " One of the START, COUNT, STRIDE, or BLOCK parameters are mandatory if you do subsetting.\n");
+    HDfprintf(stdout, " The STRIDE, COUNT, and BLOCK parameters are optional and will default to 1 in\n");
+    HDfprintf(stdout, " each dimension. START is optional and will default to 0 in each dimension.\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "      -s START,  --start=START    Offset of start of subsetting selection\n");
+    HDfprintf(stdout, "      -S STRIDE, --stride=STRIDE  Hyperslab stride\n");
+    HDfprintf(stdout, "      -c COUNT,  --count=COUNT    Number of blocks to include in selection\n");
+    HDfprintf(stdout, "      -k BLOCK,  --block=BLOCK    Size of block in hyperslab\n");
+    HDfprintf(stdout, "  START, COUNT, STRIDE, and BLOCK - is a list of integers the number of which are equal to the\n");
+    HDfprintf(stdout, "        number of dimensions in the dataspace being queried\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "  D - is the file driver to use in opening the file. Acceptable values\n");
+    HDfprintf(stdout, "        are \"sec2\", \"family\", \"split\", \"multi\", \"direct\", and \"stream\". Without\n");
+    HDfprintf(stdout, "        the file driver flag, the file will be opened with each driver in\n");
+    HDfprintf(stdout, "        turn and in the order specified above until one driver succeeds\n");
+    HDfprintf(stdout, "        in opening the file.\n");
+    HDfprintf(stdout, "  F - is a filename.\n");
+    HDfprintf(stdout, "  P - is the full path from the root group to the object.\n");
+    HDfprintf(stdout, "  N - is an integer greater than 1.\n");
+    HDfprintf(stdout, "  T - is a string containing the floating point format, e.g '%%.3f'\n");
+    HDfprintf(stdout, "  U - is a URI reference (as defined in [IETF RFC 2396],\n");
+    HDfprintf(stdout, "        updated by [IETF RFC 2732])\n");
+    HDfprintf(stdout, "  B - is the form of binary output: NATIVE for a memory type, FILE for the\n");
+    HDfprintf(stdout, "        file type, LE or BE for pre-existing little or big endian types.\n");
+    HDfprintf(stdout, "        Must be used with -o (output file) and it is recommended that\n");
+    HDfprintf(stdout, "        -d (dataset) is used. B is an optional argument, defaults to NATIVE\n");
+    HDfprintf(stdout, "  Q - is the sort index type. It can be \"creation_order\" or \"name\" (default)\n");
+    HDfprintf(stdout, "  Z - is the sort order type. It can be \"descending\" or \"ascending\" (default)\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "  Examples:\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "  1) Attribute foo of the group /bar_none in file quux.h5\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "      h5dump -a /bar_none/foo quux.h5\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "  2) Selecting a subset from dataset /foo in file quux.h5\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "      h5dump -d /foo -s \"0,1\" -S \"1,1\" -c \"2,3\" -k \"2,2\" quux.h5\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "  3) Saving dataset 'dset' in file quux.h5 to binary file 'out.bin'\n");
+    HDfprintf(stdout, "        using a little-endian type\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "      h5dump -d /dset -b LE -o out.bin quux.h5\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "  4) Display two packed bits (bits 0-1 and bits 4-6) in the dataset /dset\n");
+    HDfprintf(stdout, "\n");
+    HDfprintf(stdout, "      h5dump -d /dset -M 0,1,4,3 quux.h5\n");
+    HDfprintf(stdout, "\n");
 }
 
 
diff --git a/tools/h5dump/h5dump_xml.c b/tools/h5dump/h5dump_xml.c
index b92ccdb..94e4d28 100644
--- a/tools/h5dump/h5dump_xml.c
+++ b/tools/h5dump/h5dump_xml.c
@@ -601,27 +601,27 @@ xml_escape_the_name(const char *str)
 
     for (i = 0; i < len; i++) {
         if (*cp == '\'') {
-            strncpy(ncp, apos, HDstrlen(apos));
+            HDstrncpy(ncp, apos, HDstrlen(apos));
             ncp += HDstrlen(apos);
             cp++;
         } 
         else if (*cp == '<') {
-            strncpy(ncp, lt, HDstrlen(lt));
+            HDstrncpy(ncp, lt, HDstrlen(lt));
             ncp += HDstrlen(lt);
             cp++;
         } 
         else if (*cp == '>') {
-            strncpy(ncp, gt, HDstrlen(gt));
+            HDstrncpy(ncp, gt, HDstrlen(gt));
             ncp += HDstrlen(gt);
             cp++;
         } 
         else if (*cp == '\"') {
-            strncpy(ncp, quote, HDstrlen(quote));
+            HDstrncpy(ncp, quote, HDstrlen(quote));
             ncp += HDstrlen(quote);
             cp++;
         } 
         else if (*cp == '&') {
-            strncpy(ncp, amp, HDstrlen(amp));
+            HDstrncpy(ncp, amp, HDstrlen(amp));
             ncp += HDstrlen(amp);
             cp++;
         } 
@@ -708,22 +708,22 @@ xml_escape_the_string(const char *str, int slen)
             *ncp++ = *cp++;
         }
         else if (*cp == '\'') {
-            strncpy(ncp, apos, HDstrlen(apos));
+            HDstrncpy(ncp, apos, HDstrlen(apos));
             ncp += HDstrlen(apos);
             cp++;
         }
         else if (*cp == '<') {
-            strncpy(ncp, lt, HDstrlen(lt));
+            HDstrncpy(ncp, lt, HDstrlen(lt));
             ncp += HDstrlen(lt);
             cp++;
         }
         else if (*cp == '>') {
-            strncpy(ncp, gt, HDstrlen(gt));
+            HDstrncpy(ncp, gt, HDstrlen(gt));
             ncp += HDstrlen(gt);
             cp++;
         }
         else if (*cp == '&') {
-            strncpy(ncp, amp, HDstrlen(amp));
+            HDstrncpy(ncp, amp, HDstrlen(amp));
             ncp += HDstrlen(amp);
             cp++;
         }
diff --git a/tools/h5import/h5import.c b/tools/h5import/h5import.c
index 232f3c1..31d44de 100755
--- a/tools/h5import/h5import.c
+++ b/tools/h5import/h5import.c
@@ -65,7 +65,7 @@ int main(int argc, char *argv[])
      * validate the number of command line arguments
      */
     if (argc < 2) {
-        (void) fprintf(stderr, err1, argc);
+        (void) HDfprintf(stderr, err1, argc);
         usage(argv[0]);
         goto err;
     }
@@ -95,7 +95,7 @@ int main(int argc, char *argv[])
                 opt.fcount++;
             }
             else {
-                (void) fprintf(stderr, err9, argv[i]);
+                (void) HDfprintf(stderr, err9, argv[i]);
                 goto err;
             }
 
@@ -127,7 +127,7 @@ int main(int argc, char *argv[])
 
         case 8: /* read dimensions */
             if (parseDimensions(in, argv[i]) == -1) {
-                (void) fprintf(stderr, err6, argv[i]);
+                (void) HDfprintf(stderr, err6, argv[i]);
                 goto err;
             }
             break;
@@ -137,7 +137,7 @@ int main(int argc, char *argv[])
 
         case 10: /* read path name */
             if (parsePathInfo(&in->path, argv[i]) == -1) {
-                (void) fprintf(stderr, err5, argv[i]);
+                (void) HDfprintf(stderr, err5, argv[i]);
                 goto err;
             }
             break;
@@ -147,7 +147,7 @@ int main(int argc, char *argv[])
 
         case 12: /* read data type */
             if (getInputClass(in, argv[i]) == -1) {
-                (void) fprintf(stderr, err7, argv[i]);
+                (void) HDfprintf(stderr, err7, argv[i]);
                 goto err;
             }
 
@@ -164,7 +164,7 @@ int main(int argc, char *argv[])
 
         case 14: /* read data size */
             if (getInputSize(in, (int) HDstrtol(argv[i], NULL, BASE_10)) == -1) {
-                (void) fprintf(stderr, err8, argv[i]);
+                (void) HDfprintf(stderr, err8, argv[i]);
                 goto err;
             }
             /*set default value for output-size */
@@ -173,14 +173,14 @@ int main(int argc, char *argv[])
 
         case ERR: /* command syntax error */
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             usage(argv[0]);
             goto err;
         }
     }
 
     if (FALSE == outfile_named) {
-        (void) fprintf(stderr, "%s", err3);
+        (void) HDfprintf(stderr, "%s", err3);
         usage(argv[0]);
         goto err;
     }
@@ -204,7 +204,7 @@ int main(int argc, char *argv[])
 
     return (EXIT_SUCCESS);
 err: 
-    (void) fprintf(stderr, "%s", err4);
+    (void) HDfprintf(stderr, "%s", err4);
     for (i = 0; i < opt.fcount; i++) {
         in = &(opt.infiles[i].in);
         if (in->sizeOfDimension)
@@ -272,7 +272,7 @@ static int gtoken(char *s)
         }
 
         if (token == ERR)
-            (void) fprintf(stderr, err1, s);
+            (void) HDfprintf(stderr, err1, s);
     }
     else { /* filename */
         token = FILNAME;
@@ -318,7 +318,7 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id)
     if (in->inputClass == 4 /* "IN" */|| in->inputClass == 3 /* "FP" */|| in->inputClass == 7 /* "UIN" */) {
 
         if ((strm = HDfopen(infile, READ_OPEN_FLAGS)) == NULL) {
-            (void) fprintf(stderr, err1, infile);
+            (void) HDfprintf(stderr, err1, infile);
             return (-1);
         }
     }
@@ -328,7 +328,7 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id)
      */
     else {
         if ((strm = HDfopen(infile, "r")) == NULL) {
-            (void) fprintf(stderr, err1, infile);
+            (void) HDfprintf(stderr, err1, infile);
             return (-1);
         }
     }
@@ -337,13 +337,13 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id)
     case 0: /*  TEXTIN */
     case 4: /*  IN  */
         if (allocateIntegerStorage(in) == -1) {
-            (void) fprintf(stderr, err2, infile);
+            (void) HDfprintf(stderr, err2, infile);
             HDfclose(strm);
             return (-1);
         }
 
         if (readIntegerData(strm, in) == -1) {
-            (void) fprintf(stderr, err4, infile);
+            (void) HDfprintf(stderr, err4, infile);
             HDfclose(strm);
             return (-1);
         }
@@ -353,14 +353,14 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id)
     case 2: /*  TEXTFPE  */
     case 3: /*  FP  */
         if (allocateFloatStorage(in) == -1) {
-            (void) fprintf(stderr, err3, infile);
+            (void) HDfprintf(stderr, err3, infile);
             HDfclose(strm);
             return (-1);
 
         }
 
         if (readFloatData(strm, in) == -1) {
-            (void) fprintf(stderr, err5, infile);
+            (void) HDfprintf(stderr, err5, infile);
             HDfclose(strm);
             return (-1);
         }
@@ -369,7 +369,7 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id)
     case 5: /*  STR  */
 
         if (processStrData(strm, in, file_id) == -1) {
-            (void) fprintf(stderr, err11, infile);
+            (void) HDfprintf(stderr, err11, infile);
             HDfclose(strm);
             return (-1);
         }
@@ -379,19 +379,19 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id)
     case 6: /* TEXTUIN */
     case 7: /* UIN */
         if (allocateUIntegerStorage(in) == -1) {
-            (void) fprintf(stderr, err6, infile);
+            (void) HDfprintf(stderr, err6, infile);
             HDfclose(strm);
             return (-1);
         }
         if (readUIntegerData(strm, in) == -1) {
-            (void) fprintf(stderr, err7, infile);
+            (void) HDfprintf(stderr, err7, infile);
             HDfclose(strm);
             return (-1);
         }
         break;
 
     default:
-        (void) fprintf(stderr, "%s", err10);
+        (void) HDfprintf(stderr, "%s", err10);
         HDfclose(strm);
         return (-1);
     }
@@ -427,7 +427,7 @@ static int readIntegerData(FILE *strm, struct Input *in)
             in08 = (H5DT_INT8 *) in->data;
             for (i = 0; i < len; i++, in08++) {
                 if (fscanf(strm, "%hd", &temp) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
                 (*in08) = (H5DT_INT8) temp;
@@ -438,14 +438,14 @@ static int readIntegerData(FILE *strm, struct Input *in)
             in08 = (H5DT_INT8 *) in->data;
             for (i = 0; i < len; i++, in08++) {
                 if (HDfread((char *) in08, sizeof(H5DT_INT8), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
@@ -456,7 +456,7 @@ static int readIntegerData(FILE *strm, struct Input *in)
         case 0: /* TEXTIN */
             for (i = 0; i < len; i++, in16++) {
                 if (fscanf(strm, "%hd", in16) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -466,14 +466,14 @@ static int readIntegerData(FILE *strm, struct Input *in)
         case 4: /* IN */
             for (i = 0; i < len; i++, in16++) {
                 if (HDfread((char *) in16, sizeof(H5DT_INT16), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
@@ -484,7 +484,7 @@ static int readIntegerData(FILE *strm, struct Input *in)
         case 0: /* TEXTIN */
             for (i = 0; i < len; i++, in32++) {
                 if (fscanf(strm, "%d", in32) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -493,14 +493,14 @@ static int readIntegerData(FILE *strm, struct Input *in)
         case 4: /* IN */
             for (i = 0; i < len; i++, in32++) {
                 if (HDfread((char *) in32, sizeof(H5DT_INT32), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
@@ -512,7 +512,7 @@ static int readIntegerData(FILE *strm, struct Input *in)
         case 0: /* TEXTIN */
             for (i = 0; i < len; i++, in64++) {
                 if (fscanf(strm, "%s", buffer) < 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
                 *in64 = (H5DT_INT64) HDstrtoll(buffer, NULL, 10);
@@ -522,21 +522,21 @@ static int readIntegerData(FILE *strm, struct Input *in)
         case 4: /* IN */
             for (i = 0; i < len; i++, in64++) {
                 if (HDfread((char *) in64, sizeof(H5DT_INT64), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
 #endif /* ifdef H5_SIZEOF_LONG_LONG */
 
     default:
-        (void) fprintf(stderr, "%s", err3);
+        (void) HDfprintf(stderr, "%s", err3);
         break;
     }
     return (0);
@@ -569,7 +569,7 @@ static int readUIntegerData(FILE *strm, struct Input *in)
             in08 = (H5DT_UINT8 *) in->data;
             for (i = 0; i < len; i++, in08++) {
                 if (fscanf(strm, "%hu", &temp) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
                 (*in08) = (H5DT_UINT8) temp;
@@ -580,14 +580,14 @@ static int readUIntegerData(FILE *strm, struct Input *in)
             in08 = (H5DT_UINT8 *) in->data;
             for (i = 0; i < len; i++, in08++) {
                 if (HDfread((char *) in08, sizeof(H5DT_UINT8), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
@@ -598,7 +598,7 @@ static int readUIntegerData(FILE *strm, struct Input *in)
         case 6: /* TEXTUIN */
             for (i = 0; i < len; i++, in16++) {
                 if (fscanf(strm, "%hu", in16) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -607,14 +607,14 @@ static int readUIntegerData(FILE *strm, struct Input *in)
         case 7: /* UIN */
             for (i = 0; i < len; i++, in16++) {
                 if (HDfread((char *) in16, sizeof(H5DT_UINT16), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
@@ -625,7 +625,7 @@ static int readUIntegerData(FILE *strm, struct Input *in)
         case 6: /* TEXTUIN */
             for (i = 0; i < len; i++, in32++) {
                 if (fscanf(strm, "%u", in32) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -634,14 +634,14 @@ static int readUIntegerData(FILE *strm, struct Input *in)
         case 7: /* UIN */
             for (i = 0; i < len; i++, in32++) {
                 if (HDfread((char *) in32, sizeof(H5DT_UINT32), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
@@ -653,7 +653,7 @@ static int readUIntegerData(FILE *strm, struct Input *in)
         case 6: /* TEXTUIN */
             for (i = 0; i < len; i++, in64++) {
                 if (fscanf(strm, "%s", buffer) < 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
                 *in64 = (H5DT_UINT64) HDstrtoll(buffer, NULL, 10);
@@ -663,21 +663,21 @@ static int readUIntegerData(FILE *strm, struct Input *in)
         case 7: /* UIN */
             for (i = 0; i < len; i++, in64++) {
                 if (HDfread((char *) in64, sizeof(H5DT_UINT64), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
 #endif /* ifdef H5_SIZEOF_LONG_LONG */
 
     default:
-        (void) fprintf(stderr, "%s", err3);
+        (void) HDfprintf(stderr, "%s", err3);
         break;
     }
     return (0);
@@ -705,7 +705,7 @@ static int readFloatData(FILE *strm, struct Input *in)
         case 1: /* TEXTFP */
             for (i = 0; i < len; i++, fp32++) {
                 if (fscanf(strm, "%f", fp32) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -718,7 +718,7 @@ static int readFloatData(FILE *strm, struct Input *in)
 
             for (i = 0; i < len; i++, fp32++) {
                 if (fscanf(strm, "%f", fp32) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -729,14 +729,14 @@ static int readFloatData(FILE *strm, struct Input *in)
         case 3: /* FP */
             for (i = 0; i < len; i++, fp32++) {
                 if (HDfread((char *) fp32, sizeof(H5DT_FLOAT32), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
@@ -747,7 +747,7 @@ static int readFloatData(FILE *strm, struct Input *in)
         case 1: /* TEXTFP */
             for (i = 0; i < len; i++, fp64++) {
                 if (fscanf(strm, "%lf", fp64) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -760,7 +760,7 @@ static int readFloatData(FILE *strm, struct Input *in)
 
             for (i = 0; i < len; i++, fp64++) {
                 if (fscanf(strm, "%lf", fp64) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
@@ -771,20 +771,20 @@ static int readFloatData(FILE *strm, struct Input *in)
         case 3: /* FP */
             for (i = 0; i < len; i++, fp64++) {
                 if (HDfread((char *) fp64, sizeof(H5DT_FLOAT64), 1, strm) != 1) {
-                    (void) fprintf(stderr, "%s", err1);
+                    (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
             }
             break;
 
         default:
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         break;
 
     default:
-        (void) fprintf(stderr, "%s", err3);
+        (void) HDfprintf(stderr, "%s", err3);
         break;
     }
     return (0);
@@ -953,34 +953,34 @@ static int allocateIntegerStorage(struct Input *in)
     switch (in->inputSize) {
     case 8:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT8))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     case 16:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT16))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     case 32:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT32))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     case 64:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT64))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     default:
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         break;
     }
     return (0);
@@ -999,34 +999,34 @@ static int allocateUIntegerStorage(struct Input *in)
     switch (in->inputSize) {
     case 8:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT8))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     case 16:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT16))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     case 32:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT32))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     case 64:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT64))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     default:
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         break;
     }
     return (0);
@@ -1045,20 +1045,20 @@ static int allocateFloatStorage(struct Input *in)
     switch (in->inputSize) {
     case 32:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_FLOAT32))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     case 64:
         if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_FLOAT64))) == NULL) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
         break;
 
     default:
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         break;
     }
     return (0);
@@ -1116,30 +1116,30 @@ static int processConfigurationFile(char *infile, struct Input *in)
      */
 
     if ((strm = HDfopen(infile, "r")) == NULL) {
-        (void) fprintf(stderr, err1, infile);
+        (void) HDfprintf(stderr, err1, infile);
         return (-1);
     }
 
     while (fscanf(strm, "%s", key) == 1) {
         if ((kindex = mapKeywordToIndex(key)) == -1) {
-            (void) fprintf(stderr, err2, infile);
+            (void) HDfprintf(stderr, err2, infile);
             HDfclose(strm);
             return (-1);
         }
         switch (kindex) {
         case 0: /* PATH */
             if (in->configOptionVector[PATH] == 1) {
-                (void) fprintf(stderr, err3a, infile);
+                (void) HDfprintf(stderr, err3a, infile);
                 HDfclose(strm);
                 return (-1);
             }
             if (fscanf(strm, "%s", temp) != 1) {
-                (void) fprintf(stderr, "%s", err18);
+                (void) HDfprintf(stderr, "%s", err18);
                 HDfclose(strm);
                 return (-1);
             }
             if (parsePathInfo(&in->path, temp) == -1) {
-                (void) fprintf(stderr, err3b, infile);
+                (void) HDfprintf(stderr, err3b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1148,18 +1148,18 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 1: /* INPUT-CLASS */
             if (in->configOptionVector[INPUT_CLASS] == 1) {
-                (void) fprintf(stderr, err4a, infile);
+                (void) HDfprintf(stderr, err4a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (fscanf(strm, "%s", temp) != 1) {
-                (void) fprintf(stderr, "%s", err18);
+                (void) HDfprintf(stderr, "%s", err18);
                 HDfclose(strm);
                 return (-1);
             }
             if (getInputClass(in, temp) == -1) {
-                (void) fprintf(stderr, err4b, infile);
+                (void) HDfprintf(stderr, err4b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1180,17 +1180,17 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 2: /* INPUT-SIZE */
             if (in->configOptionVector[INPUT_SIZE] == 1) {
-                (void) fprintf(stderr, err5a, infile);
+                (void) HDfprintf(stderr, err5a, infile);
                 HDfclose(strm);
                 return (-1);
             }
             if (fscanf(strm, "%d", (&ival)) != 1) {
-                (void) fprintf(stderr, "%s", err19);
+                (void) HDfprintf(stderr, "%s", err19);
                 HDfclose(strm);
                 return (-1);
             }
             if (getInputSize(in, ival) == -1) {
-                (void) fprintf(stderr, err5b, infile);
+                (void) HDfprintf(stderr, err5b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1203,13 +1203,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 3: /* RANK */
             if (in->configOptionVector[RANK] == 1) {
-                (void) fprintf(stderr, err6a, infile);
+                (void) HDfprintf(stderr, err6a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getRank(in, strm) == -1) {
-                (void) fprintf(stderr, err6b, infile);
+                (void) HDfprintf(stderr, err6b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1218,18 +1218,18 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 4: /* DIMENSION-SIZES */
             if (in->configOptionVector[DIM] == 1) {
-                (void) fprintf(stderr, err7a, infile);
+                (void) HDfprintf(stderr, err7a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (in->configOptionVector[RANK] == 0) {
-                (void) fprintf(stderr, err7b, infile);
+                (void) HDfprintf(stderr, err7b, infile);
                 HDfclose(strm);
                 return (-1);
             }
             if (getDimensionSizes(in, strm) == -1) {
-                (void) fprintf(stderr, err7c, infile);
+                (void) HDfprintf(stderr, err7c, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1238,13 +1238,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 5: /* OUTPUT-CLASS */
             if (in->configOptionVector[OUTPUT_CLASS] == 1) {
-                (void) fprintf(stderr, err8a, infile);
+                (void) HDfprintf(stderr, err8a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getOutputClass(in, strm) == -1) {
-                (void) fprintf(stderr, err8b, infile);
+                (void) HDfprintf(stderr, err8b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1253,13 +1253,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 6: /* OUTPUT-SIZE */
             if (in->configOptionVector[OUTPUT_SIZE] == 1) {
-                (void) fprintf(stderr, err9a, infile);
+                (void) HDfprintf(stderr, err9a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getOutputSize(in, strm) == -1) {
-                (void) fprintf(stderr, err9b, infile);
+                (void) HDfprintf(stderr, err9b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1268,13 +1268,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 7: /* OUTPUT-ARCHITECTURE */
             if (in->configOptionVector[OUTPUT_ARCH] == 1) {
-                (void) fprintf(stderr, err10a, infile);
+                (void) HDfprintf(stderr, err10a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getOutputArchitecture(in, strm) == -1) {
-                (void) fprintf(stderr, err10b, infile);
+                (void) HDfprintf(stderr, err10b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1283,13 +1283,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 8: /* OUTPUT-BYTE-ORDER */
             if (in->configOptionVector[OUTPUT_B_ORDER] == 1) {
-                (void) fprintf(stderr, err11a, infile);
+                (void) HDfprintf(stderr, err11a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getOutputByteOrder(in, strm) == -1) {
-                (void) fprintf(stderr, err11b, infile);
+                (void) HDfprintf(stderr, err11b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1298,19 +1298,19 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 9: /* CHUNKED-DIMENSION-SIZES */
             if (in->configOptionVector[CHUNK] == 1) {
-                (void) fprintf(stderr, err12a, infile);
+                (void) HDfprintf(stderr, err12a, infile);
                 HDfclose(strm);
                 return (-1);
             }
             /* cant appear before dimension sizes have been provided */
             if (in->configOptionVector[DIM] == 0) {
-                (void) fprintf(stderr, err12b, infile);
+                (void) HDfprintf(stderr, err12b, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getChunkedDimensionSizes(in, strm) == -1) {
-                (void) fprintf(stderr, err12c, infile);
+                (void) HDfprintf(stderr, err12c, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1319,13 +1319,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 10: /* COMPRESSION-TYPE */
             if (in->configOptionVector[COMPRESS] == 1) {
-                (void) fprintf(stderr, err13a, infile);
+                (void) HDfprintf(stderr, err13a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getCompressionType(in, strm) == -1) {
-                (void) fprintf(stderr, err13b, infile);
+                (void) HDfprintf(stderr, err13b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1339,13 +1339,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 11: /* COMPRESSION-PARAM */
             if (in->configOptionVector[COMPRESS_PARAM] == 1) {
-                (void) fprintf(stderr, err14a, infile);
+                (void) HDfprintf(stderr, err14a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getCompressionParameter(in, strm) == -1) {
-                (void) fprintf(stderr, err14b, infile);
+                (void) HDfprintf(stderr, err14b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1359,13 +1359,13 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 12: /* EXTERNAL-STORAGE */
             if (in->configOptionVector[EXTERNAL] == 1) {
-                (void) fprintf(stderr, err15a, infile);
+                (void) HDfprintf(stderr, err15a, infile);
                 HDfclose(strm);
                 return (-1);
             }
 
             if (getExternalFilename(in, strm) == -1) {
-                (void) fprintf(stderr, err15b, infile);
+                (void) HDfprintf(stderr, err15b, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1374,18 +1374,18 @@ static int processConfigurationFile(char *infile, struct Input *in)
 
         case 13: /* MAXIMUM-DIMENSIONS */
             if (in->configOptionVector[EXTEND] == 1) {
-                (void) fprintf(stderr, err16a, infile);
+                (void) HDfprintf(stderr, err16a, infile);
                 HDfclose(strm);
                 return (-1);
             }
             /* cant appear before dimension sizes have been provided */
             if (in->configOptionVector[DIM] == 0) {
-                (void) fprintf(stderr, err16b, infile);
+                (void) HDfprintf(stderr, err16b, infile);
                 HDfclose(strm);
                 return (-1);
             }
             if (getMaximumDimensionSizes(in, strm) == -1) {
-                (void) fprintf(stderr, err16c, infile);
+                (void) HDfprintf(stderr, err16c, infile);
                 HDfclose(strm);
                 return (-1);
             }
@@ -1402,7 +1402,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
      */
 
     if (validateConfigurationParameters(in) == -1) {
-        (void) fprintf(stderr, err17, infile);
+        (void) HDfprintf(stderr, err17, infile);
         HDfclose(strm);
         return (-1);
     }
@@ -1428,20 +1428,20 @@ static int validateConfigurationParameters(struct Input *in)
         return (0);
 
     if ((in->configOptionVector[DIM] != 1) || (in->configOptionVector[RANK] != 1)) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
     if (in->configOptionVector[EXTERNAL] == 1) {
         if ((in->configOptionVector[COMPRESS] == 1) || (in->configOptionVector[CHUNK] == 1) || (in->configOptionVector[EXTEND] == 1)) {
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
     }
 
     if ((in->configOptionVector[COMPRESS] == 1) || (in->configOptionVector[EXTEND] == 1)) {
         if (in->configOptionVector[CHUNK] != 1) {
-            (void) fprintf(stderr, "%s", err3);
+            (void) HDfprintf(stderr, "%s", err3);
             return (-1);
         }
     }
@@ -1449,26 +1449,26 @@ static int validateConfigurationParameters(struct Input *in)
     /* Arch cant be STD if O/p class is FP */
     if (in->outputArchitecture == 1)
         if (in->outputClass == 1) {
-            (void) fprintf(stderr, "%s", err4a);
+            (void) HDfprintf(stderr, "%s", err4a);
             return (-1);
         }
 
     /* Arch cant be IEEE if O/p class is IN */
     if (in->outputArchitecture == 2)
         if (in->outputClass == 0) {
-            (void) fprintf(stderr, "%s", err4b);
+            (void) HDfprintf(stderr, "%s", err4b);
             return (-1);
         }
 
     if (in->outputClass == 1)
         if (in->outputSize != 32 && in->outputSize != 64) {
-            (void) fprintf(stderr, "%s", err5);
+            (void) HDfprintf(stderr, "%s", err5);
             return (-1);
         }
 
 #ifndef H5_SIZEOF_LONG_LONG
     if (in->inputSize == 64 && (in->inputClass == 0 || in->inputClass == 4 || in->inputClass == 6 || in->inputClass == 7) ) {
-        (void) fprintf(stderr, "%s", err6);
+        (void) HDfprintf(stderr, "%s", err6);
         return -1;
     }
 #endif
@@ -1494,7 +1494,7 @@ static int parsePathInfo(struct path_info *path, char *temp)
 
     token = HDstrtok (temp, delimiter);
     if (HDstrlen(token) >= MAX_PATH_NAME_LENGTH) {
-        (void) fprintf(stderr, err1);
+        (void) HDfprintf(stderr, err1);
         return (-1);
     }
     HDstrcpy(path->group[i++],token);
@@ -1504,7 +1504,7 @@ static int parsePathInfo(struct path_info *path, char *temp)
         if (token == NULL)
             break;
         if (HDstrlen(token) >= MAX_PATH_NAME_LENGTH) {
-            (void) fprintf(stderr, err1);
+            (void) HDfprintf(stderr, err1);
             return (-1);
         }
         HDstrcpy(path->group[i++],token);
@@ -1533,7 +1533,7 @@ static int parseDimensions(struct Input *in, char *strm)
     }
     in->rank = i + 1;
     if ((in->sizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
@@ -1560,12 +1560,12 @@ static int getOutputClass(struct Input *in, FILE *strm)
     const char *err2 = "Invalid value for output class.\n";
 
     if (fscanf(strm, "%s", temp) != 1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
     if ((kindex = OutputClassStrToInt(temp)) == -1) {
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         return (-1);
     }
 
@@ -1593,7 +1593,7 @@ static int getOutputSize(struct Input *in, FILE *strm)
     const char *err2 = "Invalid value for output size.\n";
 
     if (fscanf(strm, "%d", (&ival)) != 1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
@@ -1602,7 +1602,7 @@ static int getOutputSize(struct Input *in, FILE *strm)
             in->outputSize = ival;
             return (0);
         }
-    (void) fprintf(stderr, "%s", err2);
+    (void) HDfprintf(stderr, "%s", err2);
     return (-1);
 }
 
@@ -1612,7 +1612,7 @@ static int getInputClass(struct Input *in, char * temp)
     const char *err1 = "Invalid value for input class.\n";
 
     if ((kindex = InputClassStrToInt(temp)) == -1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
@@ -1642,7 +1642,7 @@ static int getInputSize(struct Input *in, int ival)
             in->inputSize = ival;
             return (0);
         }
-    (void) fprintf(stderr, "%s", err1);
+    (void) HDfprintf(stderr, "%s", err1);
     return (-1);
 }
 
@@ -1654,7 +1654,7 @@ static int getRank(struct Input *in, FILE *strm)
     const char *err2 = "Invalid value for rank.\n";
 
     if (fscanf(strm, "%d", (&ival)) != 1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
     if (ival >= MIN_NUM_DIMENSION && ival <= MAX_NUM_DIMENSION) {
@@ -1662,7 +1662,7 @@ static int getRank(struct Input *in, FILE *strm)
         return (0);
     }
 
-    (void) fprintf(stderr, "%s", err2);
+    (void) HDfprintf(stderr, "%s", err2);
     return (-1);
 }
 
@@ -1676,7 +1676,7 @@ static int getDimensionSizes(struct Input *in, FILE *strm)
     const char *err2 = "No. of dimensions for which dimension sizes provided is not equal to provided rank.\n";
 
     if ((in->sizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
@@ -1684,7 +1684,7 @@ static int getDimensionSizes(struct Input *in, FILE *strm)
         in->sizeOfDimension[i++] = ival;
 
     if (in->rank != i) {
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         return (-1);
     }
     return (0);
@@ -1700,7 +1700,7 @@ static int getChunkedDimensionSizes(struct Input *in, FILE *strm)
     const char *err3 = "The CHUNKED-DIMENSION-SIZES cannot exceed the sizes of DIMENSION-SIZES\n";
 
     if ((in->sizeOfChunk = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
@@ -1708,13 +1708,13 @@ static int getChunkedDimensionSizes(struct Input *in, FILE *strm)
         in->sizeOfChunk[i++] = ival;
 
     if (in->rank != i) {
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         return (-1);
     }
 
     for (i = 0; i < in->rank; i++)
         if (in->sizeOfChunk[i] > in->sizeOfDimension[i]) {
-            (void) fprintf(stderr, "%s", err3);
+            (void) HDfprintf(stderr, "%s", err3);
             return (-1);
         }
     return (0);
@@ -1730,7 +1730,7 @@ static int getMaximumDimensionSizes(struct Input *in, FILE *strm)
     const char *err3 = "The MAXIMUM-DIMENSIONS cannot be less than the sizes of DIMENSION-SIZES. Exception: can be -1 to indicate unlimited size\n";
 
     if ((in->maxsizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
@@ -1742,14 +1742,14 @@ static int getMaximumDimensionSizes(struct Input *in, FILE *strm)
     }
 
     if (in->rank != i) {
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         return (-1);
     }
 
     for (i = 0; i < in->rank; i++) {
         if (in->maxsizeOfDimension[i] != H5S_UNLIMITED)
             if (in->maxsizeOfDimension[i] < in->sizeOfDimension[i]) {
-                (void) fprintf(stderr, "%s", err3);
+                (void) HDfprintf(stderr, "%s", err3);
                 return (-1);
             }
     }
@@ -1764,12 +1764,12 @@ static int getOutputArchitecture(struct Input *in, FILE *strm)
     const char *err2 = "Invalid value for output architecture.\n";
 
     if (fscanf(strm, "%s", temp) != 1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
     if ((kindex = OutputArchStrToInt(temp)) == -1) {
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         return (-1);
     }
 
@@ -1796,12 +1796,12 @@ static int getOutputByteOrder(struct Input *in, FILE *strm)
     const char *err2 = "Invalid value for output byte-order.\n";
 
     if (fscanf(strm, "%s", temp) != 1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
     if ((kindex = OutputByteOrderStrToInt(temp)) == -1) {
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         return (-1);
     }
 
@@ -1827,12 +1827,12 @@ static int getCompressionType(struct Input *in, FILE *strm)
     const char *err2 = "Invalid value for compression.\n";
 
     if (fscanf(strm, "%s", temp) != 1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
     if ((kindex = CompressionTypeStrToInt(temp)) == -1) {
-        (void) fprintf(stderr, "%s", err2);
+        (void) HDfprintf(stderr, "%s", err2);
         return (-1);
     }
 
@@ -1868,19 +1868,19 @@ static int getCompressionParameter(struct Input *in, FILE *strm)
     switch (in->compressionType) {
     case 0: /* GZIP */
         if (fscanf(strm, "%d", (&ival)) != 1) {
-            (void) fprintf(stderr, "%s", err1);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
 
         if (ival < 0 || ival > 9) {
-            (void) fprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err2);
             return (-1);
         }
         in->compressionParam = ival;
         return (0);
 
     default:
-        (void) fprintf(stderr, "%s", err3);
+        (void) HDfprintf(stderr, "%s", err3);
         return (-1);
     }
 }
@@ -1891,7 +1891,7 @@ static int getExternalFilename(struct Input *in, FILE *strm)
     const char *err1 = "Unable to get 'string' value.\n";
 
     if (fscanf(strm, "%s", temp) != 1) {
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
 
@@ -2183,7 +2183,7 @@ hid_t createOutputDataType(struct Input *in)
         break;
 
     default:
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
     return new_type;
@@ -2255,7 +2255,7 @@ hid_t createInputDataType(struct Input *in)
         break;
 
     default:
-        (void) fprintf(stderr, "%s", err1);
+        (void) HDfprintf(stderr, "%s", err1);
         return (-1);
     }
     return new_type;
@@ -2288,7 +2288,7 @@ static int process(struct Options *opt)
     {
         if ((file_id = H5Fopen(opt->outfile, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
             if ((file_id = H5Fcreate(opt->outfile, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) == FAIL) {
-                (void) fprintf(stderr, err1, opt->outfile);
+                (void) HDfprintf(stderr, err1, opt->outfile);
                 return (-1);
             }
         }
@@ -2299,13 +2299,13 @@ static int process(struct Options *opt)
         in = &(opt->infiles[k].in);
         if (opt->infiles[k].config == 1) {
             if (processConfigurationFile(opt->infiles[k].configfile, in) == -1) {
-                (void) fprintf(stderr, err2, opt->infiles[k].configfile);
+                (void) HDfprintf(stderr, err2, opt->infiles[k].configfile);
                 return (-1);
             }
         }
 
         if (processDataFile(opt->infiles[k].datafile, in, file_id) == -1) {
-            (void) fprintf(stderr, err3, opt->infiles[k].datafile);
+            (void) HDfprintf(stderr, err3, opt->infiles[k].datafile);
             return (-1);
         }
 
@@ -2360,7 +2360,7 @@ static int process(struct Options *opt)
             if (in->configOptionVector[EXTERNAL] == 1) {
                 /* creating the external file if it doesnt exist */
                 if ((extfile = HDfopen(in->externFilename, "ab")) == NULL) {
-                    (void) fprintf(stderr, "%s", err4);
+                    (void) HDfprintf(stderr, "%s", err4);
                     H5Pclose(proplist);
                     H5Sclose(dataspace);
                     H5Fclose(file_id);
@@ -2381,7 +2381,7 @@ static int process(struct Options *opt)
             {
                 /* create data set */
                 if ((dataset = H5Dcreate2(handle, in->path.group[j], outtype, dataspace, H5P_DEFAULT, proplist, H5P_DEFAULT)) < 0) {
-                    (void) fprintf(stderr, "%s", err5);
+                    (void) HDfprintf(stderr, "%s", err5);
                     H5Pclose(proplist);
                     H5Sclose(dataspace);
                     H5Fclose(file_id);
@@ -2394,7 +2394,7 @@ static int process(struct Options *opt)
 
             /* write dataset */
             if (H5Dwrite(dataset, intype, H5S_ALL, H5S_ALL, H5P_DEFAULT, (VOIDP) in->data) < 0) {
-                (void) fprintf(stderr, "%s", err6);
+                (void) HDfprintf(stderr, "%s", err6);
                 H5Dclose(dataset);
                 H5Pclose(proplist);
                 H5Sclose(dataspace);
@@ -2423,405 +2423,405 @@ static int process(struct Options *opt)
 
 void help(char *name)
 {
-    (void) fprintf(stdout, "Name:\n\n");
-    (void) fprintf(stdout, "\t%s\n\n", name);
-    (void) fprintf(stdout, "\t  TOOL NAME:\n");
-    (void) fprintf(stdout, "\t   %s\n", name);
-    (void) fprintf(stdout, "\t   SYNTAX:\n");
-    (void) fprintf(stdout, "\t   %s -h[elp], OR\n", name);
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "Name:\n\n");
+    (void) HDfprintf(stdout, "\t%s\n\n", name);
+    (void) HDfprintf(stdout, "\t  TOOL NAME:\n");
+    (void) HDfprintf(stdout, "\t   %s\n", name);
+    (void) HDfprintf(stdout, "\t   SYNTAX:\n");
+    (void) HDfprintf(stdout, "\t   %s -h[elp], OR\n", name);
+    (void) HDfprintf(stdout,
             "\t   %s <infile> -c[onfig] <configfile> [<infile> -c[config] <configfile>...]", name);
-    (void) fprintf(stdout, "\t\t\t\t      -o[utfile] <outfile>\n\n");
-    (void) fprintf(stdout, "\t   PURPOSE:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t\t\t\t      -o[utfile] <outfile>\n\n");
+    (void) HDfprintf(stdout, "\t   PURPOSE:\n");
+    (void) HDfprintf(stdout,
             "\t   To convert data stored in one or more ASCII or binary files\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  into one or more datasets (in accordance with the \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  user-specified type and storage properties) in an existing \n");
-    (void) fprintf(stdout, "\t  or new HDF5 file.\n\n");
-    (void) fprintf(stdout, "\t   DESCRIPTION:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  or new HDF5 file.\n\n");
+    (void) HDfprintf(stdout, "\t   DESCRIPTION:\n");
+    (void) HDfprintf(stdout,
             "\t  The primary objective of the utility is to convert floating\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  point or integer data stored in ASCII text or binary form \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  into a data-set according to the type and storage properties\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  specified by the user. The utility can also accept ASCII\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  text files and store the contents in a compact form as an\n");
-    (void) fprintf(stdout, "\t  array of one-dimensional strings.\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  array of one-dimensional strings.\n\n");
+    (void) HDfprintf(stdout,
             "\t  The input data to be written as a data-set can be provided\n");
-    (void) fprintf(stdout, "\t  to the utility in one of the following forms:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  to the utility in one of the following forms:\n");
+    (void) HDfprintf(stdout,
             "\t  1. ASCII text file with numeric data (floating point or \n");
-    (void) fprintf(stdout, "\t  integer data). \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  integer data). \n");
+    (void) HDfprintf(stdout,
             "\t  2. Binary file with native floating point data (32-bit or \n");
-    (void) fprintf(stdout, "\t  64-bit) \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  64-bit) \n");
+    (void) HDfprintf(stdout,
             "\t  3. Binary file with native integer (signed or unsigned)\n");
-    (void) fprintf(stdout, "\t  data (8-bit or 16-bit or 32-bit or 64-bit). \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  data (8-bit or 16-bit or 32-bit or 64-bit). \n");
+    (void) HDfprintf(stdout,
             "\t  4. ASCII text file containing strings (text data).\n");
-    (void) fprintf(stdout, "\t    \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t    \n");
+    (void) HDfprintf(stdout,
             "\t  Every input file is associated with a configuration file \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  also provided as an input to the utility. (See Section \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  \"CONFIGURATION FILE\" to know how it is to be organized).\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  The class, size and dimensions of the input data is \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  specified in this configuration file. A point to note is\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  that the floating point data in the ASCII text file may be\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  organized in the fixed floating form (for example 323.56)\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  or in a scientific notation (for example 3.23E+02). A \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  different input-class specification is to be used for both\n");
-    (void) fprintf(stdout, "\t  forms.\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  forms.\n\n");
+    (void) HDfprintf(stdout,
             "\t  The utility extracts the input data from the input file \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  according to the specified parameters and saves it into \n");
-    (void) fprintf(stdout, "\t  an H5 dataset. \n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  an H5 dataset. \n\n");
+    (void) HDfprintf(stdout,
             "\t  The user can specify output type and storage properties in \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  the configuration file. The user is requited to specify the \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  path of the dataset. If the groups in the path leading to \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  the data-set do not exist, the groups will be created by the\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  utility. If no group is specified, the dataset will be\n");
-    (void) fprintf(stdout, "\t  created under the root group.\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  created under the root group.\n\n");
+    (void) HDfprintf(stdout,
             "\t  In addition to the name, the user is also required to \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  provide the class and size of output data to be written to \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  the dataset and may optionally specify the output-architecure,\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  and the output-byte-order. If output-architecture is not \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  specified the default is NATIVE. Output-byte-orders are fixed\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  for some architectures and may be specified only if output-\n");
-    (void) fprintf(stdout, "\t  architecture is IEEE, UNIX or STD.\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  architecture is IEEE, UNIX or STD.\n\n");
+    (void) HDfprintf(stdout,
             "\t   Also, layout and other storage properties such as \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  compression, external storage and extendible data-sets may be\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  optionally specified.  The layout and storage properties \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  denote how raw data is to be organized on the disk. If these \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  options are not specified the default is Contiguous layout \n");
-    (void) fprintf(stdout, "\t  and storage.\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  and storage.\n\n");
+    (void) HDfprintf(stdout,
             "\t  The dataset can be organized in any of the following ways:\n");
-    (void) fprintf(stdout, "\t  1. Contiguous.\n");
-    (void) fprintf(stdout, "\t  2. Chunked.\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  1. Contiguous.\n");
+    (void) HDfprintf(stdout, "\t  2. Chunked.\n");
+    (void) HDfprintf(stdout,
             "\t  3. External Storage File    (has to be contiguous)\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  4. Extendible data sets     (has to be chunked)\n");
-    (void) fprintf(stdout, "\t  5. Compressed.        (has to be chunked)\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  5. Compressed.        (has to be chunked)\n");
+    (void) HDfprintf(stdout,
             "\t  6. Compressed & Extendible  (has to be chunked)\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  If the user wants to store raw data in a non-HDF file then \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  the external storage file option is to be used and the name \n");
-    (void) fprintf(stdout, "\t  of the file is to be specified. \n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  of the file is to be specified. \n\n");
+    (void) HDfprintf(stdout,
             "\t  If the user wants the dimensions of the data-set to be\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  unlimited, the extendible data set option can be chosen. \n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  The user may also specify the type of compression and the \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  level to which the data set must be compresses by setting \n");
-    (void) fprintf(stdout, "\t  the compressed option.\n\n");
-    (void) fprintf(stdout, "\t   SYNOPSIS:\n");
-    (void) fprintf(stdout, "\t  h5import -h[elp], OR\n");
-    (void) fprintf( stdout,
+    (void) HDfprintf(stdout, "\t  the compressed option.\n\n");
+    (void) HDfprintf(stdout, "\t   SYNOPSIS:\n");
+    (void) HDfprintf(stdout, "\t  h5import -h[elp], OR\n");
+    (void) HDfprintf( stdout,
             "\t  h5import <infile> -c[onfig] <configfile> \
                     [<infile> -c[config] <confile2>...] -o[utfile] <outfile>\n\n");
-    (void) fprintf(stdout, "\t   -h[elp]:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t   -h[elp]:\n");
+    (void) HDfprintf(stdout,
             "\t           Prints this summary of usage, and exits.\n\n");
-    (void) fprintf(stdout, "\t   <infile(s)>:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t   <infile(s)>:\n");
+    (void) HDfprintf(stdout,
             "\t           Name of the Input file(s), containing a \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    single n-dimensional floating point or integer array \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    in either ASCII text, native floating point(32-bit \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    or 64-bit) or native integer(8-bit or 16-bit or \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    32-bit or 64-bit). Data to be specified in the order\n");
-    (void) fprintf(stdout, "\t    of fastest changing dimensions first.\n\n");
-    (void) fprintf(stdout, "\t  -c[config] <configfile>:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t    of fastest changing dimensions first.\n\n");
+    (void) HDfprintf(stdout, "\t  -c[config] <configfile>:\n");
+    (void) HDfprintf(stdout,
             "\t    Every input file should be associated with a \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    configuration file and this is done by the -c option.\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    <configfile> is the name of the configuration file.\n");
-    (void) fprintf(stdout, "\t    (See Section \"CONFIGURATION FILE\")\n\n");
-    (void) fprintf(stdout, "\t   -o[utfile] <outfile>:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t    (See Section \"CONFIGURATION FILE\")\n\n");
+    (void) HDfprintf(stdout, "\t   -o[utfile] <outfile>:\n");
+    (void) HDfprintf(stdout,
             "\t           Name of the HDF5 output file. Data from one or more \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    input files are stored as one or more data sets in \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    <outfile>. The output file may be an existing file or \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t    it maybe new in which case it will be created.\n\n\n");
-    (void) fprintf(stdout, "\t   CONFIGURATION FILE:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t   CONFIGURATION FILE:\n");
+    (void) HDfprintf(stdout,
             "\t  The configuration file is an ASCII text file and must be \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  organized as \"CONFIG-KEYWORD VALUE\" pairs, one pair on each \n");
-    (void) fprintf(stdout, "\t  line.\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  line.\n\n");
+    (void) HDfprintf(stdout,
             "\t   The configuration file may have the following keywords each \n");
-    (void) fprintf(stdout, "\t   followed by an acceptable value.\n\n");
-    (void) fprintf(stdout, "\t  Required KEYWORDS:\n");
-    (void) fprintf(stdout, "\t    PATH\n");
-    (void) fprintf(stdout, "\t    INPUT-CLASS\n");
-    (void) fprintf(stdout, "\t    INPUT-SIZE\n");
-    (void) fprintf(stdout, "\t    RANK\n");
-    (void) fprintf(stdout, "\t    DIMENSION-SIZES\n");
-    (void) fprintf(stdout, "\t    OUTPUT-CLASS\n");
-    (void) fprintf(stdout, "\t    OUTPUT-SIZE\n\n");
-    (void) fprintf(stdout, "\t  Optional KEYWORDS:\n");
-    (void) fprintf(stdout, "\t    OUTPUT-ARCHITECTURE\n");
-    (void) fprintf(stdout, "\t    OUTPUT-BYTE-ORDER\n");
-    (void) fprintf(stdout, "\t      CHUNKED-DIMENSION-SIZES\n");
-    (void) fprintf(stdout, "\t    COMPRESSION-TYPE\n");
-    (void) fprintf(stdout, "\t    COMPRESSION-PARAM\n");
-    (void) fprintf(stdout, "\t    EXTERNAL-STORAGE\n");
-    (void) fprintf(stdout, "\t    MAXIMUM-DIMENSIONS\n\n\n");
-    (void) fprintf(stdout, "\t    Values for keywords:\n");
-    (void) fprintf(stdout, "\t    PATH:\n");
-    (void) fprintf(stdout, "\t      Strings separated by spaces to represent\n");
-    (void) fprintf(stdout, "\t      the path of the data-set. If the groups in\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t   followed by an acceptable value.\n\n");
+    (void) HDfprintf(stdout, "\t  Required KEYWORDS:\n");
+    (void) HDfprintf(stdout, "\t    PATH\n");
+    (void) HDfprintf(stdout, "\t    INPUT-CLASS\n");
+    (void) HDfprintf(stdout, "\t    INPUT-SIZE\n");
+    (void) HDfprintf(stdout, "\t    RANK\n");
+    (void) HDfprintf(stdout, "\t    DIMENSION-SIZES\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-CLASS\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-SIZE\n\n");
+    (void) HDfprintf(stdout, "\t  Optional KEYWORDS:\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-ARCHITECTURE\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-BYTE-ORDER\n");
+    (void) HDfprintf(stdout, "\t      CHUNKED-DIMENSION-SIZES\n");
+    (void) HDfprintf(stdout, "\t    COMPRESSION-TYPE\n");
+    (void) HDfprintf(stdout, "\t    COMPRESSION-PARAM\n");
+    (void) HDfprintf(stdout, "\t    EXTERNAL-STORAGE\n");
+    (void) HDfprintf(stdout, "\t    MAXIMUM-DIMENSIONS\n\n\n");
+    (void) HDfprintf(stdout, "\t    Values for keywords:\n");
+    (void) HDfprintf(stdout, "\t    PATH:\n");
+    (void) HDfprintf(stdout, "\t      Strings separated by spaces to represent\n");
+    (void) HDfprintf(stdout, "\t      the path of the data-set. If the groups in\n");
+    (void) HDfprintf(stdout,
             "\t      the path do no exist, they will be created. \n");
-    (void) fprintf(stdout, "\t      For example,\n");
-    (void) fprintf(stdout, "\t        PATH grp1/grp2/dataset1\n");
-    (void) fprintf(stdout, "\t        PATH: keyword\n");
-    (void) fprintf(stdout, "\t        grp1: group under the root. If\n");
-    (void) fprintf(stdout, "\t              non-existent will be created.\n");
-    (void) fprintf(stdout, "\t        grp2: group under grp1. If \n");
-    (void) fprintf(stdout, "\t              non-existent will be created \n");
-    (void) fprintf(stdout, "\t              under grp1.\n");
-    (void) fprintf(stdout, "\t        dataset1: the name of the data-set \n");
-    (void) fprintf(stdout, "\t            to be created.\n\n");
-    (void) fprintf(stdout, "\t               INPUT-CLASS:\n");
-    (void) fprintf(stdout, "\t      String denoting the type of input data.\n");
-    (void) fprintf(stdout, "\t      (\"TEXTIN\", \"TEXTFP\", \"FP\", \"IN\", \n");
-    (void) fprintf(stdout, "\t      \"STR\", \"TEXTUIN\", \"UIN\"). \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      For example,\n");
+    (void) HDfprintf(stdout, "\t        PATH grp1/grp2/dataset1\n");
+    (void) HDfprintf(stdout, "\t        PATH: keyword\n");
+    (void) HDfprintf(stdout, "\t        grp1: group under the root. If\n");
+    (void) HDfprintf(stdout, "\t              non-existent will be created.\n");
+    (void) HDfprintf(stdout, "\t        grp2: group under grp1. If \n");
+    (void) HDfprintf(stdout, "\t              non-existent will be created \n");
+    (void) HDfprintf(stdout, "\t              under grp1.\n");
+    (void) HDfprintf(stdout, "\t        dataset1: the name of the data-set \n");
+    (void) HDfprintf(stdout, "\t            to be created.\n\n");
+    (void) HDfprintf(stdout, "\t               INPUT-CLASS:\n");
+    (void) HDfprintf(stdout, "\t      String denoting the type of input data.\n");
+    (void) HDfprintf(stdout, "\t      (\"TEXTIN\", \"TEXTFP\", \"FP\", \"IN\", \n");
+    (void) HDfprintf(stdout, "\t      \"STR\", \"TEXTUIN\", \"UIN\"). \n");
+    (void) HDfprintf(stdout,
             "\t      INPUT-CLASS \"TEXTIN\" denotes an ASCII text \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      file with signed integer data in ASCII form,\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      INPUT-CLASS \"TEXTUIN\" denotes an ASCII text \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      file with unsigned integer data in ASCII form,\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      \"TEXTFP\" denotes an ASCII text file containing\n");
-    (void) fprintf(stdout, "\t      floating point data in the fixed notation\n");
-    (void) fprintf(stdout, "\t      (325.34),\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      floating point data in the fixed notation\n");
+    (void) HDfprintf(stdout, "\t      (325.34),\n");
+    (void) HDfprintf(stdout,
             "\t      \"FP\" denotes a floating point binary file,\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      \"IN\" denotes a signed integer binary file,\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      \"UIN\" denotes an unsigned integer binary file,\n");
-    (void) fprintf(stdout, "\t       & \"STR\" denotes an ASCII text file the \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t       & \"STR\" denotes an ASCII text file the \n");
+    (void) HDfprintf(stdout,
             "\t      contents of which should be stored as an 1-D \n");
-    (void) fprintf(stdout, "\t      array of strings.\n");
-    (void) fprintf(stdout, "\t      If INPUT-CLASS is \"STR\", then RANK, \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      array of strings.\n");
+    (void) HDfprintf(stdout, "\t      If INPUT-CLASS is \"STR\", then RANK, \n");
+    (void) HDfprintf(stdout,
             "\t      DIMENSION-SIZES, OUTPUT-CLASS, OUTPUT-SIZE, \n");
-    (void) fprintf(stdout, "\t      OUTPUT-ARCHITECTURE and OUTPUT-BYTE-ORDER \n");
-    (void) fprintf(stdout, "\t      will be ignored.\n\n\n");
-    (void) fprintf(stdout, "\t    INPUT-SIZE:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      OUTPUT-ARCHITECTURE and OUTPUT-BYTE-ORDER \n");
+    (void) HDfprintf(stdout, "\t      will be ignored.\n\n\n");
+    (void) HDfprintf(stdout, "\t    INPUT-SIZE:\n");
+    (void) HDfprintf(stdout,
             "\t      Integer denoting the size of the input data \n");
-    (void) fprintf(stdout, "\t      (8, 16, 32, 64). \n\n");
-    (void) fprintf(stdout, "\t      For floating point,\n");
-    (void) fprintf(stdout, "\t      INPUT-SIZE can be 32 or 64.\n");
-    (void) fprintf(stdout, "\t      For integers (signed and unsigned)\n");
-    (void) fprintf(stdout, "\t      INPUT-SIZE can be 8, 16, 32 or 64.\n\n");
-    (void) fprintf(stdout, "\t    RANK:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      (8, 16, 32, 64). \n\n");
+    (void) HDfprintf(stdout, "\t      For floating point,\n");
+    (void) HDfprintf(stdout, "\t      INPUT-SIZE can be 32 or 64.\n");
+    (void) HDfprintf(stdout, "\t      For integers (signed and unsigned)\n");
+    (void) HDfprintf(stdout, "\t      INPUT-SIZE can be 8, 16, 32 or 64.\n\n");
+    (void) HDfprintf(stdout, "\t    RANK:\n");
+    (void) HDfprintf(stdout,
             "\t      Integer denoting the number of dimensions.\n\n");
-    (void) fprintf(stdout, "\t    DIMENSION-SIZES:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t    DIMENSION-SIZES:\n");
+    (void) HDfprintf(stdout,
             "\t            Integers separated by spaces to denote the \n");
-    (void) fprintf(stdout, "\t      dimension sizes for the no. of dimensions \n");
-    (void) fprintf(stdout, "\t      determined by rank.\n\n");
-    (void) fprintf(stdout, "\t    OUTPUT-CLASS:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      dimension sizes for the no. of dimensions \n");
+    (void) HDfprintf(stdout, "\t      determined by rank.\n\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-CLASS:\n");
+    (void) HDfprintf(stdout,
             "\t      String dentoting data type of the dataset to \n");
-    (void) fprintf(stdout, "\t      be written (\"IN\",\"FP\", \"UIN\")\n\n");
-    (void) fprintf(stdout, "\t    OUTPUT-SIZE:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      be written (\"IN\",\"FP\", \"UIN\")\n\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-SIZE:\n");
+    (void) HDfprintf(stdout,
             "\t      Integer denoting the size of the data in the \n");
-    (void) fprintf(stdout, "\t      output dataset to be written.\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      output dataset to be written.\n");
+    (void) HDfprintf(stdout,
             "\t      If OUTPUT-CLASS is \"FP\", OUTPUT-SIZE can be \n");
-    (void) fprintf(stdout, "\t      32 or 64.\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      32 or 64.\n");
+    (void) HDfprintf(stdout,
             "\t      If OUTPUT-CLASS is \"IN\" or \"UIN\", OUTPUT-SIZE\n");
-    (void) fprintf(stdout, "\t      can be 8, 16, 32 or 64.\n\n");
-    (void) fprintf(stdout, "\t    OUTPUT-ARCHITECTURE:\n");
-    (void) fprintf(stdout, "\t      STRING denoting the type of output \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      can be 8, 16, 32 or 64.\n\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-ARCHITECTURE:\n");
+    (void) HDfprintf(stdout, "\t      STRING denoting the type of output \n");
+    (void) HDfprintf(stdout,
             "\t      architecture. Can accept the following values\n");
-    (void) fprintf(stdout, "\t      STD\n");
-    (void) fprintf(stdout, "\t      IEEE\n");
-    (void) fprintf(stdout, "\t      INTEL\n");
-    (void) fprintf(stdout, "\t      CRAY\n");
-    (void) fprintf(stdout, "\t      MIPS\n");
-    (void) fprintf(stdout, "\t      ALPHA\n");
-    (void) fprintf(stdout, "\t      NATIVE (default)\n");
-    (void) fprintf(stdout, "\t      UNIX\n\n");
-    (void) fprintf(stdout, "\t    OUTPUT-BYTE-ORDER:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      STD\n");
+    (void) HDfprintf(stdout, "\t      IEEE\n");
+    (void) HDfprintf(stdout, "\t      INTEL\n");
+    (void) HDfprintf(stdout, "\t      CRAY\n");
+    (void) HDfprintf(stdout, "\t      MIPS\n");
+    (void) HDfprintf(stdout, "\t      ALPHA\n");
+    (void) HDfprintf(stdout, "\t      NATIVE (default)\n");
+    (void) HDfprintf(stdout, "\t      UNIX\n\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-BYTE-ORDER:\n");
+    (void) HDfprintf(stdout,
             "\t      String denoting the output-byte-order. Ignored\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      if the OUTPUT-ARCHITECTURE is not specified or\n");
-    (void) fprintf(stdout, "\t      if it is IEEE, UNIX or STD. Can accept the \n");
-    (void) fprintf(stdout, "\t      following values.\n");
-    (void) fprintf(stdout, "\t      BE (default)\n");
-    (void) fprintf(stdout, "\t      LE\n\n");
-    (void) fprintf(stdout, "\t    CHUNKED-DIMENSION-SIZES:\n");
-    (void) fprintf(stdout, "\t      Integers separated by spaces to denote the \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      if it is IEEE, UNIX or STD. Can accept the \n");
+    (void) HDfprintf(stdout, "\t      following values.\n");
+    (void) HDfprintf(stdout, "\t      BE (default)\n");
+    (void) HDfprintf(stdout, "\t      LE\n\n");
+    (void) HDfprintf(stdout, "\t    CHUNKED-DIMENSION-SIZES:\n");
+    (void) HDfprintf(stdout, "\t      Integers separated by spaces to denote the \n");
+    (void) HDfprintf(stdout,
             "\t      dimension sizes of the chunk for the no. of \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      dimensions determined by rank. Required field\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      to denote that the dataset will be stored with\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      chunked storage. If this field is absent the\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      dataset will be stored with contiguous storage.\n\n");
-    (void) fprintf(stdout, "\t    COMPRESSION-TYPE:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t    COMPRESSION-TYPE:\n");
+    (void) HDfprintf(stdout,
             "\t      String denoting the type of compression to be\n");
-    (void) fprintf(stdout, "\t      used with the chunked storage. Requires the\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      used with the chunked storage. Requires the\n");
+    (void) HDfprintf(stdout,
             "\t      CHUNKED-DIMENSION-SIZES to be specified. The only \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      currently supported compression method is GZIP. \n");
-    (void) fprintf(stdout, "\t      Will accept the following value\n");
-    (void) fprintf(stdout, "\t      GZIP\n\n");
-    (void) fprintf(stdout, "\t    COMPRESSION-PARAM:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      Will accept the following value\n");
+    (void) HDfprintf(stdout, "\t      GZIP\n\n");
+    (void) HDfprintf(stdout, "\t    COMPRESSION-PARAM:\n");
+    (void) HDfprintf(stdout,
             "\t      Integer used to denote compression level and \n");
-    (void) fprintf(stdout, "\t      this option is to be always specified when \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      this option is to be always specified when \n");
+    (void) HDfprintf(stdout,
             "\t      the COMPRESSION-TYPE option is specified. The\n");
-    (void) fprintf(stdout, "\t      values are applicable only to GZIP \n");
-    (void) fprintf(stdout, "\t      compression.\n");
-    (void) fprintf(stdout, "\t      Value 1-9: The level of Compression. \n");
-    (void) fprintf(stdout, "\t        1 will result in the fastest \n");
-    (void) fprintf(stdout, "\t        compression while 9 will result in \n");
-    (void) fprintf(stdout, "\t        the best compression ratio. The default\n");
-    (void) fprintf(stdout, "\t        level of compression is 6.\n\n");
-    (void) fprintf(stdout, "\t    EXTERNAL-STORAGE:\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      values are applicable only to GZIP \n");
+    (void) HDfprintf(stdout, "\t      compression.\n");
+    (void) HDfprintf(stdout, "\t      Value 1-9: The level of Compression. \n");
+    (void) HDfprintf(stdout, "\t        1 will result in the fastest \n");
+    (void) HDfprintf(stdout, "\t        compression while 9 will result in \n");
+    (void) HDfprintf(stdout, "\t        the best compression ratio. The default\n");
+    (void) HDfprintf(stdout, "\t        level of compression is 6.\n\n");
+    (void) HDfprintf(stdout, "\t    EXTERNAL-STORAGE:\n");
+    (void) HDfprintf(stdout,
             "\t      String to denote the name of the non-HDF5 file \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      to store data to. Cannot be used if CHUNKED-\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t      DIMENSIONS or COMPRESSION-TYPE or EXTENDIBLE-\n");
-    (void) fprintf(stdout, "\t      DATASET is specified.\n");
-    (void) fprintf(stdout, "\t      Value <external-filename>: the name of the \n");
-    (void) fprintf(stdout, "\t      external file as a string to be used.\n\n");
-    (void) fprintf(stdout, "\t    MAXIMUM-DIMENSIONS:\n");
-    (void) fprintf(stdout, "\t      Integers separated by spaces to denote the \n");
-    (void) fprintf(stdout, "\t      maximum dimension sizes of all the \n");
-    (void) fprintf(stdout, "\t      dimensions determined by rank. Requires the\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      DATASET is specified.\n");
+    (void) HDfprintf(stdout, "\t      Value <external-filename>: the name of the \n");
+    (void) HDfprintf(stdout, "\t      external file as a string to be used.\n\n");
+    (void) HDfprintf(stdout, "\t    MAXIMUM-DIMENSIONS:\n");
+    (void) HDfprintf(stdout, "\t      Integers separated by spaces to denote the \n");
+    (void) HDfprintf(stdout, "\t      maximum dimension sizes of all the \n");
+    (void) HDfprintf(stdout, "\t      dimensions determined by rank. Requires the\n");
+    (void) HDfprintf(stdout,
             "\t      CHUNKED-DIMENSION-SIZES to be specified. A value of \n");
-    (void) fprintf(stdout, "\t      -1 for any dimension implies UNLIMITED \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t      -1 for any dimension implies UNLIMITED \n");
+    (void) HDfprintf(stdout,
             "\t      DIMENSION size for that particular dimension.\n\n");
-    (void) fprintf(stdout, "\t   EXAMPLES:\n");
-    (void) fprintf(stdout, "\t  1. Configuration File may look like:\n\n");
-    (void) fprintf(stdout, "\t    PATH work h5 pkamat First-set\n");
-    (void) fprintf(stdout, "\t    INPUT-CLASS TEXTFP\n");
-    (void) fprintf(stdout, "\t    RANK 3\n");
-    (void) fprintf(stdout, "\t    DIMENSION-SIZES 5 2 4\n");
-    (void) fprintf(stdout, "\t    OUTPUT-CLASS FP\n");
-    (void) fprintf(stdout, "\t    OUTPUT-SIZE 64\n");
-    (void) fprintf(stdout, "\t    OUTPUT-ARCHITECTURE IEEE\n");
-    (void) fprintf(stdout, "\t    OUTPUT-BYTE-ORDER LE\n");
-    (void) fprintf(stdout, "\t      CHUNKED-DIMENSION-SIZES 2 2 2 \n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t   EXAMPLES:\n");
+    (void) HDfprintf(stdout, "\t  1. Configuration File may look like:\n\n");
+    (void) HDfprintf(stdout, "\t    PATH work h5 pkamat First-set\n");
+    (void) HDfprintf(stdout, "\t    INPUT-CLASS TEXTFP\n");
+    (void) HDfprintf(stdout, "\t    RANK 3\n");
+    (void) HDfprintf(stdout, "\t    DIMENSION-SIZES 5 2 4\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-CLASS FP\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-SIZE 64\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-ARCHITECTURE IEEE\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-BYTE-ORDER LE\n");
+    (void) HDfprintf(stdout, "\t      CHUNKED-DIMENSION-SIZES 2 2 2 \n\n");
+    (void) HDfprintf(stdout,
             "\t  The above configuration will accept a floating point array \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  (5 x 2 x 4)  in an ASCII file with the rank and dimension sizes \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  specified and will save it in a chunked data-set (of pattern \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  2 X 2 X 2) of 64-bit floating point in the little-endian order \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  and IEEE architecture. The dataset will be stored at\n");
-    (void) fprintf(stdout, "\t  \"/work/h5/pkamat/First-set\"\n\n");
-    (void) fprintf(stdout, "\t  2. Another configuration could be:\n\n");
-    (void) fprintf(stdout, "\t    PATH Second-set\n");
-    (void) fprintf(stdout, "\t    INPUT-CLASS IN  \n");
-    (void) fprintf(stdout, "\t    RANK 5\n");
-    (void) fprintf(stdout, "\t    DIMENSION-SIZES 6 3 5 2 4\n");
-    (void) fprintf(stdout, "\t    OUTPUT-CLASS IN\n");
-    (void) fprintf(stdout, "\t    OUTPUT-SIZE 32\n");
-    (void) fprintf(stdout, "\t      CHUNKED-DIMENSION-SIZES 2 2 2 2 2\n");
-    (void) fprintf(stdout, "\t    EXTENDIBLE-DATASET 1 3 \n");
-    (void) fprintf(stdout, "\t    COMPRESSION-TYPE GZIP\n");
-    (void) fprintf(stdout, "\t    COMPRESSION-PARAM 7\n\n\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  \"/work/h5/pkamat/First-set\"\n\n");
+    (void) HDfprintf(stdout, "\t  2. Another configuration could be:\n\n");
+    (void) HDfprintf(stdout, "\t    PATH Second-set\n");
+    (void) HDfprintf(stdout, "\t    INPUT-CLASS IN  \n");
+    (void) HDfprintf(stdout, "\t    RANK 5\n");
+    (void) HDfprintf(stdout, "\t    DIMENSION-SIZES 6 3 5 2 4\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-CLASS IN\n");
+    (void) HDfprintf(stdout, "\t    OUTPUT-SIZE 32\n");
+    (void) HDfprintf(stdout, "\t      CHUNKED-DIMENSION-SIZES 2 2 2 2 2\n");
+    (void) HDfprintf(stdout, "\t    EXTENDIBLE-DATASET 1 3 \n");
+    (void) HDfprintf(stdout, "\t    COMPRESSION-TYPE GZIP\n");
+    (void) HDfprintf(stdout, "\t    COMPRESSION-PARAM 7\n\n\n");
+    (void) HDfprintf(stdout,
             "\t  The above configuration will accept an integer array \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  (6 X 3 X 5 x 2 x 4)  in a binary file with the rank and \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  dimension sizes specified and will save it in a chunked data-set\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  (of pattern 2 X 2 X 2 X 2 X 2) of 32-bit floating point in \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  native format (as output-architecture is not specified). The \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  first and the third dimension will be defined as unlimited. The \n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout,
             "\t  data-set will be compressed using GZIP and a compression level \n");
-    (void) fprintf(stdout, "\t  of 7.\n");
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\t  of 7.\n");
+    (void) HDfprintf(stdout,
             "\t  The dataset will be stored at \"/Second-set\"\n\n");
     return;
 }
 
 void usage(char *name)
 {
-    (void) fprintf(stdout, "\nUsage:\t%s -h[elp], OR\n", name);
-    (void) fprintf(stdout,
+    (void) HDfprintf(stdout, "\nUsage:\t%s -h[elp], OR\n", name);
+    (void) HDfprintf(stdout,
             "\t%s <infile> -c[onfig] <configfile> \
   [<infile> -c[config] <configfile>...] -o[utfile] <outfile> \n\n", name);
     return;
diff --git a/tools/h5ls/h5ls.c b/tools/h5ls/h5ls.c
index b06f302..b51c7e1 100644
--- a/tools/h5ls/h5ls.c
+++ b/tools/h5ls/h5ls.c
@@ -176,7 +176,7 @@ static herr_t visit_obj(hid_t file, const char *oname, iter_t *iter);
 static void
 usage (void)
 {
-    fprintf(stderr, "\
+    HDfprintf(stderr, "\
 usage: %s [OPTIONS] [OBJECTS...]\n\
   OPTIONS\n\
    -h, -?, --help  Print a usage message and exit\n\
@@ -263,39 +263,39 @@ display_string(FILE *stream, const char *s, hbool_t escape_spaces)
     for (/*void*/; s && *s; s++) {
         switch (*s) {
             case '"':
-                if (stream) fprintf(stream, "\\\"");
+                if (stream) HDfprintf(stream, "\\\"");
                 nprint += 2;
                 break;
             case '\\':
-                if (stream) fprintf(stream, "\\\\");
+                if (stream) HDfprintf(stream, "\\\\");
                 nprint += 2;
                 break;
             case '\b':
-                if (stream) fprintf(stream, "\\b");
+                if (stream) HDfprintf(stream, "\\b");
                 nprint += 2;
                 break;
             case '\f':
-                if (stream) fprintf(stream, "\\f");
+                if (stream) HDfprintf(stream, "\\f");
                 nprint += 2;
                 break;
             case '\n':
-                if (stream) fprintf(stream, "\\n");
+                if (stream) HDfprintf(stream, "\\n");
                 nprint += 2;
                 break;
             case '\r':
-                if (stream) fprintf(stream, "\\r");
+                if (stream) HDfprintf(stream, "\\r");
                 nprint += 2;
                 break;
             case '\t':
-                if (stream) fprintf(stream, "\\t");
+                if (stream) HDfprintf(stream, "\\t");
                 nprint += 2;
                 break;
             case ' ':
                 if (escape_spaces) {
-                    if (stream) fprintf(stream, "\\ ");
+                    if (stream) HDfprintf(stream, "\\ ");
                     nprint += 2;
                 } else {
-                    if (stream) fprintf(stream, " ");
+                    if (stream) HDfprintf(stream, " ");
                     nprint++;
                 }
                 break;
@@ -305,7 +305,7 @@ display_string(FILE *stream, const char *s, hbool_t escape_spaces)
                     nprint++;
                 } else {
                     if (stream) {
-                        fprintf(stream, "\\%03o", *((const unsigned char*)s));
+                        HDfprintf(stream, "\\%03o", *((const unsigned char*)s));
                     }
                     nprint += 4;
                 }
@@ -2515,7 +2515,7 @@ dump_dataset_values(hid_t dset)
 
     H5Tclose(f_type);
     
-    fprintf(stdout, "\n");
+    HDfprintf(stdout, "\n");
 
     h5tools_str_close(&buffer);
 }
@@ -2694,14 +2694,14 @@ list_attr(hid_t obj, const char *attr_name, const H5A_info_t UNUSED *ainfo,
             HDfree(buf);
             H5Tclose(p_type);
         } /* end if */
-        fprintf(stdout, "\n");
+        HDfprintf(stdout, "\n");
 
         H5Sclose(space);
         H5Tclose(type);
         H5Aclose(attr);
     } 
     else {
-        fprintf(stdout, "\n");
+        HDfprintf(stdout, "\n");
     }
 
     h5tools_str_close(&buffer);
@@ -3296,7 +3296,7 @@ visit_obj(hid_t file, const char *oname, iter_t *iter)
     if(H5O_TYPE_GROUP == oi.type && !grp_literal_g) {
         /* Get ID for group */
         if(!iter->symlink_target && (iter->gid = H5Gopen2(file, oname, H5P_DEFAULT)) < 0) {
-            fprintf(stderr, "%s: unable to open '%s' as group\n", iter->fname, oname);
+            HDfprintf(stderr, "%s: unable to open '%s' as group\n", iter->fname, oname);
             return 0;   /* Previously "continue", when this code was in main().
                          * We don't "continue" here in order to close the file
                          * and free the file name properly. */
@@ -3424,14 +3424,14 @@ is_valid_args(void)
 
     if(recursive_g && grp_literal_g) 
     {
-        fprintf(stderr, "Error: 'recursive' option not compatible with 'group info' option!\n\n");
+        HDfprintf(stderr, "Error: 'recursive' option not compatible with 'group info' option!\n\n");
         ret = FALSE;
         goto out;
     }
 
     if(no_dangling_link_g && !follow_symlink_g) 
     {
-        fprintf(stderr, "Error: --no-dangling-links must be used along with --follow-symlinks option!\n\n");
+        HDfprintf(stderr, "Error: --no-dangling-links must be used along with --follow-symlinks option!\n\n");
         ret = FALSE;
         goto out;
     }
@@ -3727,7 +3727,7 @@ main(int argc, const char *argv[])
         } /* end while */
 
         if(file < 0) {
-            fprintf(stderr, "%s: unable to open file\n", argv[argno-1]);
+            HDfprintf(stderr, "%s: unable to open file\n", argv[argno-1]);
             HDfree(fname);
             err_exit = 1;
             continue;
@@ -3740,7 +3740,7 @@ main(int argc, const char *argv[])
             iter.base_len -= oname[iter.base_len-1] == '/';
             x = oname;
             if(NULL == (oname = HDstrdup(oname))) {
-                fprintf(stderr, "memory allocation failed\n");
+                HDfprintf(stderr, "memory allocation failed\n");
                 leave(EXIT_FAILURE);
             }
             *x = '\0';
diff --git a/tools/h5stat/h5stat.c b/tools/h5stat/h5stat.c
index f6ed4b8..dd7adf9 100644
--- a/tools/h5stat/h5stat.c
+++ b/tools/h5stat/h5stat.c
@@ -239,21 +239,21 @@ leave(int ret)
 static void usage(const char *prog)
 {
      fflush(stdout);
-     fprintf(stdout, "Usage: %s [OPTIONS] file\n", prog);
-     fprintf(stdout, "\n");
-     fprintf(stdout, "      OPTIONS\n");
-     fprintf(stdout, "     -h, --help            Print a usage message and exit\n");
-     fprintf(stdout, "     -V, --version         Print version number and exit\n");
-     fprintf(stdout, "     -f, --file            Print file information\n");
-     fprintf(stdout, "     -F, --filemetadata    Print file space information for file's metadata\n");
-     fprintf(stdout, "     -g, --group           Print group information\n");
-     fprintf(stdout, "     -G, --groupmetadata   Print file space information for groups' metadata\n");
-     fprintf(stdout, "     -d, --dset            Print dataset information\n");
-     fprintf(stdout, "     -D, --dsetmetadata    Print file space information for datasets' metadata\n");
-     fprintf(stdout, "     -T, --dtypemetadata   Print datasets' datatype information\n");
-     fprintf(stdout, "     -A, --attribute       Print attribute information\n");
-     fprintf(stdout, "     -s, --freespace       Print free space information\n");
-     fprintf(stdout, "     -S, --summary         Print summary of file space information\n");
+     HDfprintf(stdout, "Usage: %s [OPTIONS] file\n", prog);
+     HDfprintf(stdout, "\n");
+     HDfprintf(stdout, "      OPTIONS\n");
+     HDfprintf(stdout, "     -h, --help            Print a usage message and exit\n");
+     HDfprintf(stdout, "     -V, --version         Print version number and exit\n");
+     HDfprintf(stdout, "     -f, --file            Print file information\n");
+     HDfprintf(stdout, "     -F, --filemetadata    Print file space information for file's metadata\n");
+     HDfprintf(stdout, "     -g, --group           Print group information\n");
+     HDfprintf(stdout, "     -G, --groupmetadata   Print file space information for groups' metadata\n");
+     HDfprintf(stdout, "     -d, --dset            Print dataset information\n");
+     HDfprintf(stdout, "     -D, --dsetmetadata    Print file space information for datasets' metadata\n");
+     HDfprintf(stdout, "     -T, --dtypemetadata   Print datasets' datatype information\n");
+     HDfprintf(stdout, "     -A, --attribute       Print attribute information\n");
+     HDfprintf(stdout, "     -s, --freespace       Print free space information\n");
+     HDfprintf(stdout, "     -S, --summary         Print summary of file space information\n");
 }
 
 
diff --git a/tools/lib/h5diff.c b/tools/lib/h5diff.c
index 53688d9..7376642 100644
--- a/tools/lib/h5diff.c
+++ b/tools/lib/h5diff.c
@@ -25,11 +25,11 @@
  * Debug printf macros. The prefix allows output filtering by test scripts.
  */
 #ifdef H5DIFF_DEBUG
-#define h5diffdebug(x) fprintf(stderr, "h5diff debug: " x)
-#define h5diffdebug2(x1, x2) fprintf(stderr, "h5diff debug: " x1, x2)
-#define h5diffdebug3(x1, x2, x3) fprintf(stderr, "h5diff debug: " x1, x2, x3)
-#define h5diffdebug4(x1, x2, x3, x4) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4)
-#define h5diffdebug5(x1, x2, x3, x4, x5) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4, x5)
+#define h5diffdebug(x) HDfprintf(stderr, "h5diff debug: " x)
+#define h5diffdebug2(x1, x2) HDfprintf(stderr, "h5diff debug: " x1, x2)
+#define h5diffdebug3(x1, x2, x3) HDfprintf(stderr, "h5diff debug: " x1, x2, x3)
+#define h5diffdebug4(x1, x2, x3, x4) HDfprintf(stderr, "h5diff debug: " x1, x2, x3, x4)
+#define h5diffdebug5(x1, x2, x3, x4, x5) HDfprintf(stderr, "h5diff debug: " x1, x2, x3, x4, x5)
 #else
 #define h5diffdebug(x)
 #define h5diffdebug2(x1, x2)
@@ -159,7 +159,7 @@ void print_manager_output(void)
     }
     else if( (outBuffOffset>0) && !g_Parallel)
     {
-        fprintf(stderr, "h5diff error: outBuffOffset>0, but we're not in parallel!\n");
+        HDfprintf(stderr, "h5diff error: outBuffOffset>0, but we're not in parallel!\n");
     }
 }
 
@@ -995,7 +995,7 @@ hsize_t h5diff(const char *fname1,
             if((HDstrlen(fname1) > MAX_FILENAME) || 
                (HDstrlen(fname2) > MAX_FILENAME))
             {
-                fprintf(stderr, "The parallel diff only supports path names up to %d characters\n", MAX_FILENAME);
+                HDfprintf(stderr, "The parallel diff only supports path names up to %d characters\n", MAX_FILENAME);
                 MPI_Abort(MPI_COMM_WORLD, 0);
             } /* end if */
 
diff --git a/tools/misc/h5debug.c b/tools/misc/h5debug.c
index 7b4215a..021cfcd 100644
--- a/tools/misc/h5debug.c
+++ b/tools/misc/h5debug.c
@@ -23,34 +23,34 @@
  *
  *-------------------------------------------------------------------------
  */
-#define H5A_PACKAGE		/*suppress error about including H5Apkg  */
-#define H5B2_PACKAGE		/*suppress error about including H5B2pkg  */
-#define H5B2_TESTING		/*suppress warning about H5B2 testing funcs*/
-#define H5EA_PACKAGE		/*suppress error about including H5EApkg  */
-#define H5EA_TESTING		/*suppress warning about H5EA testing funcs*/
-#define H5FA_PACKAGE		/*suppress error about including H5FApkg  */
-#define H5FA_TESTING		/*suppress warning about H5FA testing funcs*/
-#define H5F_PACKAGE		/*suppress error about including H5Fpkg	  */
-#define H5G_PACKAGE		/*suppress error about including H5Gpkg	  */
-#define H5HF_PACKAGE		/*suppress error about including H5HFpkg  */
-#define H5O_PACKAGE		/*suppress error about including H5Opkg	  */
-#define H5SM_PACKAGE		/*suppress error about including H5SMpkg  */
-
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Apkg.h"		/* Attributes				*/
-#include "H5B2pkg.h"		/* v2 B-trees				*/
-#include "H5Dprivate.h"		/* Datasets				*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5EApkg.h"		/* Extensible Arrays			*/
-#include "H5FApkg.h"		/* Fixed Arrays				*/
-#include "H5Fpkg.h"             /* File access				*/
-#include "H5FSprivate.h"	/* Free space manager			*/
-#include "H5Gpkg.h"		/* Groups				*/
-#include "H5HFpkg.h"		/* Fractal heaps			*/
-#include "H5HGprivate.h"	/* Global Heaps				*/
-#include "H5Iprivate.h"		/* IDs			  		*/
-#include "H5Opkg.h"             /* Object headers			*/
-#include "H5SMpkg.h"		/* Implicitly shared messages		*/
+#define H5A_PACKAGE    /*suppress error about including H5Apkg  */
+#define H5B2_PACKAGE    /*suppress error about including H5B2pkg  */
+#define H5B2_TESTING    /*suppress warning about H5B2 testing funcs*/
+#define H5EA_PACKAGE    /*suppress error about including H5EApkg  */
+#define H5EA_TESTING    /*suppress warning about H5EA testing funcs*/
+#define H5FA_PACKAGE    /*suppress error about including H5FApkg  */
+#define H5FA_TESTING    /*suppress warning about H5FA testing funcs*/
+#define H5F_PACKAGE    /*suppress error about including H5Fpkg    */
+#define H5G_PACKAGE    /*suppress error about including H5Gpkg    */
+#define H5HF_PACKAGE    /*suppress error about including H5HFpkg  */
+#define H5O_PACKAGE    /*suppress error about including H5Opkg    */
+#define H5SM_PACKAGE    /*suppress error about including H5SMpkg  */
+
+#include "H5private.h"    /* Generic Functions      */
+#include "H5Apkg.h"    /* Attributes        */
+#include "H5B2pkg.h"    /* v2 B-trees        */
+#include "H5Dprivate.h"    /* Datasets        */
+#include "H5Eprivate.h"    /* Error handling        */
+#include "H5EApkg.h"    /* Extensible Arrays      */
+#include "H5FApkg.h"    /* Fixed Arrays        */
+#include "H5Fpkg.h"             /* File access        */
+#include "H5FSprivate.h"  /* Free space manager      */
+#include "H5Gpkg.h"    /* Groups        */
+#include "H5HFpkg.h"    /* Fractal heaps      */
+#include "H5HGprivate.h"  /* Global Heaps        */
+#include "H5Iprivate.h"    /* IDs            */
+#include "H5Opkg.h"             /* Object headers      */
+#include "H5SMpkg.h"    /* Implicitly shared messages    */
 
 /* File drivers */
 #include "H5FDfamily.h"
@@ -61,15 +61,15 @@
 /*-------------------------------------------------------------------------
  * Function:    get_H5B2_class
  *
- * Purpose:	Determine the v2 B-tree class from the buffer read in.
+ * Purpose:  Determine the v2 B-tree class from the buffer read in.
  *              B-trees are debugged through the B-tree subclass.  The subclass
  *              identifier is two bytes after the B-tree signature.
  *
- * Return:	Non-NULL on success/NULL on failure
+ * Return:  Non-NULL on success/NULL on failure
  *
- * Programmer:	Quincey Koziol
- *		koziol@hdfgroup.org
- *		Sep 11 2008
+ * Programmer:  Quincey Koziol
+ *    koziol@hdfgroup.org
+ *    Sep 11 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -121,7 +121,7 @@ get_H5B2_class(const uint8_t *sig)
             break;
 
         default:
-            fprintf(stderr, "Unknown B-tree subtype %u\n", (unsigned)(subtype));
+            HDfprintf(stderr, "Unknown B-tree subtype %u\n", (unsigned)(subtype));
             HDexit(4);
     } /* end switch */
 
@@ -132,15 +132,15 @@ get_H5B2_class(const uint8_t *sig)
 /*-------------------------------------------------------------------------
  * Function:    get_H5EA_class
  *
- * Purpose:	Determine the extensible array class from the buffer read in.
+ * Purpose:  Determine the extensible array class from the buffer read in.
  *              Extensible arrays are debugged through the array subclass.
  *              The subclass identifier is two bytes after the signature.
  *
- * Return:	Non-NULL on success/NULL on failure
+ * Return:  Non-NULL on success/NULL on failure
  *
- * Programmer:	Quincey Koziol
- *		koziol@hdfgroup.org
- *		Sep 11 2008
+ * Programmer:  Quincey Koziol
+ *    koziol@hdfgroup.org
+ *    Sep 11 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -156,7 +156,7 @@ get_H5EA_class(const uint8_t *sig)
             break;
 
         default:
-            fprintf(stderr, "Unknown array class %u\n", (unsigned)(clsid));
+            HDfprintf(stderr, "Unknown array class %u\n", (unsigned)(clsid));
             HDexit(4);
     } /* end switch */
 
@@ -167,15 +167,15 @@ get_H5EA_class(const uint8_t *sig)
 /*-------------------------------------------------------------------------
  * Function:    get_H5FA_class
  *
- * Purpose:	Determine the fixed array class from the buffer read in.
+ * Purpose:  Determine the fixed array class from the buffer read in.
  *              Extensible arrays are debugged through the array subclass.
  *              The subclass identifier is two bytes after the signature.
  *
- * Return:	Non-NULL on success/NULL on failure
+ * Return:  Non-NULL on success/NULL on failure
  *
- * Programmer:	Quincey Koziol
- *		koziol@hdfgroup.org
- *		Sep 11 2008
+ * Programmer:  Quincey Koziol
+ *    koziol@hdfgroup.org
+ *    Sep 11 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -191,7 +191,7 @@ get_H5FA_class(const uint8_t *sig)
             break;
 
         default:
-            fprintf(stderr, "Unknown array class %u\n", (unsigned)(clsid));
+            HDfprintf(stderr, "Unknown array class %u\n", (unsigned)(clsid));
             HDexit(4);
     } /* end switch */
 
@@ -217,7 +217,7 @@ get_H5FA_class(const uint8_t *sig)
 int
 main(int argc, char *argv[])
 {
-    hid_t	fid, fapl, dxpl;
+    hid_t  fid, fapl, dxpl;
     H5F_t       *f;
     haddr_t     addr = 0, extra = 0, extra2 = 0, extra3 = 0, extra4 = 0;
     uint8_t     sig[H5F_SIGNATURE_LEN];
@@ -225,13 +225,13 @@ main(int argc, char *argv[])
     herr_t      status = SUCCEED;
 
     if(argc == 1) {
-	fprintf(stderr, "Usage: %s filename [signature-addr [extra]]\n", argv[0]);
-	HDexit(1);
+  HDfprintf(stderr, "Usage: %s filename [signature-addr [extra]]\n", argv[0]);
+  HDexit(1);
     } /* end if */
 
     /* Initialize the library */
     if(H5open() < 0) {
-        fprintf(stderr, "cannot initialize the library\n");
+        HDfprintf(stderr, "cannot initialize the library\n");
         HDexit(1);
     } /* end if */
 
@@ -239,27 +239,27 @@ main(int argc, char *argv[])
      * Open the file and get the file descriptor.
      */
     if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) {
-        fprintf(stderr, "cannot create dataset transfer property list\n");
+        HDfprintf(stderr, "cannot create dataset transfer property list\n");
         HDexit(1);
     } /* end if */
     if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
-        fprintf(stderr, "cannot create file access property list\n");
+        HDfprintf(stderr, "cannot create file access property list\n");
         HDexit(1);
     } /* end if */
     if(strchr(argv[1], '%'))
-	H5Pset_fapl_family (fapl, (hsize_t)0, H5P_DEFAULT);
+  H5Pset_fapl_family (fapl, (hsize_t)0, H5P_DEFAULT);
     if((fid = H5Fopen(argv[1], H5F_ACC_RDONLY, fapl)) < 0) {
-        fprintf(stderr, "cannot open file\n");
+        HDfprintf(stderr, "cannot open file\n");
         HDexit(1);
     } /* end if */
     if(NULL == (f = (H5F_t *)H5I_object(fid))) {
-        fprintf(stderr, "cannot obtain H5F_t pointer\n");
+        HDfprintf(stderr, "cannot obtain H5F_t pointer\n");
         HDexit(2);
     } /* end if */
 
     /* Ignore metadata tags while using h5debug */
     if(H5AC_ignore_tags(f) < 0) {
-        fprintf(stderr, "cannot ignore metadata tags\n");
+        HDfprintf(stderr, "cannot ignore metadata tags\n");
         HDexit(1);
     }
 
@@ -282,7 +282,7 @@ main(int argc, char *argv[])
      */
     HDfprintf(stdout, "Reading signature at address %a (rel)\n", addr);
     if(H5F_block_read(f, H5FD_MEM_SUPER, addr, sizeof(sig), dxpl, sig) < 0) {
-        fprintf(stderr, "cannot read signature\n");
+        HDfprintf(stderr, "cannot read signature\n");
         HDexit(3);
     }
     if(!HDmemcmp(sig, H5F_SIGNATURE, (size_t)H5F_SIGNATURE_LEN)) {
@@ -298,10 +298,10 @@ main(int argc, char *argv[])
         status = H5HL_debug(f, H5P_DATASET_XFER_DEFAULT, addr, stdout, 0, VCOL);
 
     } else if(!HDmemcmp (sig, H5HG_MAGIC, (size_t)H5_SIZEOF_MAGIC)) {
-	/*
-	 * Debug a global heap collection.
-	 */
-	status = H5HG_debug (f, H5P_DATASET_XFER_DEFAULT, addr, stdout, 0, VCOL);
+  /*
+   * Debug a global heap collection.
+   */
+  status = H5HG_debug (f, H5P_DATASET_XFER_DEFAULT, addr, stdout, 0, VCOL);
 
     } else if(!HDmemcmp(sig, H5G_NODE_MAGIC, (size_t)H5_SIZEOF_MAGIC)) {
         /*
@@ -310,9 +310,9 @@ main(int argc, char *argv[])
 
         /* Check for extra parameters */
         if(extra == 0) {
-            fprintf(stderr, "\nWarning: Providing the group's local heap address will give more information\n");
-            fprintf(stderr, "Symbol table node usage:\n");
-            fprintf(stderr, "\th5debug <filename> <Symbol table node address> <address of local heap>\n\n");
+            HDfprintf(stderr, "\nWarning: Providing the group's local heap address will give more information\n");
+            HDfprintf(stderr, "Symbol table node usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <Symbol table node address> <address of local heap>\n\n");
         } /* end if */
 
         status = H5G_node_debug(f, H5P_DATASET_XFER_DEFAULT, addr, stdout, 0, VCOL, extra);
@@ -330,9 +330,9 @@ main(int argc, char *argv[])
             case H5B_SNODE_ID:
                 /* Check for extra parameters */
                 if(extra == 0) {
-                    fprintf(stderr, "\nWarning: Providing the group's local heap address will give more information\n");
-                    fprintf(stderr, "B-tree symbol table node usage:\n");
-                    fprintf(stderr, "\th5debug <filename> <B-tree node address> <address of local heap>\n\n");
+                    HDfprintf(stderr, "\nWarning: Providing the group's local heap address will give more information\n");
+                    HDfprintf(stderr, "B-tree symbol table node usage:\n");
+                    HDfprintf(stderr, "\th5debug <filename> <B-tree node address> <address of local heap>\n\n");
                 } /* end if */
 
                 status = H5G_node_debug(f, H5P_DATASET_XFER_DEFAULT, addr, stdout, 0, VCOL, extra);
@@ -341,9 +341,9 @@ main(int argc, char *argv[])
             case H5B_CHUNK_ID:
                 /* Check for extra parameters */
                 if(extra == 0) {
-                    fprintf(stderr, "ERROR: Need number of dimensions of chunk in order to dump chunk B-tree node\n");
-                    fprintf(stderr, "B-tree chunked storage node usage:\n");
-                    fprintf(stderr, "\th5debug <filename> <B-tree node address> <# of dimensions>\n");
+                    HDfprintf(stderr, "ERROR: Need number of dimensions of chunk in order to dump chunk B-tree node\n");
+                    HDfprintf(stderr, "B-tree chunked storage node usage:\n");
+                    HDfprintf(stderr, "\th5debug <filename> <B-tree node address> <# of dimensions>\n");
                     HDexit(4);
                 } /* end if */
 
@@ -352,7 +352,7 @@ main(int argc, char *argv[])
                 break;
 
             default:
-                fprintf(stderr, "Unknown B-tree subtype %u\n", (unsigned)(subtype));
+                HDfprintf(stderr, "Unknown B-tree subtype %u\n", (unsigned)(subtype));
                 HDexit(4);
         }
 
@@ -374,10 +374,10 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0 || extra3 == 0) {
-            fprintf(stderr, "ERROR: Need v2 B-tree header address and the node's number of records and depth in order to dump internal node\n");
-            fprintf(stderr, "NOTE: Leaf nodes are depth 0, the internal nodes above them are depth 1, etc.\n");
-            fprintf(stderr, "v2 B-tree internal node usage:\n");
-            fprintf(stderr, "\th5debug <filename> <internal node address> <v2 B-tree header address> <number of records> <depth>\n");
+            HDfprintf(stderr, "ERROR: Need v2 B-tree header address and the node's number of records and depth in order to dump internal node\n");
+            HDfprintf(stderr, "NOTE: Leaf nodes are depth 0, the internal nodes above them are depth 1, etc.\n");
+            HDfprintf(stderr, "v2 B-tree internal node usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <internal node address> <v2 B-tree header address> <number of records> <depth>\n");
             HDexit(4);
         } /* end if */
 
@@ -392,9 +392,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0) {
-            fprintf(stderr, "ERROR: Need v2 B-tree header address and number of records in order to dump leaf node\n");
-            fprintf(stderr, "v2 B-tree leaf node usage:\n");
-            fprintf(stderr, "\th5debug <filename> <leaf node address> <v2 B-tree header address> <number of records>\n");
+            HDfprintf(stderr, "ERROR: Need v2 B-tree header address and number of records in order to dump leaf node\n");
+            HDfprintf(stderr, "v2 B-tree leaf node usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <leaf node address> <v2 B-tree header address> <number of records>\n");
             HDexit(4);
         } /* end if */
 
@@ -413,9 +413,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0) {
-            fprintf(stderr, "ERROR: Need fractal heap header address and size of direct block in order to dump direct block\n");
-            fprintf(stderr, "Fractal heap direct block usage:\n");
-            fprintf(stderr, "\th5debug <filename> <direct block address> <heap header address> <size of direct block>\n");
+            HDfprintf(stderr, "ERROR: Need fractal heap header address and size of direct block in order to dump direct block\n");
+            HDfprintf(stderr, "Fractal heap direct block usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <direct block address> <heap header address> <size of direct block>\n");
             HDexit(4);
         } /* end if */
 
@@ -428,9 +428,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0) {
-            fprintf(stderr, "ERROR: Need fractal heap header address and number of rows in order to dump indirect block\n");
-            fprintf(stderr, "Fractal heap indirect block usage:\n");
-            fprintf(stderr, "\th5debug <filename> <indirect block address> <heap header address> <number of rows>\n");
+            HDfprintf(stderr, "ERROR: Need fractal heap header address and number of rows in order to dump indirect block\n");
+            HDfprintf(stderr, "Fractal heap indirect block usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <indirect block address> <heap header address> <number of rows>\n");
             HDexit(4);
         } /* end if */
 
@@ -450,9 +450,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0) {
-            fprintf(stderr, "ERROR: Need free space header address and client address in order to dump serialized sections\n");
-            fprintf(stderr, "Free space serialized sections usage:\n");
-            fprintf(stderr, "\th5debug <filename> <serialized sections address> <free space header address> <client address>\n");
+            HDfprintf(stderr, "ERROR: Need free space header address and client address in order to dump serialized sections\n");
+            HDfprintf(stderr, "Free space serialized sections usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <serialized sections address> <free space header address> <client address>\n");
             HDexit(4);
         } /* end if */
 
@@ -472,9 +472,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra2 == 0) {
-            fprintf(stderr, "ERROR: Need list format version and number of messages in order to shared message list\n");
-            fprintf(stderr, "Shared message list usage:\n");
-            fprintf(stderr, "\th5debug <filename> <shared message list address> <list format version> <number of mesages in list>\n");
+            HDfprintf(stderr, "ERROR: Need list format version and number of messages in order to shared message list\n");
+            HDfprintf(stderr, "Shared message list usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <shared message list address> <list format version> <number of mesages in list>\n");
             HDexit(4);
         } /* end if */
 
@@ -487,11 +487,11 @@ main(int argc, char *argv[])
         const H5EA_class_t *cls = get_H5EA_class(sig);
         HDassert(cls);
 
-	 /* Check for enough valid parameters */
+   /* Check for enough valid parameters */
         if(extra == 0) {
-            fprintf(stderr, "ERROR: Need object header address containing the layout message in order to dump header\n");
-            fprintf(stderr, "Extensible array header block usage:\n");
-            fprintf(stderr, "\th5debug <filename> <Extensible Array header address> <object header address>\n");
+            HDfprintf(stderr, "ERROR: Need object header address containing the layout message in order to dump header\n");
+            HDfprintf(stderr, "Extensible array header block usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <Extensible Array header address> <object header address>\n");
             HDexit(4);
         } /* end if */
 
@@ -506,9 +506,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0) {
-            fprintf(stderr, "ERROR: Need extensible array header address and object header address containing the layout message in order to dump index block\n");
-            fprintf(stderr, "Extensible array index block usage:\n");
-            fprintf(stderr, "\th5debug <filename> <index block address> <array header address> <object header address\n");
+            HDfprintf(stderr, "ERROR: Need extensible array header address and object header address containing the layout message in order to dump index block\n");
+            HDfprintf(stderr, "Extensible array index block usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <index block address> <array header address> <object header address\n");
             HDexit(4);
         } /* end if */
 
@@ -523,9 +523,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0 || extra3 == 0) {
-            fprintf(stderr, "ERROR: Need extensible array header address, super block index and object header address containing the layout message in order to dump super block\n");
-            fprintf(stderr, "Extensible array super block usage:\n");
-            fprintf(stderr, "\th5debug <filename> <super block address> <array header address> <super block index> <object header address>\n");
+            HDfprintf(stderr, "ERROR: Need extensible array header address, super block index and object header address containing the layout message in order to dump super block\n");
+            HDfprintf(stderr, "Extensible array super block usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <super block address> <array header address> <super block index> <object header address>\n");
             HDexit(4);
         } /* end if */
 
@@ -540,9 +540,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0 || extra3 == 0) {
-            fprintf(stderr, "ERROR: Need extensible array header address, # of elements in data block and object header address containing the layout message in order to dump data block\n");
-            fprintf(stderr, "Extensible array data block usage:\n");
-            fprintf(stderr, "\th5debug <filename> <data block address> <array header address> <# of elements in data block> <object header address\n");
+            HDfprintf(stderr, "ERROR: Need extensible array header address, # of elements in data block and object header address containing the layout message in order to dump data block\n");
+            HDfprintf(stderr, "Extensible array data block usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <data block address> <array header address> <# of elements in data block> <object header address\n");
             HDexit(4);
         } /* end if */
 
@@ -555,11 +555,11 @@ main(int argc, char *argv[])
         const H5FA_class_t *cls = get_H5FA_class(sig);
         HDassert(cls);
 
-	/* Check for enough valid parameters */
+  /* Check for enough valid parameters */
         if(extra == 0) {
-	    fprintf(stderr, "ERROR: Need object header address containing the layout message in order to dump header\n");
-            fprintf(stderr, "Fixed array header block usage:\n");
-	    fprintf(stderr, "\th5debug <filename> <Fixed Array header address> <object header address>\n");
+      HDfprintf(stderr, "ERROR: Need object header address containing the layout message in order to dump header\n");
+            HDfprintf(stderr, "Fixed array header block usage:\n");
+      HDfprintf(stderr, "\th5debug <filename> <Fixed Array header address> <object header address>\n");
             HDexit(4);
         } /* end if */
 
@@ -574,9 +574,9 @@ main(int argc, char *argv[])
 
         /* Check for enough valid parameters */
         if(extra == 0 || extra2 == 0) {
-            fprintf(stderr, "ERROR: Need fixed array header address and object header address containing the layout message in order to dump data block\n");
-            fprintf(stderr, "fixed array data block usage:\n");
-            fprintf(stderr, "\th5debug <filename> <data block address> <array header address> <object header address>\n");
+            HDfprintf(stderr, "ERROR: Need fixed array header address and object header address containing the layout message in order to dump data block\n");
+            HDfprintf(stderr, "fixed array data block usage:\n");
+            HDfprintf(stderr, "\th5debug <filename> <data block address> <array header address> <object header address>\n");
             HDexit(4);
         } /* end if */
 
@@ -612,13 +612,13 @@ main(int argc, char *argv[])
         }
         HDputchar('\n');
 
-        fprintf(stderr, "unknown signature\n");
+        HDfprintf(stderr, "unknown signature\n");
         HDexit(4);
     } /* end else */
 
     /* Check for an error when dumping information */
     if(status < 0) {
-        fprintf(stderr, "An error occurred!\n");
+        HDfprintf(stderr, "An error occurred!\n");
         H5Eprint2(H5E_DEFAULT, stderr);
         HDexit(5);
     } /* end if */
diff --git a/tools/misc/h5mkgrp.c b/tools/misc/h5mkgrp.c
index 09f23ef..b5c69e8 100644
--- a/tools/misc/h5mkgrp.c
+++ b/tools/misc/h5mkgrp.c
@@ -81,7 +81,7 @@ leave(int ret)
 static void
 usage(void)
 {
-    fprintf(stdout, "\
+    HDfprintf(stdout, "\
 usage: h5mkgrp [OPTIONS] FILE GROUP...\n\
    OPTIONS\n\
       -h, --help         Print a usage message and exit\n\
@@ -97,8 +97,8 @@ usage: h5mkgrp [OPTIONS] FILE GROUP...\n\
  *
  * Purpose: Parses command line and sets up global variable to control output
  *
- * Return:	Success: 0
- *		Failure: -1
+ * Return:  Success: 0
+ *    Failure: -1
  *
  * Programmer: Quincey Koziol, 2/13/2007
  *