[svn-r2623] Purpose:

    Reformat the source
Description:
    The tabstop seems to defined different from 8-stops.  The
    source files looked very confusing.  Just reformate the
    files.  Not change to source code at all.
Platforms tested:
    modi4 -64.

2 files changed, 730 insertions, 726 deletions

diff --git a/tools/h5dump.c b/tools/h5dump.c
index 4865458..c87a74f 100644
--- a/tools/h5dump.c
+++ b/tools/h5dump.c
@@ -34,167 +34,166 @@ extern void indentation(int);
 extern int print_data(hid_t, hid_t, int);
 
 static h5dump_t dataformat = {
-	0,		/*raw*/
-
-	"",		/*fmt_raw*/
-	"%d",	/*fmt_int*/
-	"%u",	/*fmt_uint*/
-	"%d",	/*fmt_schar*/
-	"%u",	/*fmt_uchar*/
-	"%d",	/*fmt_short*/
-	"%u",	/*fmt_ushort*/
-	"%ld",	/*fmt_long*/
-	"%lu",	/*fmt_ulong*/
-	NULL,	/*fmt_llong*/
-	NULL,	/*fmt_ullong*/
-	"%g",	/*fmt_double*/
-	"%g",	/*fmt_float*/
-
-	0,		/*ascii*/
-	0,		/*str_locale*/
-	0,		/*str_repeat*/
-
-
-	"[ ",	/*arr_pre*/
-	", ",	/*arr_sep*/
-	" ]",	/*arr_suf*/
-	1,		/*arr_linebreak*/
-
-	"",		/*cmpd_name*/
-	",\n",	/*cmpd_sep*/
-	"{\n",	/*cmpd_pre*/
-	"}",	/*cmpd_suf*/
-	"\n",	/*cmpd_end*/
-
-	"%s",	/*elmt_fmt*/
-	",",	/*elmt_suf1*/
-	" ",	/*elmt_suf2*/
-
-	"",		/*idx_n_fmt*/
-	"",		/*idx_sep*/
-	"",		/*idx_fmt*/
-
-	80,		/*line_ncols*//*standard default columns*/
-	0,		/*line_per_line*/
-	"",		/*line_pre*/
-	"%s",	/*line_1st*/
-	"%s",	/*line_cont*/
-	"",		/*line_suf*/
-	"",		/*line_sep*/
-	1,		/*line_multi_new*/
-	"   ",	/*line_indent*/
-
-	1,		/*skip_first*/
-
-	1,		/*obj_hidefileno*/
-	" %lu:%lu",/*obj_format*/
-
-	1,		/*dset_hidefileno*/
-	"DATASET %lu:%lu ",/*dset_format*/
-	"%s",	/*dset_blockformat_pre*/
-	"%s",	/*dset_ptformat_pre*/
-	"%s",	/*dset_ptformat*/
+    0,		/*raw*/
+
+    "",		/*fmt_raw*/
+    "%d",	/*fmt_int*/
+    "%u",	/*fmt_uint*/
+    "%d",	/*fmt_schar*/
+    "%u",	/*fmt_uchar*/
+    "%d",	/*fmt_short*/
+    "%u",	/*fmt_ushort*/
+    "%ld",	/*fmt_long*/
+    "%lu",	/*fmt_ulong*/
+    NULL,	/*fmt_llong*/
+    NULL,	/*fmt_ullong*/
+    "%g",	/*fmt_double*/
+    "%g",	/*fmt_float*/
+
+    0,		/*ascii*/
+    0,		/*str_locale*/
+    0,		/*str_repeat*/
+
+
+    "[ ",	/*arr_pre*/
+    ", ",	/*arr_sep*/
+    " ]",	/*arr_suf*/
+    1,		/*arr_linebreak*/
+
+    "",		/*cmpd_name*/
+    ",\n",	/*cmpd_sep*/
+    "{\n",	/*cmpd_pre*/
+    "}",	/*cmpd_suf*/
+    "\n",	/*cmpd_end*/
+
+    "%s",	/*elmt_fmt*/
+    ",",	/*elmt_suf1*/
+    " ",	/*elmt_suf2*/
+
+    "",		/*idx_n_fmt*/
+    "",		/*idx_sep*/
+    "",		/*idx_fmt*/
+
+    80,		/*line_ncols*//*standard default columns*/
+    0,		/*line_per_line*/
+    "",		/*line_pre*/
+    "%s",	/*line_1st*/
+    "%s",	/*line_cont*/
+    "",		/*line_suf*/
+    "",		/*line_sep*/
+    1,		/*line_multi_new*/
+    "   ",	/*line_indent*/
+
+    1,		/*skip_first*/
+
+    1,		/*obj_hidefileno*/
+    " %lu:%lu",/*obj_format*/
+
+    1,		/*dset_hidefileno*/
+    "DATASET %lu:%lu ",/*dset_format*/
+    "%s",	/*dset_blockformat_pre*/
+    "%s",	/*dset_ptformat_pre*/
+    "%s",	/*dset_ptformat*/
 };
 
 static const dump_header standardformat = {
-	"standardformat",	/*name*/
-	"HDF5",				/*fileebgin*/
-	"",					/*fileend*/
-	BOOT_BLOCK,			/*bootblockbegin*/
-	"",					/*bootblockend*/
-	GROUPNAME,			/*groupbegin*/
-	"",					/*groupend*/
-	DATASET,			/*datasetbegin*/
-	"",					/*datasetend*/
-	ATTRIBUTE,			/*attributebegin*/
-	"",					/*attributeend*/
-	DATATYPE,			/*datatypebegin*/
-	"",					/*datatypeend*/
-	DATASPACE,			/*dataspacebegin*/
-	"",					/*dataspaceend*/
-	DATA,				/*databegin*/
-	"",					/*dataend*/
-	SOFTLINK,			/*softlinkbegin*/
-	"",					/*softlinkend*/
-
-
-	"{",				/*fileblockbegin*/
-	"}",				/*fileblockend*/
-	"{",				/*bootblockblockbegin*/
-	"}",				/*bootblockblockend*/
-	"{",				/*groupblockbegin*/
-	"}",				/*groupblockend*/
-	"{",				/*datasetblockbegin*/
-	"}",				/*datasetblockend*/
-	"{",				/*attributeblockbegin*/
-	"}",				/*attributeblockend*/
-	"{",				/*datatypeblockbegin*/
-	"}",				/*datatypeblockend*/
-	"{",				/*dataspaceblockbegin*/
-	"}",				/*dataspaceblockend*/
-	"{",				/*datablockbegin*/
-	"}",				/*datablockend*/
-	"{",				/*softlinkblockbegin*/
-	"}",				/*softlinkblockend*/
-	"{",				/*strblockbegin*/
-	"}",				/*strblockend*/
-	"{",				/*enumblockbegin*/
-	"}",				/*enumblockend*/
-
-	"{",				/*dataspacedescriptionbegin*/
-	"}",				/*dataspacedescriptionend*/
-	"(",				/*dataspacedimbegin*/
-	")",				/*dataspacedimend*/
+    "standardformat",	/*name*/
+    "HDF5",		/*fileebgin*/
+    "",			/*fileend*/
+    BOOT_BLOCK,		/*bootblockbegin*/
+    "",			/*bootblockend*/
+    GROUPNAME,		/*groupbegin*/
+    "",			/*groupend*/
+    DATASET,		/*datasetbegin*/
+    "",			/*datasetend*/
+    ATTRIBUTE,		/*attributebegin*/
+    "",			/*attributeend*/
+    DATATYPE,		/*datatypebegin*/
+    "",			/*datatypeend*/
+    DATASPACE,		/*dataspacebegin*/
+    "",			/*dataspaceend*/
+    DATA,		/*databegin*/
+    "",			/*dataend*/
+    SOFTLINK,		/*softlinkbegin*/
+    "",			/*softlinkend*/
+
+    "{",		/*fileblockbegin*/
+    "}",		/*fileblockend*/
+    "{",		/*bootblockblockbegin*/
+    "}",		/*bootblockblockend*/
+    "{",		/*groupblockbegin*/
+    "}",		/*groupblockend*/
+    "{",		/*datasetblockbegin*/
+    "}",		/*datasetblockend*/
+    "{",		/*attributeblockbegin*/
+    "}",		/*attributeblockend*/
+    "{",		/*datatypeblockbegin*/
+    "}",		/*datatypeblockend*/
+    "{",		/*dataspaceblockbegin*/
+    "}",		/*dataspaceblockend*/
+    "{",		/*datablockbegin*/
+    "}",		/*datablockend*/
+    "{",		/*softlinkblockbegin*/
+    "}",		/*softlinkblockend*/
+    "{",		/*strblockbegin*/
+    "}",		/*strblockend*/
+    "{",		/*enumblockbegin*/
+    "}",		/*enumblockend*/
+
+    "{",		/*dataspacedescriptionbegin*/
+    "}",		/*dataspacedescriptionend*/
+    "(",		/*dataspacedimbegin*/
+    ")",		/*dataspacedimend*/
 };
 
 static const dump_header xmlformat = {
-	"xml",				/*name*/
-	"<FILE>",			/*filebegin*/
-	"</FILE>",			/*fileend*/
-	"<BOOTBLOCK>",		/*bootblockbegin*/
-	"</BOOTBLOCK>",		/*bootblockend*/
-	"<GROUP>",			/*groupbegin*/
-	"</GROUP>",			/*groupend*/
-	"<DATASET>",		/*datasetbegin*/
-	"</DATASET>",		/*datasetend*/	
-	"<ATTRIBUTE>",		/*attributebegin*/
-	"</ATTRIBUTE>",		/*attributeend*/
-	"<DATATYPE>",		/*datatypeend*/
-	"</DATATYPE>",		/*datatypeend*/
-	"<DATASPACE>",		/*dataspacebegin*/
-	"</DATASPACE>",		/*dataspaceend*/
-	"<DATA>",			/*databegin*/
-	"</DATA>",			/*dataend*/
-	"<SOFTLINK>",		/*softlinkbegin*/
-	"</SOFTLINK>",		/*softlinkend*/
-
-	"",					/*fileblockbegin*/
-	"",					/*fileblockend*/
-	"",					/*bootblockblockbegin*/
-	"",					/*bootblockblockend*/
-	"",					/*groupblockbegin*/
-	"",					/*groupblockend*/
-	"",					/*datasetblockbegin*/
-	"",					/*datasetblockend*/
-	"",					/*attributeblockbegin*/
-	"",					/*attributeblockend*/
-	"",					/*datatypeblockbegin*/
-	"",					/*datatypeblockend*/
-	"",					/*dataspaceblockbegin*/
-	"",					/*dataspaceblockend*/
-	"",					/*datablockbegin*/
-	"",					/*datablockend*/
-	"",					/*softlinkblockbegin*/
-	"",					/*softlinkblockend*/
-	"",					/*strblockbegin*/
-	"",					/*strblockend*/
-	"",					/*enumblockbegin*/
-	"",					/*enumblockend*/
-
-	"",					/*dataspacedescriptionbegin*/
-	"",					/*dataspacedescriptionend*/
-	"(",				/*dataspacedimbegin*/
-	")",				/*dataspacedimend*/
+    "xml",		/*name*/
+    "<FILE>",		/*filebegin*/
+    "</FILE>",		/*fileend*/
+    "<BOOTBLOCK>",	/*bootblockbegin*/
+    "</BOOTBLOCK>",	/*bootblockend*/
+    "<GROUP>",		/*groupbegin*/
+    "</GROUP>",		/*groupend*/
+    "<DATASET>",	/*datasetbegin*/
+    "</DATASET>",	/*datasetend*/	
+    "<ATTRIBUTE>",	/*attributebegin*/
+    "</ATTRIBUTE>",	/*attributeend*/
+    "<DATATYPE>",	/*datatypeend*/
+    "</DATATYPE>",	/*datatypeend*/
+    "<DATASPACE>",	/*dataspacebegin*/
+    "</DATASPACE>",	/*dataspaceend*/
+    "<DATA>",		/*databegin*/
+    "</DATA>",		/*dataend*/
+    "<SOFTLINK>",	/*softlinkbegin*/
+    "</SOFTLINK>",	/*softlinkend*/
+
+    "",			/*fileblockbegin*/
+    "",			/*fileblockend*/
+    "",			/*bootblockblockbegin*/
+    "",			/*bootblockblockend*/
+    "",			/*groupblockbegin*/
+    "",			/*groupblockend*/
+    "",			/*datasetblockbegin*/
+    "",			/*datasetblockend*/
+    "",			/*attributeblockbegin*/
+    "",			/*attributeblockend*/
+    "",			/*datatypeblockbegin*/
+    "",			/*datatypeblockend*/
+    "",			/*dataspaceblockbegin*/
+    "",			/*dataspaceblockend*/
+    "",			/*datablockbegin*/
+    "",			/*datablockend*/
+    "",			/*softlinkblockbegin*/
+    "",			/*softlinkblockend*/
+    "",			/*strblockbegin*/
+    "",			/*strblockend*/
+    "",			/*enumblockbegin*/
+    "",			/*enumblockend*/
+
+    "",			/*dataspacedescriptionbegin*/
+    "",			/*dataspacedescriptionend*/
+    "(",		/*dataspacedimbegin*/
+    ")",		/*dataspacedimend*/
 };
 
 /*-------------------------------------------------------------------------
@@ -212,7 +211,7 @@ static const dump_header xmlformat = {
 static void
 usage(void)
 {
-	fprintf(stderr, 
+    fprintf(stderr, 
 "\nUsage of HDF5 Dumper:\n\n\
 h5dump [-h] [-bb] [-header] [-v] [-V] [-a <names>] [-d <names>] [-g <names>]\n\
        [-l <names>] [-t <names>] [-w <number>] <file>\n\n\
@@ -247,14 +246,14 @@ h5dump [-h] [-bb] [-header] [-v] [-V] [-a <names>] [-d <names>] [-g <names>]\n\
 static void
 print_datatype(hid_t type)
 {
-	char *fname ;
-	hid_t nmembers, mtype, str_type;
-	int i, j, ndims, perm[H5DUMP_MAX_RANK];
-	size_t dims[H5DUMP_MAX_RANK], size;
-	H5T_str_t str_pad; 
-	H5T_cset_t cset;
-	H5G_stat_t statbuf;
-	hid_t super;
+    char *fname ;
+    hid_t nmembers, mtype, str_type;
+    int i, j, ndims, perm[H5DUMP_MAX_RANK];
+    size_t dims[H5DUMP_MAX_RANK], size;
+    H5T_str_t str_pad; 
+    H5T_cset_t cset;
+    H5G_stat_t statbuf;
+    hid_t super;
 
     switch (H5Tget_class(type)) {
     case H5T_INTEGER:
@@ -379,20 +378,20 @@ print_datatype(hid_t type)
             printf("H5T_C_S1;\n");
             H5Tclose(str_type);
         } else {
-        	H5Tclose(str_type);
-        	str_type = H5Tcopy(H5T_FORTRAN_S1);
-        	H5Tset_cset(str_type, cset ) ;
-        	H5Tset_size(str_type, size);
-        	H5Tset_strpad(str_type, str_pad );
-
-        	if (H5Tequal(type,str_type)) {
-            	printf( "H5T_FORTRAN_S1;\n");
-			} else {
-				printf("unknown_one_character_type;\n ");
-				d_status = 1;
-			}
+	    H5Tclose(str_type);
+	    str_type = H5Tcopy(H5T_FORTRAN_S1);
+	    H5Tset_cset(str_type, cset ) ;
+	    H5Tset_size(str_type, size);
+	    H5Tset_strpad(str_type, str_pad );
+
+	    if (H5Tequal(type,str_type)) {
+		printf( "H5T_FORTRAN_S1;\n");
+	    } else {
+		printf("unknown_one_character_type;\n ");
+		d_status = 1;
+	    }
 
-        	H5Tclose(str_type);
+	    H5Tclose(str_type);
         }
 
         indentation(indent + COL);
@@ -425,9 +424,9 @@ print_datatype(hid_t type)
     case H5T_OPAQUE: 
         printf( "\n");
         indentation (indent+COL);
-		printf("H5T_OPAQUE;\n");
+	printf("H5T_OPAQUE;\n");
         indentation (indent+COL);
-		printf("OPAQUE_TAG \"%s\";\n", H5Tget_tag(type));
+	printf("OPAQUE_TAG \"%s\";\n", H5Tget_tag(type));
         indentation (indent);
         break;
 
@@ -440,7 +439,7 @@ print_datatype(hid_t type)
             if (i >= 0) {
                 if (!type_table->objs[i].recorded) 
                     printf("\"/#%lu:%lu\"\n",
-						   type_table->objs[i].objno[0],
+			   type_table->objs[i].objno[0],
                            type_table->objs[i].objno[1]);
                 else
                     printf("\"%s\"\n", type_table->objs[i].objname);
@@ -458,21 +457,21 @@ print_datatype(hid_t type)
                  ndims = H5Tget_member_dims(type, i, dims, perm);
 
                  if (H5Tget_class(mtype) != H5T_STRING)
-					 /* && (H5Tget_class(mtype) != H5T_COMPOUND))*/
+			 /* && (H5Tget_class(mtype) != H5T_COMPOUND))*/
                      indentation (indent + COL);
 
-				 if (H5Tget_class(mtype) == H5T_COMPOUND) {
-					 indent += COL; 
-					 printf("{\n");
-				 }
+		 if (H5Tget_class(mtype) == H5T_COMPOUND) {
+			 indent += COL; 
+			 printf("{\n");
+		 }
 
                  print_datatype(mtype);
 
-				 if (H5Tget_class(mtype) == H5T_COMPOUND) {
-					 indent -= COL;
-                     indentation (indent+COL);
-					 printf("}");
-				 }
+		 if (H5Tget_class(mtype) == H5T_COMPOUND) {
+		     indent -= COL;
+		     indentation (indent+COL);
+		     printf("}");
+		 }
 
                  printf (" \"%s\"", fname);
 
@@ -487,26 +486,26 @@ print_datatype(hid_t type)
         break;
 
 	case H5T_REFERENCE:
-		printf("H5T_REFERENCE");
-		break;
+	    printf("H5T_REFERENCE");
+	    break;
 
 	case H5T_ENUM:
-		printf("H5T_ENUM\n");
-		indentation(indent + COL);
-		printf("%s ", dump_header_format->enumblockbegin);	
-		super = H5Tget_super(type);
-		print_datatype(super);
-		printf(";");
-		print_enum(type);
-		printf("\n");
-		indentation(indent + COL);
-		printf("%s", dump_header_format->enumblockend);
-		break;
-
-    default:
-        printf( "unknown data type");
-        d_status = 1;
-        break;
+	    printf("H5T_ENUM\n");
+	    indentation(indent + COL);
+	    printf("%s ", dump_header_format->enumblockbegin);	
+	    super = H5Tget_super(type);
+	    print_datatype(super);
+	    printf(";");
+	    print_enum(type);
+	    printf("\n");
+	    indentation(indent + COL);
+	    printf("%s", dump_header_format->enumblockend);
+	    break;
+
+	default:
+	    printf( "unknown data type");
+	    d_status = 1;
+	    break;
     }
 }
 
@@ -548,25 +547,25 @@ dump_datatype(hid_t type)
     indentation(indent);
 
     if (H5Tget_class(type) == H5T_COMPOUND) {
-		printf("%s %s\n", dump_header_format->datatypebegin,
-			   dump_header_format->datatypeblockbegin);
+	printf("%s %s\n", dump_header_format->datatypebegin,
+		       dump_header_format->datatypeblockbegin);
         print_datatype(type);
         indentation(indent);
         printf("%s %s\n", dump_header_format->datatypeblockend,
-			   dump_header_format->datatypeend);
+		       dump_header_format->datatypeend);
     } else if (H5Tget_class(type) == H5T_STRING) {
         printf("%s %s\n", dump_header_format->datatypebegin,
-			   dump_header_format->datatypeblockbegin);
+		       dump_header_format->datatypeblockbegin);
         print_datatype(type);
         printf("\n");
         indentation(indent);
-		printf("%s %s\n", dump_header_format->datatypeblockend,
-			   dump_header_format->datatypeend);
+	printf("%s %s\n", dump_header_format->datatypeblockend,
+		       dump_header_format->datatypeend);
     } else {
         printf("%s %s ", dump_header_format->datatypebegin,
 			   dump_header_format->datatypeblockbegin);
         print_datatype(type);
-		printf(" %s %s\n", dump_header_format->datatypeblockend,
+	printf(" %s %s\n", dump_header_format->datatypeblockend,
 			   dump_header_format->datatypeend);
     }
 
@@ -599,28 +598,28 @@ dump_dataspace(hid_t space)
 
     if (H5Sis_simple(space)) {
         if (ndims == 0) {
-			/* scalar dataspace */ 
+	    /* scalar dataspace */ 
             HDfprintf(stdout, "%s %s ",
-					  dump_header_format->dataspacedescriptionbegin,
-					  SCALAR);
-		} else {
-			/* simple dataspace */
+			  dump_header_format->dataspacedescriptionbegin,
+			  SCALAR);
+	} else {
+	    /* simple dataspace */
             HDfprintf(stdout, "%s %s %s %Hu",
-					  dump_header_format->dataspacedescriptionbegin, SIMPLE, 
-					  dump_header_format->dataspacedimbegin,size[0]);
+			  dump_header_format->dataspacedescriptionbegin, SIMPLE, 
+			  dump_header_format->dataspacedimbegin,size[0]);
 
             for (i = 1; i < ndims; i++) 
                 HDfprintf (stdout, ", %Hu", size[i]);
 
             printf(" %s / ", dump_header_format->dataspacedimend);
            
-           if (maxsize[0]==H5S_UNLIMITED)
-               HDfprintf(stdout, "%s %s",
-					     dump_header_format->dataspacedimbegin,
-						 "H5S_UNLIMITED");
+	    if (maxsize[0]==H5S_UNLIMITED)
+		HDfprintf(stdout, "%s %s",
+			     dump_header_format->dataspacedimbegin,
+			     "H5S_UNLIMITED");
             else
                HDfprintf(stdout, "%s %Hu",
-					     dump_header_format->dataspacedimbegin, maxsize[0]);
+			     dump_header_format->dataspacedimbegin, maxsize[0]);
 
             for (i = 1; i < ndims; i++) 
                  if (maxsize[i] == H5S_UNLIMITED)
@@ -632,9 +631,10 @@ dump_dataspace(hid_t space)
         }
     } else {
         printf("%s not yet implemented %s\n", BEGIN, END);
-	}
+    }
 
-	end_obj(dump_header_format->dataspaceend, dump_header_format->dataspaceblockend);
+    end_obj(dump_header_format->dataspaceend,
+	    dump_header_format->dataspaceblockend);
 }
 
 /*-------------------------------------------------------------------------
@@ -654,11 +654,11 @@ dump_dataspace(hid_t space)
 static herr_t
 dump_attr(hid_t attr, const char *attr_name, void UNUSED *op_data)
 {
-	hid_t  attr_id, type, space;
+    hid_t  attr_id, type, space;
 
     indentation(indent);
     begin_obj(dump_header_format->attributebegin, attr_name,
-			  dump_header_format->attributeblockbegin); 
+	      dump_header_format->attributeblockbegin); 
 
     if ((attr_id = H5Aopen_name (attr, attr_name))>= 0) {
         type = H5Aget_type(attr_id);
@@ -666,25 +666,25 @@ dump_attr(hid_t attr, const char *attr_name, void UNUSED *op_data)
         dump_datatype(type);
         dump_dataspace(space);
 
-		if (display_oid)
-			dump_oid(attr_id);
+	if (display_oid)
+	    dump_oid(attr_id);
 
         if (display_data)
-			dump_data(attr_id, ATTRIBUTE_DATA);
+	    dump_data(attr_id, ATTRIBUTE_DATA);
 
         H5Tclose(type);
         H5Sclose(space);
-		H5Aclose (attr_id);
+	H5Aclose (attr_id);
         indentation (indent);
         end_obj(dump_header_format->attributeend,
-				dump_header_format->attributeblockend);
-		return SUCCEED;
+		dump_header_format->attributeblockend);
+	return SUCCEED;
     } else {
         indentation(indent + COL);
         printf("h5dump error: unable to open attribute.\n");
         indentation(indent);
         end_obj(dump_header_format->attributeend,
-				dump_header_format->attributeblockend);
+		dump_header_format->attributeblockend);
         d_status = 1;
         return FAIL;
     }
@@ -707,29 +707,29 @@ dump_attr(hid_t attr, const char *attr_name, void UNUSED *op_data)
 static herr_t
 dump_selected_attr(hid_t loc_id, char *name)
 {
-	int j;
-	char *obj_name, *attr_name;
-	hid_t  oid, attr_id, type, space;
-	H5G_stat_t statbuf;
+    int j;
+    char *obj_name, *attr_name;
+    hid_t  oid, attr_id, type, space;
+    H5G_stat_t statbuf;
 
     j = (int)strlen(name) - 1;
     obj_name = malloc(j + 2);
 
     /* find the last / */
     while (name[j] != '/' && j >=0)
-		j--;
+	j--;
 
     /* object name */
     if (j == -1) {
-		strcpy(obj_name, "/");
-	} else {
-		strncpy(obj_name, name, j+1);
+	strcpy(obj_name, "/");
+    } else {
+	strncpy(obj_name, name, j+1);
     	obj_name[j+1] = '\0';
     }
 
     attr_name = name + j + 1;
     begin_obj(dump_header_format->attributebegin, name,
-			  dump_header_format->attributeblockbegin);
+	      dump_header_format->attributeblockbegin);
     H5Gget_objinfo(loc_id, obj_name, FALSE , &statbuf);
 
     switch (statbuf.type) {
@@ -738,7 +738,7 @@ dump_selected_attr(hid_t loc_id, char *name)
              indentation(COL);
              fprintf(stdout, "h5dump error: unable to open %s\n", obj_name);
              end_obj(dump_header_format->attributeend,
-					 dump_header_format->attributeblockend);
+		     dump_header_format->attributeblockend);
              d_status = 1;
              return FAIL;
          }
@@ -749,7 +749,7 @@ dump_selected_attr(hid_t loc_id, char *name)
              indentation(COL);
              fprintf(stdout, "h5dump error: unable to open %s\n", obj_name);
              end_obj(dump_header_format->attributeend,
-					 dump_header_format->attributeblockend);
+		     dump_header_format->attributeblockend);
              d_status = 1;
              return FAIL;
          }
@@ -760,7 +760,7 @@ dump_selected_attr(hid_t loc_id, char *name)
              indentation(COL);
              fprintf(stdout, "h5dump error: unable to open %s\n", obj_name);
              end_obj(dump_header_format->attributeend,
-					 dump_header_format->attributeblockend);
+		     dump_header_format->attributeblockend);
              d_status = 1;
              return FAIL;
          }
@@ -769,7 +769,7 @@ dump_selected_attr(hid_t loc_id, char *name)
          indentation(COL);
          fprintf(stdout, "h5dump error: unable to open %s\n", obj_name);
          end_obj(dump_header_format->attributeend,
-				 dump_header_format->attributeblockend);
+		     dump_header_format->attributeblockend);
          d_status = 1;
          return FAIL;
     }
@@ -780,30 +780,30 @@ dump_selected_attr(hid_t loc_id, char *name)
         dump_datatype(type);
         dump_dataspace(space);
 
-		if (display_oid)
-			dump_oid(attr_id);
+	if (display_oid)
+	    dump_oid(attr_id);
 
         if (display_data)
-			dump_data(attr_id, ATTRIBUTE_DATA);
+	    dump_data(attr_id, ATTRIBUTE_DATA);
 
         H5Tclose(type);
         H5Sclose(space);
-		H5Aclose (attr_id);
+	H5Aclose (attr_id);
         end_obj(dump_header_format->attributeend,
-				dump_header_format->attributeblockend);
+		dump_header_format->attributeblockend);
     } else {
         indentation(COL);
         printf("h5dump error: unable to open attribute.\n");
         end_obj(dump_header_format->attributeend,
-				dump_header_format->attributeblockend);
+		dump_header_format->attributeblockend);
         d_status = 1;
     }
 
     switch (statbuf.type) {
     case H5G_GROUP:
          if (H5Gclose (oid) < 0) {
-			 d_status = 1;
-			 return FAIL;
+	     d_status = 1;
+	     return FAIL;
          } 
          break;
           
@@ -846,10 +846,10 @@ dump_selected_attr(hid_t loc_id, char *name)
 static herr_t
 dump_all(hid_t group, const char *name, void UNUSED *op_data)
 {
-	hid_t obj;
-	char *buf, *tmp;
-	H5G_stat_t statbuf;
-	int i;
+    hid_t obj;
+    char *buf, *tmp;
+    H5G_stat_t statbuf;
+    int i;
 
     H5Gget_objinfo(group, name, FALSE, &statbuf);
     tmp = (char *)malloc(strlen(prefix) + strlen(name) + 2);
@@ -860,19 +860,19 @@ dump_all(hid_t group, const char *name, void UNUSED *op_data)
         indentation(indent);
         buf = malloc(statbuf.linklen);
         begin_obj(dump_header_format->softlinkbegin, name,
-				  dump_header_format->softlinkblockbegin);
+		  dump_header_format->softlinkblockbegin);
         indentation(indent + COL);
 
         if (H5Gget_linkval(group, name, statbuf.linklen, buf) >= 0) {
             printf("LINKTARGET \"%s\"\n", buf);
-		} else {
+	} else {
             printf("h5dump error: unable to get link value.\n");
             d_status = 1;
         }
 
         indentation(indent);
         end_obj(dump_header_format->softlinkend,
-				dump_header_format->softlinkblockend);
+		dump_header_format->softlinkblockend);
         free(buf);
         break;
 
@@ -900,23 +900,23 @@ dump_all(hid_t group, const char *name, void UNUSED *op_data)
                  if (i < 0) {
                      indentation(indent);
                      begin_obj(dump_header_format->datasetbegin, name,
-							   dump_header_format->datasetblockbegin);
+			       dump_header_format->datasetblockbegin);
                      indentation(indent + COL);
                      printf("h5dump error: internal error\n");
                      indentation(indent);
                      end_obj(dump_header_format->datasetend,
-							 dump_header_format->datasetblockend);
+			     dump_header_format->datasetblockend);
                      d_status = 1;
                      goto done;
                  } else if (dset_table->objs[i].displayed) {
                      indentation(indent);
                      begin_obj(dump_header_format->datasetbegin, name,
-							   dump_header_format->datasetblockbegin);
+			       dump_header_format->datasetblockbegin);
                      indentation(indent + COL);
                      printf("%s \"%s\"\n", HARDLINK, dset_table->objs[i].objname);
                      indentation(indent);
                      end_obj(dump_header_format->datasetend,
-							 dump_header_format->datasetblockend);
+			     dump_header_format->datasetblockend);
                      goto done;
                  } else {
                      dset_table->objs[i].displayed = 1;
@@ -936,15 +936,15 @@ dump_all(hid_t group, const char *name, void UNUSED *op_data)
          break;
 
     case H5G_TYPE:
-		if ((obj = H5Topen(group, name)) >= 0) {
-			dump_named_datatype(obj, name);
-			H5Tclose(obj);
-		} else {
-			printf("h5dump error: unable to dump data type %s\n", name);
-			d_status = 1;
-		}
+	if ((obj = H5Topen(group, name)) >= 0) {
+	    dump_named_datatype(obj, name);
+	    H5Tclose(obj);
+	} else {
+	    printf("h5dump error: unable to dump data type %s\n", name);
+	    d_status = 1;
+	}
 
-		break;
+	break;
 
     default:
          printf ("h5dump error: unknown object %s\n", name);
@@ -972,42 +972,42 @@ done:
 static void
 dump_named_datatype(hid_t type, const char *name)
 {
-	int nmembers = 1, x,j;
-	hid_t comptype;
-	char *compname;
-	int ndims, perm[H5DUMP_MAX_RANK];
-	size_t dims[H5DUMP_MAX_RANK];
+    int nmembers = 1, x,j;
+    hid_t comptype;
+    char *compname;
+    int ndims, perm[H5DUMP_MAX_RANK];
+    size_t dims[H5DUMP_MAX_RANK];
 
     indentation(indent);
     begin_obj(dump_header_format->datatypebegin, name,
-			  dump_header_format->datatypeblockbegin);
+	      dump_header_format->datatypeblockbegin);
 
-	if (H5Tget_class(type) == H5T_COMPOUND) {
-		nmembers = H5Tget_nmembers(type);
+    if (H5Tget_class(type) == H5T_COMPOUND) {
+	nmembers = H5Tget_nmembers(type);
 
-		for (x = 0; x < nmembers; x++) {
-			comptype = H5Tget_member_type(type,x);
-			compname = H5Tget_member_name(type,x);
-			ndims = H5Tget_member_dims(type, x, dims, perm);
-		    indentation(indent + COL);
-			print_datatype(comptype);
-			printf(" \"%s\"", compname);
+	for (x = 0; x < nmembers; x++) {
+	    comptype = H5Tget_member_type(type,x);
+	    compname = H5Tget_member_name(type,x);
+	    ndims = H5Tget_member_dims(type, x, dims, perm);
+	    indentation(indent + COL);
+	    print_datatype(comptype);
+	    printf(" \"%s\"", compname);
 
-			if (ndims != 1 || dims[0] != 1)
-				for (j = 0; j < ndims; j++) 
-					printf("[%d]",(int)dims[j]);
+	    if (ndims != 1 || dims[0] != 1)
+		for (j = 0; j < ndims; j++) 
+		    printf("[%d]",(int)dims[j]);
 
-			printf(";\n");		   
-		}
-	} else {
-		indentation(indent + COL);	
-		print_datatype(type);
-		printf(";\n");
+	    printf(";\n");		   
 	}
+    } else {
+	indentation(indent + COL);	
+	print_datatype(type);
+	printf(";\n");
+    }
 
     indentation(indent);
     end_obj(dump_header_format->datatypeend,
-			dump_header_format->datatypeblockend);
+	    dump_header_format->datatypeblockend);
 }
 
 /*-------------------------------------------------------------------------
@@ -1025,29 +1025,29 @@ dump_named_datatype(hid_t type, const char *name)
 static void
 dump_group(hid_t gid, const char *name)
 {
-	H5G_stat_t statbuf;
-	hid_t dset, type;
-	char typename[1024], *tmp;
-	int i;
+    H5G_stat_t statbuf;
+    hid_t dset, type;
+    char typename[1024], *tmp;
+    int i;
 
     tmp = malloc (strlen(prefix) + strlen(name) + 2);
     strcpy(tmp, prefix);
     indentation(indent);
     begin_obj(dump_header_format->groupbegin, name,
-			  dump_header_format->groupblockbegin);
+	      dump_header_format->groupblockbegin);
     indent += COL;
 
-	if (display_oid)
-		dump_oid(gid);
+    if (display_oid)
+	dump_oid(gid);
 
     if (!strcmp(name, "/") && unamedtype)
-		/* dump unamed type in root group */
+	/* dump unamed type in root group */
         for (i = 0; i < type_table->nobjs; i++)
              if (!type_table->objs[i].recorded) {
                  dset = H5Dopen(gid, type_table->objs[i].objname);
                  type = H5Dget_type(dset);
                  sprintf(typename,"#%lu:%lu",
-						 type_table->objs[i].objno[0],
+			 type_table->objs[i].objno[0],
                          type_table->objs[i].objno[1]);
                  dump_named_datatype(type, typename);
                  H5Tclose(type);
@@ -1080,7 +1080,7 @@ dump_group(hid_t gid, const char *name)
     indent -= COL;
     indentation(indent);
     end_obj(dump_header_format->groupend,
-			dump_header_format->groupblockend);
+	    dump_header_format->groupblockend);
     free(tmp);
 }
 
@@ -1099,66 +1099,66 @@ dump_group(hid_t gid, const char *name)
 static void
 dump_dataset(hid_t did, const char *name)
 {
-	hid_t  type, space;
+    hid_t  type, space;
 
     indentation (indent);
     begin_obj(dump_header_format->datasetbegin, name,
-			  dump_header_format->datasetblockbegin);
+	      dump_header_format->datasetblockbegin);
     type = H5Dget_type(did);
     space = H5Dget_space(did);
     dump_datatype(type);
     dump_dataspace(space);
 
-	if (display_oid)
-		dump_oid(did);
+    if (display_oid)
+	dump_oid(did);
 
     if (display_data)
-		switch (H5Tget_class(type)) {
-		case H5T_INTEGER:
-			 dump_data(did, DATASET_DATA);
-			 break;
-
-		case H5T_FLOAT:
-			 dump_data(did, DATASET_DATA);
-			 break;
-
-		case H5T_TIME:
-			 indent += COL;
-			 indentation(indent);
-			 indent -= COL;
-			 printf("DATA{ not yet implemented.}\n");
-			 break;
-
-		case H5T_STRING:
-			 dump_data(did, DATASET_DATA);
-			 break;
-
-		case H5T_BITFIELD:
-			 dump_data(did, DATASET_DATA); 
-			 break;
-
-		case H5T_OPAQUE:
-			/* indent += COL;
-			 indentation (indent);
-			 indent -= COL;*/
-			 dump_data(did, DATASET_DATA);
-			 break;
-
-		case H5T_COMPOUND:
-			 dump_data(did, DATASET_DATA);
-			 break;
-
-		case H5T_REFERENCE:
-			 dump_data(did, DATASET_DATA);
-			 break;
-
-		case H5T_ENUM:
-			 dump_data(did,DATASET_DATA);
-			 break;
-
-		default:
-			 break;
-		}
+	switch (H5Tget_class(type)) {
+	case H5T_INTEGER:
+		 dump_data(did, DATASET_DATA);
+		 break;
+
+	case H5T_FLOAT:
+		 dump_data(did, DATASET_DATA);
+		 break;
+
+	case H5T_TIME:
+		 indent += COL;
+		 indentation(indent);
+		 indent -= COL;
+		 printf("DATA{ not yet implemented.}\n");
+		 break;
+
+	case H5T_STRING:
+		 dump_data(did, DATASET_DATA);
+		 break;
+
+	case H5T_BITFIELD:
+		 dump_data(did, DATASET_DATA); 
+		 break;
+
+	case H5T_OPAQUE:
+		/* indent += COL;
+		 indentation (indent);
+		 indent -= COL;*/
+		 dump_data(did, DATASET_DATA);
+		 break;
+
+	case H5T_COMPOUND:
+		 dump_data(did, DATASET_DATA);
+		 break;
+
+	case H5T_REFERENCE:
+		 dump_data(did, DATASET_DATA);
+		 break;
+
+	case H5T_ENUM:
+		 dump_data(did,DATASET_DATA);
+		 break;
+
+	default:
+		 break;
+	}
 
     indent += COL;
     H5Aiterate(did, NULL, dump_attr, NULL);
@@ -1185,34 +1185,34 @@ dump_dataset(hid_t did, const char *name)
 static void 
 dump_tables(void)
 {
-	int i;
+    int i;
 
     printf("group_table: # of entries = %d\n", group_table->nobjs);
 
     for ( i = 0; i < group_table->nobjs; i++)
         printf ("%ul %ul %s %d %d\n", group_table->objs[i].objno[0],
-                                   group_table->objs[i].objno[1],
-                                   group_table->objs[i].objname,
-                                   group_table->objs[i].displayed,
-                                   group_table->objs[i].recorded);
+		   group_table->objs[i].objno[1],
+		   group_table->objs[i].objname,
+		   group_table->objs[i].displayed,
+		   group_table->objs[i].recorded);
 
     printf("\ndset_table: # of entries = %d\n", dset_table->nobjs);
 
     for ( i = 0; i < dset_table->nobjs; i++)
         printf ("%ul %ul %s %d %d\n", dset_table->objs[i].objno[0],
-                                   dset_table->objs[i].objno[1],
-                                   dset_table->objs[i].objname,
-                                   dset_table->objs[i].displayed,
-                                   dset_table->objs[i].recorded);
+		   dset_table->objs[i].objno[1],
+		   dset_table->objs[i].objname,
+		   dset_table->objs[i].displayed,
+		   dset_table->objs[i].recorded);
    
     printf("\ntype_table: # of entries = %d\n", type_table->nobjs);
 
     for ( i = 0; i < type_table->nobjs; i++)
         printf ("%ul %ul %s %d %d\n", type_table->objs[i].objno[0],
-                                   type_table->objs[i].objno[1],
-                                   type_table->objs[i].objname,
-                                   type_table->objs[i].displayed,
-                                   type_table->objs[i].recorded);
+		   type_table->objs[i].objno[1],
+		   type_table->objs[i].objname,
+		   type_table->objs[i].displayed,
+		   type_table->objs[i].recorded);
 }
 #endif	/* H5DUMP_DEBUG */
 
@@ -1232,74 +1232,75 @@ dump_tables(void)
 static void
 dump_data(hid_t obj_id, int obj_data)
 {
-	h5dump_t *outputformat = &dataformat;
-	int d_status = -1;
-	void *buf;
-	hid_t space, type, p_type;
-	int ndims, i;
-	hsize_t size[64], nelmts = 1;
-	int depth;
-	int stdindent = COL; /* should be 3*/
+    h5dump_t *outputformat = &dataformat;
+    int d_status = -1;
+    void *buf;
+    hid_t space, type, p_type;
+    int ndims, i;
+    hsize_t size[64], nelmts = 1;
+    int depth;
+    int stdindent = COL; /* should be 3*/
 
 
-	outputformat->line_ncols = nCols;
+    outputformat->line_ncols = nCols;
 
     indent += COL;
 
-	/*
-	 * the depth will tell us how far we need to indent extra.  we use to just
-	 * use indent but with the merging of the tools lib we have to do
-	 * something different for the lib funtions... the normal indentation is 6
-	 * so when we don't need any extra indentation, depth will be 0.
-	 */
-	depth = indent / stdindent + 1;
+    /*
+     * the depth will tell us how far we need to indent extra.  we use to just
+     * use indent but with the merging of the tools lib we have to do
+     * something different for the lib funtions... the normal indentation is 6
+     * so when we don't need any extra indentation, depth will be 0.
+     */
+    depth = indent / stdindent + 1;
     indentation(indent);
-	/*printf("%s %s\n", dump_header_format->databegin, BEGIN);*/
-	begin_obj(dump_header_format->databegin, NULL, dump_header_format->datablockbegin);
+    /*printf("%s %s\n", dump_header_format->databegin, BEGIN);*/
+    begin_obj(dump_header_format->databegin, NULL,
+		dump_header_format->datablockbegin);
 
     /* Print all the values. */
-	if (obj_data == DATASET_DATA) {
-		d_status = h5dump_dset(stdout, outputformat, obj_id, -1,depth);
-	} else {
-		/* need to call h5dump_mem for the attribute data */	
-		type = H5Aget_type(obj_id);
+    if (obj_data == DATASET_DATA) {
+	d_status = h5dump_dset(stdout, outputformat, obj_id, -1,depth);
+    } else {
+	/* need to call h5dump_mem for the attribute data */	
+	type = H5Aget_type(obj_id);
 
-		/*
-		if (type < 0)
-			return (d_status);
-		 */
+	/*
+	if (type < 0)
+		return (d_status);
+	 */
 
-		p_type = h5dump_fixtype(type);
-		H5Tclose(type);
+	p_type = h5dump_fixtype(type);
+	H5Tclose(type);
 
-		/*
-		if (p_type < 0)
-			return d_status;
-		 */
+	/*
+	if (p_type < 0)
+		return d_status;
+	 */
 
-		space = H5Aget_space(obj_id);
+	space = H5Aget_space(obj_id);
 
-		/*
-		if (space < 0)
-			return d_status;
-		 */
+	/*
+	if (space < 0)
+		return d_status;
+	 */
 
-		ndims = H5Sget_simple_extent_dims(space, size, NULL);
+	ndims = H5Sget_simple_extent_dims(space, size, NULL);
 
-	    for (i = 0; i < ndims; i++)
-			nelmts *= size[i];
+	for (i = 0; i < ndims; i++)
+	    nelmts *= size[i];
 
-		buf = malloc(nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type)));
-	   	assert(buf);
+	buf = malloc(nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type)));
+	assert(buf);
 
-	    if (H5Aread(obj_id, p_type, buf) >= 0)
-			d_status = h5dump_mem(stdout, outputformat, p_type, space, buf, depth);
+	if (H5Aread(obj_id, p_type, buf) >= 0)
+	    d_status = h5dump_mem(stdout, outputformat, p_type, space, buf, depth);
 
-	    free(buf);
-	    H5Tclose(p_type); 
-		H5Sclose(space);
-		H5Tclose(type);
-	}
+	free(buf);
+	H5Tclose(p_type); 
+	H5Sclose(space);
+	H5Tclose(type);
+    }
 	
     if (d_status < 0) {
         indentation(indent+COL);
@@ -1308,8 +1309,8 @@ dump_data(hid_t obj_id, int obj_data)
     }
 
     indentation(indent);
-	/*printf("%s\n", END);*/
-	end_obj(dump_header_format->dataend, dump_header_format->datablockend);
+    /*printf("%s\n", END);*/
+    end_obj(dump_header_format->dataend, dump_header_format->datablockend);
     indent -= COL;
 }
 
@@ -1337,14 +1338,14 @@ main(int argc, char *argv[])
     H5G_stat_t statbuf;
     void *edata;
     hid_t (*func)(void*);
-	find_objs_t *info = malloc(sizeof(find_objs_t));
+    find_objs_t *info = malloc(sizeof(find_objs_t));
 
     if (argc < 2) {
         usage();
         exit(1);
     }
 
-	dump_header_format = &standardformat;
+    dump_header_format = &standardformat;
 
     /* Disable error reporting */
     H5Eget_auto(&func, &edata);
@@ -1354,51 +1355,52 @@ main(int argc, char *argv[])
     opts[0] = -1;
 
     /* parse command line options */
-    for (curr_arg = 1; curr_arg < argc; curr_arg++) 
-		if (argv[curr_arg][0] == '-') {
-			opts[nopts++] = curr_arg;
-
-			if (!strcmp(argv[curr_arg],"-h")) {
-                usage();
-                free(opts);
-                exit(0);
-            } else if (!strcmp(argv[curr_arg],"-V")) {
-				print_version("h5dump");
-                free(opts);
-                exit(0);
-			} else if (!strcmp(argv[curr_arg],"-bb")) {
-                display_bb = 1;
-			} else if (!strcmp(argv[curr_arg],"-header")) {
-                display_data=0;
-	     	} else if (!strcmp(argv[curr_arg],"-v")) {
-		    	display_oid = 1;
-			} else if (!strcmp(argv[curr_arg],"-w")) {
-				/*
-				 * this way we know which arg was the -w we know it won't be 0
-				 * since curr_arg starts at 1
-				 */
-				newwidth = curr_arg;
-			} else if (!strcmp(argv[curr_arg], "-xml")) {
-				dump_header_format = &xmlformat;
-			} else if (strcmp(argv[curr_arg],"-a") &&
-                      strcmp(argv[curr_arg],"-d") &&
-                      strcmp(argv[curr_arg],"-g") &&
-                      strcmp(argv[curr_arg],"-l") &&
-                      strcmp(argv[curr_arg],"-t")) {
-                fprintf(stderr, "h5dump error: illegal option %s \n", 
-                        argv[curr_arg]);
-                usage();
-                free(opts);
-                exit(1);
-             } else {
-			 	display_all = 0;
-			 }
-         }
+    for (curr_arg = 1; curr_arg < argc; curr_arg++) {
+	if (argv[curr_arg][0] == '-') {
+	    opts[nopts++] = curr_arg;
+
+	    if (!strcmp(argv[curr_arg],"-h")) {
+		usage();
+		free(opts);
+		exit(0);
+	    } else if (!strcmp(argv[curr_arg],"-V")) {
+			print_version("h5dump");
+			free(opts);
+			exit(0);
+	    } else if (!strcmp(argv[curr_arg],"-bb")) {
+			display_bb = 1;
+	    } else if (!strcmp(argv[curr_arg],"-header")) {
+			display_data=0;
+	    } else if (!strcmp(argv[curr_arg],"-v")) {
+			display_oid = 1;
+	    } else if (!strcmp(argv[curr_arg],"-w")) {
+		    /*
+		     * this way we know which arg was the -w we know it won't be 0
+		     * since curr_arg starts at 1
+		     */
+		    newwidth = curr_arg;
+	    } else if (!strcmp(argv[curr_arg], "-xml")) {
+			dump_header_format = &xmlformat;
+	    } else if (strcmp(argv[curr_arg],"-a") &&
+		      strcmp(argv[curr_arg],"-d") &&
+		      strcmp(argv[curr_arg],"-g") &&
+		      strcmp(argv[curr_arg],"-l") &&
+		      strcmp(argv[curr_arg],"-t")) {
+			fprintf(stderr, "h5dump error: illegal option %s \n", 
+					argv[curr_arg]);
+			usage();
+			free(opts);
+			exit(1);
+	    } else {
+		display_all = 0;
+	    }
+	}
+    }
 
     /* check names */
     if (argc == 2) {
         if (opts[0] == 1) {
-			/* argv[1] is an option */
+	    /* argv[1] is an option */
             fprintf(stderr, "h5dump error: no <names> or no <file>\n");
             usage();
             free(opts);
@@ -1406,23 +1408,23 @@ main(int argc, char *argv[])
         }
     } else {
         for (i = 0; i < nopts-1; i++) {
-        	if (opts[i + 1] - opts[i] == 1) {
-            	if (strcmp(argv[opts[i]], "-bb") &&
-                    strcmp(argv[opts[i]], "-header") &&
-					strcmp(argv[opts[i]], "-xml") &&
-					strcmp(argv[opts[i]], "-v")) {
-                	fprintf(stderr,
-							"h5dump error: no <names> after option %s\n",
-                            argv[opts[i]]);
-                    usage();
-                    free(opts);
-                    exit(1);
-                }
-            }
+	    if (opts[i + 1] - opts[i] == 1) {
+		if (strcmp(argv[opts[i]], "-bb") &&
+		    strcmp(argv[opts[i]], "-header") &&
+		    strcmp(argv[opts[i]], "-xml") &&
+		    strcmp(argv[opts[i]], "-v")) {
+			fprintf(stderr,
+				"h5dump error: no <names> after option %s\n",
+				argv[opts[i]]);
+			usage();
+			free(opts);
+			exit(1);
+		}
+	    }
         }
 
         if (argc - opts[nopts - 1] == 1) {
-        	fprintf(stderr,"h5dump error: no <file>\n");
+	    fprintf(stderr,"h5dump error: no <file>\n");
             usage();
             free(opts);
             exit(1);
@@ -1431,11 +1433,11 @@ main(int argc, char *argv[])
         if (argc - opts[nopts - 1] == 2) {
             if (strcmp(argv[opts[i]], "-bb") &&
                 strcmp(argv[opts[i]], "-header") &&
-				strcmp(argv[opts[i]], "-xml") &&
+		strcmp(argv[opts[i]], "-xml") &&
                 strcmp(argv[opts[i]], "-v")) {
                 fprintf(stderr,
-						"h5dump error: no <file> or no <names> "
-						"or no <number> after option %s\n", argv[opts[i]]);
+			"h5dump error: no <file> or no <names> "
+			"or no <number> after option %s\n", argv[opts[i]]);
                 usage();
                 free(opts);
                 exit(1);
@@ -1444,11 +1446,11 @@ main(int argc, char *argv[])
     }
 
     if (argv[argc - 1][0] == '\\')
-		fname = &argv[argc - 1][1];
+	fname = &argv[argc - 1][1];
     else
-		fname = argv[argc - 1];
+	fname = argv[argc - 1];
 
-	fid = h5dump_fopen(fname, NULL, 0);
+    fid = h5dump_fopen(fname, NULL, 0);
 
     if (fid < 0) {
          fprintf(stderr, "h5dump error: unable to open file %s \n", fname);
@@ -1460,17 +1462,17 @@ main(int argc, char *argv[])
     init_table(&group_table);
     init_table(&type_table);
     init_table(&dset_table);
-	init_prefix(&prefix, prefix_len);
-
-	/* init the find_objs_t */
-	info->threshold = 0;
-	info->prefix_len = 1024;
-	info->prefix = malloc(info->prefix_len);
-	info->prefix[0] = '\0';
-	info->group_table = group_table;
-	info->type_table = type_table;
-	info->dset_table = dset_table;
-	info->status = d_status;
+    init_prefix(&prefix, prefix_len);
+
+    /* init the find_objs_t */
+    info->threshold = 0;
+    info->prefix_len = 1024;
+    info->prefix = malloc(info->prefix_len);
+    info->prefix[0] = '\0';
+    info->group_table = group_table;
+    info->type_table = type_table;
+    info->dset_table = dset_table;
+    info->status = d_status;
 
     /* find all shared objects */
     H5Giterate(fid, "/", NULL, find_objs, (void*)info);
@@ -1479,7 +1481,7 @@ main(int argc, char *argv[])
     /* does there exist unamed committed data type */
     for ( i = 0; i < type_table->nobjs; i++)
     	if (type_table->objs[i].recorded == 0)
-			unamedtype = 1;
+	    unamedtype = 1;
 
 #ifdef H5DUMP_DEBUG
     dump_tables();
@@ -1492,13 +1494,13 @@ main(int argc, char *argv[])
 
     /* start to dump */
     begin_obj(dump_header_format->filebegin, fname,
-			  dump_header_format->fileblockbegin);
+	      dump_header_format->fileblockbegin);
 	
     if (display_bb)
-		dump_bb();
+	dump_bb();
 	
-	if (newwidth)
-		sscanf(argv[newwidth + 1], "%d", &nCols);
+    if (newwidth)
+	sscanf(argv[newwidth + 1], "%d", &nCols);
 
     if (display_all) {
         if ((gid = H5Gopen (fid, "/")) < 0 ) {
@@ -1506,184 +1508,186 @@ main(int argc, char *argv[])
             d_status = 1;
         } else {
             dump_group(gid, "/");
-		}
+	}
 
         if (H5Gclose (gid) < 0) {
             fprintf(stdout, "h5dump error: unable to close root group\n");
             d_status = 1;
         }
     } else {
-    	for (i = 0; i < nopts; i++) {
-        	if (!strcmp(argv[opts[i]],"-a")) { 
-            	for (curr_arg = opts[i] + 1;
-                	 curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]);
-                	 curr_arg++)
-                    dump_selected_attr (fid, argv[curr_arg]);
-			} else if (!strcmp(argv[opts[i]],"-d")) {
-           		for (curr_arg = opts[i] + 1; 
-                     curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
-                     curr_arg++) {
-
-                	if ((dsetid = H5Dopen (fid, argv[curr_arg]))<0) {
-                    	begin_obj(dump_header_format->datasetbegin, argv[curr_arg],
-								  dump_header_format->datasetblockbegin); 
-                        indentation(COL);
-                        fprintf(stdout, "h5dump error: unable to open %s\n", 
-                                argv[curr_arg]);
-                        end_obj(dump_header_format->datasetend,
-								dump_header_format->datasetblockend);
-                        d_status = 1;
-                    } else {
-                        H5Gget_objinfo(dsetid, ".", TRUE, &statbuf);
-
-                        if (statbuf.nlink > 1) {
-                            index = search_obj (dset_table, statbuf.objno);
-
-                            if (index >= 0) {
-                            	if (dset_table->objs[index].displayed) {
-                                    begin_obj(dump_header_format->datasetbegin,
-											  argv[curr_arg],
-											  dump_header_format->datasetblockbegin);
-                                    indentation(indent + COL);
-                                    printf("%s \"%s\"\n", HARDLINK,
-                                           dset_table->objs[index].objname);
-                                    indentation(indent);
-                                    end_obj(dump_header_format->datasetend,
-											dump_header_format->datasetblockend);
-                                } else {
-                                    strcpy(dset_table->objs[index].objname,
-										   argv[curr_arg]);
-                                    dset_table->objs[index].displayed = 1;
-                                    dump_dataset(dsetid, argv[curr_arg]);
-                                }
-                             } else {
-								 d_status = 1;
-							 }
-                         } else {
-                             dump_dataset(dsetid, argv[curr_arg]);
-						 }
-
-                         if (H5Dclose(dsetid) < 1)
-							 d_status = 1;
-					}
-				}
-			} else if (!strcmp(argv[opts[i]],"-g")) {
-            	for (curr_arg = opts[i] + 1; 
-                     curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
-                     curr_arg++) {
-                	if ((gid = H5Gopen(fid, argv[curr_arg])) < 0) {
-                    	begin_obj(dump_header_format->groupbegin, argv[curr_arg],
-								  dump_header_format->groupblockbegin); 
-                        indentation(COL);
-                        fprintf(stdout, "h5dump error: unable to open %s\n", 
-                                argv[curr_arg]);
-                        end_obj(dump_header_format->groupend,
-								dump_header_format->groupblockend);
-                        d_status = 1;
-                    } else {
-                        H5Gget_objinfo(gid, ".", TRUE, &statbuf);
-                        strcpy(prefix, argv[curr_arg]);
-                        dump_group(gid, argv[curr_arg]);
-
-                        if (H5Gclose(gid) < 0)
-							d_status = 1;
-                    }
-				}
-			} else if (!strcmp(argv[opts[i]],"-l")) {
-           		for (curr_arg = opts[i] + 1; 
-                     curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
-                     curr_arg++) {
-					if (H5Gget_objinfo(fid, argv[curr_arg], FALSE, &statbuf) < 0) {
-                        begin_obj(dump_header_format->softlinkbegin,
-								  argv[curr_arg],
-								  dump_header_format->softlinkblockbegin);
-                        indentation(COL);
-                        fprintf(stdout,
-								"h5dump error: unable to get obj info from %s\n",
-								argv[curr_arg]);
-                        end_obj(dump_header_format->softlinkend,
-								dump_header_format->softlinkblockend);
-                        d_status = 1;
-                    } else if (statbuf.type == H5G_LINK) {
-                        buf = malloc(statbuf.linklen*sizeof(char));
-                        begin_obj(dump_header_format->softlinkbegin,
-								  argv[curr_arg],
-								  dump_header_format->softlinkblockbegin);
-                        indentation(COL);
-
-                        if (H5Gget_linkval(fid, argv[curr_arg], statbuf.linklen, buf) >= 0) {
-                        	printf("LINKTARGET \"%s\"\n", buf);
-						} else {
-                            fprintf(stdout, "h5dump error: unable to get link value\n");
-                            d_status = 1;
-                        }
-
-                        end_obj(dump_header_format->softlinkend,
-								dump_header_format->softlinkblockend);
-                        free(buf);
-					} else {
-                        begin_obj(dump_header_format->softlinkbegin,
-								  argv[curr_arg],
-								  dump_header_format->softlinkblockbegin);
-                        indentation(COL);
-                        fprintf(stdout, "h5dump error: %s is not a link\n", argv[curr_arg]);
-                        end_obj(dump_header_format->softlinkend,
-								dump_header_format->softlinkblockend);
-                        d_status = 1;
-                    }
-				}
-			} else if (!strcmp(argv[opts[i]],"-t")) {
-                for (curr_arg = opts[i] + 1; 
-                     curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
-                     curr_arg++) {
-                	if ((typeid = H5Topen(fid, argv[curr_arg])) < 0) {
-                        /* check if argv[curr_arg] is unamed data type */
-                        index = 0;
-
-                        while (index < type_table->nobjs ) {
-                        	if (!type_table->objs[index].recorded) { /* unamed data type */
-                            	sprintf(name, "#%lu:%lu\n",
-										type_table->objs[index].objno[0], 
-                                        type_table->objs[index].objno[1]);
-                                sprintf(name1, "/#%lu:%lu\n",
-										type_table->objs[index].objno[0], 
-                                        type_table->objs[index].objno[1]);
-
-                                if (!strncmp(name, argv[curr_arg], strlen(argv[curr_arg])) || 
-                                    !strncmp(name1, argv[curr_arg], strlen(argv[curr_arg])))
-                                      break;
-                            } 
-
-                            index++;
-						}
-
-                        if (index ==  type_table->nobjs) {
-							/* unknown type */
-                        	begin_obj(dump_header_format->datatypebegin, argv[curr_arg],
-									  dump_header_format->datatypeblockbegin); 
-                            indentation(COL);
-                            fprintf(stdout, "h5dump error: unable to open %s\n", 
-                                    argv[curr_arg]);
-                            end_obj(dump_header_format->datatypeend,
-									dump_header_format->datatypeblockend);
-                            d_status = 1;
-                        } else {
-                            dsetid = H5Dopen(fid, type_table->objs[index].objname);
-                            typeid = H5Dget_type(dsetid);
-                            dump_named_datatype(typeid, argv[curr_arg]);
-                            H5Tclose(typeid);
-                            H5Dclose(dsetid);
-                        }
-					} else {
-                        dump_named_datatype(typeid, argv[curr_arg]);
-
-                        if (H5Tclose(typeid) < 0)
-							d_status = 1;
-                    }
+	for (i = 0; i < nopts; i++) {
+	    if (!strcmp(argv[opts[i]],"-a")) { 
+		for (curr_arg = opts[i] + 1;
+		     curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]);
+		     curr_arg++)
+			dump_selected_attr (fid, argv[curr_arg]);
+	    } else if (!strcmp(argv[opts[i]],"-d")) {
+		for (curr_arg = opts[i] + 1; 
+		     curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
+		     curr_arg++) {
+
+			if ((dsetid = H5Dopen (fid, argv[curr_arg]))<0) {
+			    begin_obj(dump_header_format->datasetbegin, argv[curr_arg],
+				      dump_header_format->datasetblockbegin); 
+			    indentation(COL);
+			    fprintf(stdout, "h5dump error: unable to open %s\n", 
+				argv[curr_arg]);
+			    end_obj(dump_header_format->datasetend,
+				    dump_header_format->datasetblockend);
+			    d_status = 1;
+			} else {
+			    H5Gget_objinfo(dsetid, ".", TRUE, &statbuf);
+
+			    if (statbuf.nlink > 1) {
+				index = search_obj (dset_table, statbuf.objno);
+
+				if (index >= 0) {
+				    if (dset_table->objs[index].displayed) {
+					begin_obj(dump_header_format->datasetbegin,
+						  argv[curr_arg],
+						  dump_header_format->datasetblockbegin);
+					indentation(indent + COL);
+					printf("%s \"%s\"\n", HARDLINK,
+					       dset_table->objs[index].objname);
+					indentation(indent);
+					end_obj(dump_header_format->datasetend,
+						dump_header_format->datasetblockend);
+				    } else {
+					strcpy(dset_table->objs[index].objname,
+					       argv[curr_arg]);
+					dset_table->objs[index].displayed = 1;
+					dump_dataset(dsetid, argv[curr_arg]);
+				    }
+				} else {
+				    d_status = 1;
 				}
+			    } else {
+				dump_dataset(dsetid, argv[curr_arg]);
+			    }
+
+			    if (H5Dclose(dsetid) < 1)
+				d_status = 1;
+			}
+		}
+	    } else if (!strcmp(argv[opts[i]],"-g")) {
+		for (curr_arg = opts[i] + 1; 
+		    curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
+		    curr_arg++)
+		{
+		    if ((gid = H5Gopen(fid, argv[curr_arg])) < 0) {
+			begin_obj(dump_header_format->groupbegin, argv[curr_arg],
+				  dump_header_format->groupblockbegin); 
+			indentation(COL);
+			fprintf(stdout, "h5dump error: unable to open %s\n", 
+				argv[curr_arg]);
+			end_obj(dump_header_format->groupend,
+				dump_header_format->groupblockend);
+			d_status = 1;
+		    } else {
+			H5Gget_objinfo(gid, ".", TRUE, &statbuf);
+			strcpy(prefix, argv[curr_arg]);
+			dump_group(gid, argv[curr_arg]);
+
+			if (H5Gclose(gid) < 0)
+			    d_status = 1;
+		    }
+		}
+	    } else if (!strcmp(argv[opts[i]],"-l")) {
+		for (curr_arg = opts[i] + 1; 
+		    curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
+		    curr_arg++)
+		{
+		    if (H5Gget_objinfo(fid, argv[curr_arg], FALSE, &statbuf) < 0) {
+			begin_obj(dump_header_format->softlinkbegin,
+				  argv[curr_arg],
+				  dump_header_format->softlinkblockbegin);
+			indentation(COL);
+			fprintf(stdout, "h5dump error: unable to get obj info from %s\n",
+				argv[curr_arg]);
+			end_obj(dump_header_format->softlinkend,
+				dump_header_format->softlinkblockend);
+			d_status = 1;
+		    } else if (statbuf.type == H5G_LINK) {
+			buf = malloc(statbuf.linklen*sizeof(char));
+			begin_obj(dump_header_format->softlinkbegin,
+				  argv[curr_arg],
+				  dump_header_format->softlinkblockbegin);
+			indentation(COL);
+
+			if (H5Gget_linkval(fid, argv[curr_arg], statbuf.linklen, buf) >= 0) {
+			    printf("LINKTARGET \"%s\"\n", buf);
+			} else {
+			    fprintf(stdout, "h5dump error: unable to get link value\n");
+			    d_status = 1;
 			}
+
+			end_obj(dump_header_format->softlinkend,
+				dump_header_format->softlinkblockend);
+			free(buf);
+		    } else {
+			begin_obj(dump_header_format->softlinkbegin,
+				  argv[curr_arg],
+				  dump_header_format->softlinkblockbegin);
+			indentation(COL);
+			fprintf(stdout, "h5dump error: %s is not a link\n", argv[curr_arg]);
+			end_obj(dump_header_format->softlinkend,
+				dump_header_format->softlinkblockend);
+			d_status = 1;
+		    }
 		}
+	    } else if (!strcmp(argv[opts[i]],"-t")) {
+		for (curr_arg = opts[i] + 1; 
+		    curr_arg < ((i + 1) == nopts ? (argc - 1) : opts[i + 1]); 
+		    curr_arg++)
+		{
+		    if ((typeid = H5Topen(fid, argv[curr_arg])) < 0) {
+			/* check if argv[curr_arg] is unamed data type */
+			index = 0;
+
+			while (index < type_table->nobjs ) {
+			    if (!type_table->objs[index].recorded) { /* unamed data type */
+			    sprintf(name, "#%lu:%lu\n",
+				    type_table->objs[index].objno[0], 
+				    type_table->objs[index].objno[1]);
+			    sprintf(name1, "/#%lu:%lu\n",
+				    type_table->objs[index].objno[0], 
+				    type_table->objs[index].objno[1]);
+
+			    if (!strncmp(name, argv[curr_arg], strlen(argv[curr_arg])) || 
+				!strncmp(name1, argv[curr_arg], strlen(argv[curr_arg])))
+				  break;
+			    } 
+
+			    index++;
+			}
+
+			if (index ==  type_table->nobjs) {
+			    /* unknown type */
+			    begin_obj(dump_header_format->datatypebegin, argv[curr_arg],
+				      dump_header_format->datatypeblockbegin); 
+			    indentation(COL);
+			    fprintf(stdout, "h5dump error: unable to open %s\n", 
+				    argv[curr_arg]);
+			    end_obj(dump_header_format->datatypeend,
+				    dump_header_format->datatypeblockend);
+			    d_status = 1;
+			} else {
+			    dsetid = H5Dopen(fid, type_table->objs[index].objname);
+			    typeid = H5Dget_type(dsetid);
+			    dump_named_datatype(typeid, argv[curr_arg]);
+			    H5Tclose(typeid);
+			    H5Dclose(dsetid);
+			}
+		    } else {
+			dump_named_datatype(typeid, argv[curr_arg]);
+
+			if (H5Tclose(typeid) < 0)
+			    d_status = 1;
+		    }
+		}
+	    }
 	}
+    }
 
     end_obj(dump_header_format->fileend, dump_header_format->fileblockend);
 
@@ -1692,14 +1696,14 @@ done:
     free(opts);
 
     if (H5Fclose(fid) < 0)
-		d_status = 1;
+	d_status = 1;
 
     free(group_table->objs);
     free(dset_table->objs);
     free(type_table->objs);
     free(prefix);
-	free(info->prefix);
-	free(info);
+    free(info->prefix);
+    free(info);
     return d_status;
 }
 
@@ -1720,20 +1724,20 @@ done:
 static void
 print_enum(hid_t type)
 {
-    char	**name = NULL;		/*member names					*/
-    unsigned char *value = NULL;/*value array					*/
-    int		nmembs;				/*number of members				*/
-    int		nchars;				/*number of output characters	*/
-    hid_t	super;				/*enum base integer type		*/
-    hid_t	native = -1;		/*native integer data type		*/
-    size_t	dst_size;			/*destination value type size	*/
-    int		i;					/*miscellaneous counters		*/
+    char	**name = NULL;		/*member names			*/
+    unsigned char *value = NULL;	/*value array			*/
+    int		nmembs;			/*number of members		*/
+    int		nchars;			/*number of output characters	*/
+    hid_t	super;			/*enum base integer type	*/
+    hid_t	native = -1;		/*native integer data type	*/
+    size_t	dst_size;		/*destination value type size	*/
+    int		i;			/*miscellaneous counters	*/
     size_t	j;	
  
-	nmembs =  H5Tget_nmembers(type);
+    nmembs =  H5Tget_nmembers(type);
     super = H5Tget_super(type);
 
-	/*
+    /*
      * Determine what data type to use for the native values.  To simplify
      * things we entertain three possibilities:
      *  1. long_long -- the largest native signed integer
@@ -1741,15 +1745,15 @@ print_enum(hid_t type)
      *	3. raw format
      */
     if (H5Tget_size(type)<=sizeof(long_long)) {
-		dst_size = sizeof(long_long);
+	dst_size = sizeof(long_long);
 
-		if (H5T_SGN_NONE==H5Tget_sign(type)) {
-			native = H5T_NATIVE_ULLONG;
-		} else {
-			native = H5T_NATIVE_LLONG;
-		}
+	if (H5T_SGN_NONE==H5Tget_sign(type)) {
+	    native = H5T_NATIVE_ULLONG;
+	} else {
+	    native = H5T_NATIVE_LLONG;
+	}
     } else {
-		dst_size = H5Tget_size(type);
+	dst_size = H5Tget_size(type);
     }
 
     /* Get the names and raw values of all members */
@@ -1757,52 +1761,52 @@ print_enum(hid_t type)
     value = calloc(nmembs, MAX(H5Tget_size(type), dst_size));
 
     for (i = 0; i < nmembs; i++) {
-		name[i] = H5Tget_member_name(type, i);
-		H5Tget_member_value(type, i, value + i * H5Tget_size(type));
+	name[i] = H5Tget_member_name(type, i);
+	H5Tget_member_value(type, i, value + i * H5Tget_size(type));
     }
 
     /* Convert values to native data type */
     if (native > 0)
-		H5Tconvert(super, native, nmembs, value, NULL, H5P_DEFAULT);
+	H5Tconvert(super, native, nmembs, value, NULL, H5P_DEFAULT);
 
     /* Sort members by increasing value */
     /*not implemented yet*/
 
     /* Print members */
     for (i = 0; i < nmembs; i++) {
-		printf("\n%*s", indent + 4, "");
-		nchars = printf("\"%s\"", name[i]);/*display_string(stdout, name[i], TRUE);*/
-		printf("%*s   ", MAX(0, 16 - nchars), "");
-
-		if (native < 0) {
-			printf("0x");
-
-			for (j = 0; j < dst_size; j++)
-				printf("%02x", value[i * dst_size + j]);
-		} else if (H5T_SGN_NONE == H5Tget_sign(native)) {
-			printf("%" PRINTF_LL_WIDTH "u",
-					*((unsigned long_long *)((void *)(value + i * dst_size))));
-		} else {
-			printf("%" PRINTF_LL_WIDTH "d",
-					*((long_long *)((void *)(value + i * dst_size))));
-		}
+	printf("\n%*s", indent + 4, "");
+	nchars = printf("\"%s\"", name[i]);/*display_string(stdout, name[i], TRUE);*/
+	printf("%*s   ", MAX(0, 16 - nchars), "");
+
+	if (native < 0) {
+	    printf("0x");
+
+	    for (j = 0; j < dst_size; j++)
+		printf("%02x", value[i * dst_size + j]);
+	} else if (H5T_SGN_NONE == H5Tget_sign(native)) {
+		printf("%" PRINTF_LL_WIDTH "u",
+			*((unsigned long_long *)((void *)(value + i * dst_size))));
+	} else {
+		printf("%" PRINTF_LL_WIDTH "d",
+			*((long_long *)((void *)(value + i * dst_size))));
+	}
 
-		printf(";");
+	printf(";");
     }
 
     /* Release resources */
     for (i = 0; i < nmembs; i++)
-		free(name[i]);
+	free(name[i]);
 
     free(name);
     free(value);
     H5Tclose(super);
 
     if (0 == nmembs)
-		printf("\n%*s <empty>", indent+4, "");
+	printf("\n%*s <empty>", indent+4, "");
 
-	/*printf("\n%*s}", indent, "");*/
-	/*return TRUE;*/
+    /*printf("\n%*s}", indent, "");*/
+    /*return TRUE;*/
 }
 
 /*-------------------------------------------------------------------------
@@ -1824,7 +1828,7 @@ dump_oid(hid_t oid)
     indentation(indent);
 
     printf("%s %s ", OBJID, BEGIN);
-	printf("%d", oid);
+    printf("%d", oid);
     printf(" %s\n", END);  
-	indent -= COL;
+    indent -= COL;
 }
diff --git a/tools/h5dump.h b/tools/h5dump.h
index af7b348..6e4c54f 100644
--- a/tools/h5dump.h
+++ b/tools/h5dump.h
@@ -5,13 +5,13 @@
 
 #define H5DUMP_MAX_RANK		H5S_MAX_RANK
 
-#define begin_obj(obj,name,begin)											\
-	if (name)																\
-		printf("%s \"%s\" %s\n", (obj), (name), (begin));					\
-	else																	\
+#define begin_obj(obj,name,begin)					\
+	if (name)							\
+		printf("%s \"%s\" %s\n", (obj), (name), (begin));	\
+	else								\
 		printf("%s %s\n", (obj), (begin));
 
-#define end_obj(obj,end)													\
+#define end_obj(obj,end)						\
 	printf("%s %s\n", (end), (obj));
 
 #endif	/* H5DUMP_H__ */