[svn-r145] ./src/H5Osdtyp.c -> H5Odtype.c

./src/H5Osdim.c		-> H5Osdspace.c
./src/Makefile.in
	Changed the names of these files to better reflect what they
	actually do.

./src/H5.c
./src/H5AC.c
./src/H5B.c
./src/H5C.c
./src/H5D.c
./src/H5E.c
./src/H5Eprivate.h
./src/H5Epublic.h
./src/H5F.c
./src/H5Fcore.c
./src/H5Ffamily.c
./src/H5Fistore.c
./src/H5Flow.c
./src/H5Fsec2.c
./src/H5Fsplit.c
./src/H5Fstdio.c
./src/H5G.c
./src/H5Gent.c
./src/H5Gnode.c
./src/H5Gshad.c
./src/H5Gstab.c
./src/H5H.c
./src/H5M.c
./src/H5MF.c
./src/H5O.c
./src/H5Osdtyp.c (./src/H5Odtype.c)
./src/H5P.c
./src/H5T.c
./src/H5detect.c
./src/H5private.h
	Added an argument to the HRETURN_ERROR(), HGOTO_ERROR(), and
	HERROR() macros which is a string error message.  This allows
	us to give extra information which can't be represented by the
	major and minor error numbers.  This information was
	previously in comments just before or after the macro call.
	The string isn't currently used, but I'm planning to change
	the test files so they print an error trace when something
	fails.  This should make debugging a little faster since it's
	often obvious what's wrong if we could just see the error
	stack without even having to start a debugger.

1 files changed, 864 insertions, 0 deletions

diff --git a/src/H5Odtype.c b/src/H5Odtype.c
new file mode 100644
index 0000000..e6f4c03
--- /dev/null
+++ b/src/H5Odtype.c
@@ -0,0 +1,864 @@
+/****************************************************************************
+* NCSA HDF                                                                 *
+* Software Development Group                                               *
+* National Center for Supercomputing Applications                          *
+* University of Illinois at Urbana-Champaign                               *
+* 605 E. Springfield, Champaign IL 61820                                   *
+*                                                                          *
+* For conditions of distribution and use, see the accompanying             *
+* hdf/COPYING file.                                                        *
+*                                                                          *
+****************************************************************************/
+
+#ifdef RCSID
+static char RcsId[] = "@(#)$Revision$";
+#endif
+
+/* $Id$ */
+
+#define H5T_PACKAGE	/*prevent warning from including H5Tpkg.h	*/
+
+#include <H5private.h>
+#include <H5Eprivate.h>
+#include <H5Gprivate.h>
+#include <H5MMprivate.h>
+#include <H5Oprivate.h>
+#include <H5Tpkg.h>
+
+#define PABLO_MASK	H5O_dtype_mask
+
+/* PRIVATE PROTOTYPES */
+static herr_t H5O_dtype_encode (H5F_t *f, size_t raw_size, uint8 *p,
+				const void *mesg);
+static void *H5O_dtype_decode (H5F_t *f, size_t raw_size, const uint8 *p);
+static void *H5O_dtype_copy (const void *_mesg, void *_dest);
+static size_t H5O_dtype_size (H5F_t *f, const void *_mesg);
+static herr_t H5O_dtype_reset (void *_mesg);
+static herr_t H5O_dtype_debug (H5F_t *f, const void *_mesg,
+			       FILE *stream, intn indent, intn fwidth);
+
+/* This message derives from H5O */
+const H5O_class_t H5O_DTYPE[1] = {{
+   H5O_DTYPE_ID,		    	/* message id number		*/
+   "data_type",				/* message name for debugging	*/
+   sizeof (H5T_t),			/* native message size		*/
+   H5G_NOTHING_CACHED, 			/* symtab entry `type' field	*/
+   H5O_dtype_decode,			/* decode message		*/
+   H5O_dtype_encode,			/* encode message		*/
+   NULL,				/* get message from stab entry	*/
+   NULL,				/* put message into stab entry	*/
+   H5O_dtype_copy,			/* copy the native value 	*/
+   H5O_dtype_size,			/* size of raw message		*/
+   H5O_dtype_reset,			/* reset method 		*/
+   H5O_dtype_debug,			/* debug the message 		*/
+}};
+
+/* Interface initialization */
+static hbool_t interface_initialize_g = FALSE;
+#define INTERFACE_INIT	NULL
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5O_dtype_decode_helper
+ *
+ * Purpose:	Decodes a data type
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Monday, December  8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5O_dtype_decode_helper (const uint8 **pp, H5T_t *dt)
+{
+   uintn	flags, perm_word;
+   intn		i, j;
+   
+   FUNC_ENTER (H5O_dtype_decode_helper, FAIL);
+
+   /* check args */
+   assert (pp && *pp);
+   assert (dt);
+
+   /* decode */
+   UINT32DECODE (*pp, flags);
+   dt->type = flags & 0xff;
+   flags >>= 8;
+   UINT32DECODE (*pp, dt->size);
+
+   switch (dt->type) {
+   case H5T_FIXED:
+      /*
+       * Fixed-point types...
+       */
+      dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+      dt->u.atomic.lo_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+      dt->u.atomic.hi_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+      dt->u.atomic.u.i.sign = (flags & 0x8) ? H5T_SGN_2 : H5T_SGN_NONE;
+      UINT16DECODE (*pp, dt->u.atomic.offset);
+      UINT16DECODE (*pp, dt->u.atomic.prec);
+      break;
+
+   case H5T_FLOAT:
+      /*
+       * Floating-point types...
+       */
+      dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+      dt->u.atomic.lo_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+      dt->u.atomic.hi_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+      dt->u.atomic.u.f.pad = (flags & 0x8) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+      switch ((flags>>4) & 0x03) {
+      case 0:
+	 dt->u.atomic.u.f.norm = H5T_NORM_NONE;
+	 break;
+      case 1:
+	 dt->u.atomic.u.f.norm = H5T_NORM_MSBSET;
+	 break;
+      case 2:
+	 dt->u.atomic.u.f.norm = H5T_NORM_IMPLIED;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"unknown floating-point normalization");
+      }
+      dt->u.atomic.u.f.sign = (flags>>8) & 0xff;
+      UINT16DECODE (*pp, dt->u.atomic.offset);
+      UINT16DECODE (*pp, dt->u.atomic.prec);
+      dt->u.atomic.u.f.epos = *(*pp)++;
+      dt->u.atomic.u.f.esize = *(*pp)++;
+      assert (dt->u.atomic.u.f.esize>0);
+      dt->u.atomic.u.f.mpos = *(*pp)++;
+      dt->u.atomic.u.f.msize = *(*pp)++;
+      assert (dt->u.atomic.u.f.msize>0);
+      UINT32DECODE (*pp, dt->u.atomic.u.f.ebias);
+      break;
+
+   case H5T_COMPOUND:
+      /*
+       * Compound data types...
+       */
+      dt->u.compnd.nmembs = flags & 0xffff;
+      assert (dt->u.compnd.nmembs>0);
+      dt->u.compnd.nalloc = dt->u.compnd.nmembs;
+      dt->u.compnd.memb = H5MM_xcalloc (dt->u.compnd.nalloc,
+					sizeof(H5T_member_t));
+      for (i=0; i<dt->u.compnd.nmembs; i++) {
+	 dt->u.compnd.memb[i].name = H5MM_xstrdup (*pp);
+	 *pp += ((strlen (*pp)+8)/8) * 8; /*multiple of 8 w/ null terminator*/
+	 UINT32DECODE (*pp, dt->u.compnd.memb[i].offset);
+	 dt->u.compnd.memb[i].ndims = *(*pp)++;
+	 assert (dt->u.compnd.memb[i].ndims<=4);
+	 *pp += 3; /*reserved bytes*/
+	 for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
+	    UINT32DECODE (*pp, dt->u.compnd.memb[i].dim[j]);
+	 }
+	 UINT32DECODE (*pp, perm_word);
+	 dt->u.compnd.memb[i].perm[0] = (perm_word >>  0) & 0xff;
+	 dt->u.compnd.memb[i].perm[1] = (perm_word >>  8) & 0xff;
+	 dt->u.compnd.memb[i].perm[2] = (perm_word >> 16) & 0xff;
+	 dt->u.compnd.memb[i].perm[3] = (perm_word >> 24) & 0xff;
+	 if (H5O_dtype_decode_helper (pp, &(dt->u.compnd.memb[i].type))<0 ||
+	     H5T_COMPOUND==dt->u.compnd.memb[i].type.type) {
+	    for (j=0; j<=i; j++) H5MM_xfree (dt->u.compnd.memb[i].name);
+	    H5MM_xfree (dt->u.compnd.memb);
+	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTDECODE, FAIL,
+			   "can't decode member type");
+	 }
+      }
+      break;
+      
+   default:
+      if (flags) {
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"class flags are non-zero");
+      }
+      break;
+   }
+   
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5O_dtype_encode_helper
+ *
+ * Purpose:	Encodes a data type.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Monday, December  8, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
+{
+   uintn	flags = 0;
+   uintn	perm_word;
+   char		*hdr = *pp;
+   intn		i, j, n;
+   
+   FUNC_ENTER (H5O_dtype_encode_helper, FAIL);
+
+   /* check args */
+   assert (pp && *pp);
+   assert (dt);
+
+   /* skip the type and class bit field for now */
+   *pp += 4;
+   UINT32ENCODE (*pp, dt->size);
+
+   switch (dt->type) {
+   case H5T_FIXED:
+      /*
+       * Fixed-point data types...
+       */
+      switch (dt->u.atomic.order) {
+      case H5T_ORDER_LE:
+	 break; /*nothing*/
+      case H5T_ORDER_BE:
+	 flags |= 0x01;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"byte order is not supported in file format yet");
+      }
+
+      switch (dt->u.atomic.lo_pad) {
+      case H5T_PAD_ZERO:
+	 break; /*nothing*/
+      case H5T_PAD_ONE:
+	 flags |= 0x02;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
+      }
+      
+      switch (dt->u.atomic.hi_pad) {
+      case H5T_PAD_ZERO:
+	 break; /*nothing*/
+      case H5T_PAD_ONE:
+	 flags |= 0x04;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
+      }
+
+      switch (dt->u.atomic.u.i.sign) {
+      case H5T_SGN_NONE:
+	 break; /*nothing*/
+      case H5T_SGN_2:
+	 flags |= 0x08;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"sign scheme is not supported in file format yet");
+      }
+      
+      UINT16ENCODE (*pp, dt->u.atomic.offset);
+      UINT16ENCODE (*pp, dt->u.atomic.prec);
+      break;
+
+   case H5T_FLOAT:
+      /*
+       * Floating-point types...
+       */
+      switch (dt->u.atomic.order) {
+      case H5T_ORDER_LE:
+	 break; /*nothing*/
+      case H5T_ORDER_BE:
+	 flags |= 0x01;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"byte order is not supported in file format yet");
+      }
+
+      switch (dt->u.atomic.lo_pad) {
+      case H5T_PAD_ZERO:
+	 break; /*nothing*/
+      case H5T_PAD_ONE:
+	 flags |= 0x02;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
+      }
+      
+      switch (dt->u.atomic.hi_pad) {
+      case H5T_PAD_ZERO:
+	 break; /*nothing*/
+      case H5T_PAD_ONE:
+	 flags |= 0x04;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
+      }
+      
+      switch (dt->u.atomic.u.f.pad) {
+      case H5T_PAD_ZERO:
+	 break; /*nothing*/
+      case H5T_PAD_ONE:
+	 flags |= 0x08;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
+      }
+
+      switch (dt->u.atomic.u.f.norm) {
+      case H5T_NORM_NONE:
+	 break; /*nothing*/
+      case H5T_NORM_MSBSET:
+	 flags |= 0x10;
+	 break;
+      case H5T_NORM_IMPLIED:
+	 flags |= 0x20;
+	 break;
+      default:
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"normalization scheme is not supported in file "
+			"format yet");
+      }
+
+      flags |= (dt->u.atomic.u.f.sign << 8) & 0xff00;
+      UINT16ENCODE (*pp, dt->u.atomic.offset);
+      UINT16ENCODE (*pp, dt->u.atomic.prec);
+      *(*pp)++ = dt->u.atomic.u.f.epos;
+      *(*pp)++ = dt->u.atomic.u.f.esize;
+      *(*pp)++ = dt->u.atomic.u.f.mpos;
+      *(*pp)++ = dt->u.atomic.u.f.msize;
+      UINT32ENCODE (*pp, dt->u.atomic.u.f.ebias);
+      break;
+
+   case H5T_COMPOUND:
+      /*
+       * Compound data types...
+       */
+      flags = dt->u.compnd.nmembs & 0xffff;
+      for (i=0; i<dt->u.compnd.nmembs; i++) {
+	 n = strlen (dt->u.compnd.memb[i].name);
+	 for (j=0; j<=n && j%8; j++) {
+	    if (j<n) *(*pp)++ = dt->u.compnd.memb[i].name[j];
+	    else *(*pp)++ = '\0';
+	 }
+	 UINT32ENCODE (*pp, dt->u.compnd.memb[i].offset);
+	 *(*pp)++ = dt->u.compnd.memb[i].ndims;
+	 assert (dt->u.compnd.memb[i].ndims<=4);
+	 *(*pp)++ = '\0';
+	 *(*pp)++ = '\0';
+	 *(*pp)++ = '\0';
+	 for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
+	    UINT32ENCODE (*pp, dt->u.compnd.memb[i].dim[j]);
+	 }
+	 for (j=0, perm_word=0; j<dt->u.compnd.memb[i].ndims; j++) {
+	    perm_word |= dt->u.compnd.memb[i].perm[j] << (8*j);
+	 }
+	 UINT32ENCODE (*pp, perm_word);
+	 if (H5O_dtype_encode_helper (pp, &(dt->u.compnd.memb[i].type))<0) {
+	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTENCODE, FAIL,
+			   "can't encode member type");
+	 }
+      }
+      break;
+
+   default:
+      /*nothing*/
+      break;
+   }
+
+   *hdr++ = dt->type;
+   *hdr++ = (flags >>  0) & 0xff;
+   *hdr++ = (flags >>  8) & 0xff;
+   *hdr++ = (flags >> 16) & 0xff;
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_dtype_decode
+ PURPOSE
+    Decode a datatype message and return a pointer to a memory struct
+        with the decoded information
+ USAGE
+    void *H5O_dtype_decode(f, raw_size, p)
+        H5F_t *f;               IN: pointer to the HDF5 file struct
+        size_t raw_size;        IN: size of the raw information buffer
+        const uint8 *p;         IN: the raw information buffer
+ RETURNS
+    Pointer to the new message in native order on success, NULL on failure
+ DESCRIPTION
+        This function decodes the "raw" disk form of a simple datatype message
+    into a struct in memory native format.  The struct is allocated within this
+    function using malloc() and is returned to the caller.
+--------------------------------------------------------------------------*/
+static void *
+H5O_dtype_decode (H5F_t *f, size_t raw_size, const uint8 *p)
+{
+   H5T_t	*dt = NULL;
+   
+   FUNC_ENTER (H5O_dtype_decode, NULL);
+
+   /* check args */
+   assert (f);
+   assert (raw_size>0);
+   assert (p);
+
+   dt = H5MM_xcalloc (1, sizeof(H5T_t));
+
+   if (H5O_dtype_decode_helper (&p, dt)<0) {
+      H5MM_xfree (dt);
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTDECODE, NULL,
+		     "can't decode type");
+   }
+   assert (raw_size==H5O_dtype_size (f, (void*)dt));
+   
+   FUNC_LEAVE (dt);
+}
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_dtype_encode
+ PURPOSE
+    Encode a simple datatype message 
+ USAGE
+    herr_t H5O_dtype_encode(f, raw_size, p, mesg)
+        H5F_t *f;         IN: pointer to the HDF5 file struct
+        size_t raw_size;        IN: size of the raw information buffer
+        const uint8 *p;         IN: the raw information buffer
+        const void *mesg;       IN: Pointer to the simple datatype struct
+ RETURNS
+    SUCCEED/FAIL
+ DESCRIPTION
+        This function encodes the native memory form of the simple datatype
+    message in the "raw" disk form.
+--------------------------------------------------------------------------*/
+static herr_t
+H5O_dtype_encode (H5F_t *f, size_t raw_size, uint8 *p, const void *mesg)
+{
+   const H5T_t		*dt = (const H5T_t *)mesg;
+
+   FUNC_ENTER (H5O_dtype_encode, FAIL);
+
+   /* check args */
+   assert (f);
+   assert (raw_size==H5O_dtype_size (f, mesg));
+   assert (p);
+   assert (dt);
+
+   /* encode */
+   if (H5O_dtype_encode_helper (&p, dt)<0) {
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTENCODE, FAIL,
+		     "can't encode type");
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_dtype_copy
+ PURPOSE
+    Copies a message from MESG to DEST, allocating DEST if necessary.
+ USAGE
+    void *H5O_dtype_copy(mesg, dest)
+        const void *mesg;       IN: Pointer to the source simple datatype
+ 				    struct 
+  	const void *dest;       IN: Pointer to the destination simple
+ 				    datatype struct 
+ RETURNS
+    Pointer to DEST on success, NULL on failure
+ DESCRIPTION
+        This function copies a native (memory) simple datatype message,
+    allocating the destination structure if necessary.
+--------------------------------------------------------------------------*/
+static void *
+H5O_dtype_copy (const void *_src, void *_dst)
+{
+   const H5T_t	*src = (const H5T_t *)_src;
+   H5T_t	*dst = NULL;
+   
+   FUNC_ENTER (H5O_dtype_copy, NULL);
+
+   /* check args */
+   assert (src);
+
+   /* copy */
+   if (NULL==(dst=H5T_copy (src))) {
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL, "can't copy type");
+   }
+   
+   /* was result already allocated? */
+   if (_dst) {
+      *((H5T_t*)_dst) = *dst;
+      H5MM_xfree (dst);
+      dst = (H5T_t*)_dst;
+   }
+
+   FUNC_LEAVE ((void*)dst);
+}
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_dtype_size
+ PURPOSE
+    Return the raw message size in bytes
+ USAGE
+    void *H5O_dtype_size(f, mesg)
+        H5F_t *f;         IN: pointer to the HDF5 file struct
+        const void *mesg;     IN: Pointer to the source simple datatype struct
+ RETURNS
+    Size of message on success, FAIL on failure
+ DESCRIPTION
+        This function returns the size of the raw simple datatype message on
+    success.  (Not counting the message type or size fields, only the data
+    portion of the message).  It doesn't take into account alignment.
+--------------------------------------------------------------------------*/
+static size_t
+H5O_dtype_size (H5F_t *f, const void *mesg)
+{
+   intn		i;
+   size_t	ret_value = 8;
+   const H5T_t	*dt = (const H5T_t *)mesg;
+   
+   FUNC_ENTER (H5O_dtype_size, FAIL);
+
+   assert (mesg);
+
+   switch (dt->type) {
+   case H5T_FIXED:
+      ret_value += 4;
+      break;
+
+   case H5T_FLOAT:
+      ret_value += 12;
+      break;
+
+   case H5T_COMPOUND:
+      for (i=0; i<dt->u.compnd.nmembs; i++) {
+	 ret_value += ((HDstrlen (dt->u.compnd.memb[i].name)+8)/8)*8;
+	 ret_value += 12 + dt->u.compnd.memb[i].ndims * 4;
+	 ret_value += H5O_dtype_size (f, &(dt->u.compnd.memb[i].type));
+      }
+      break;
+
+   default:
+      /*no properties*/
+      break;
+   }
+   
+
+   FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5O_dtype_reset
+ *
+ * Purpose:	Frees resources within a data type message, but doesn't free
+ *		the message itself.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5O_dtype_reset (void *_mesg)
+{
+   H5T_t	*dt = (H5T_t *)_mesg;
+   H5T_t	*tmp = NULL;
+   
+   FUNC_ENTER (H5O_dtype_reset, FAIL);
+
+   if (dt) {
+      tmp = H5MM_xmalloc (sizeof(H5T_t));
+      *tmp = *dt;
+      H5T_close (tmp);
+      HDmemset (dt, 0, sizeof(H5T_t));
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_dtype_debug
+ PURPOSE
+    Prints debugging information for a data type message
+ USAGE
+    void *H5O_dtype_debug(f, mesg, stream, indent, fwidth)
+        H5F_t *f;               IN: pointer to the HDF5 file struct
+        const void *mesg;       IN: Pointer to the source simple datatype
+ 				    struct
+        FILE *stream;           IN: Pointer to the stream for output data
+        intn indent;            IN: Amount to indent information by
+        intn fwidth;            IN: Field width (?)
+ RETURNS
+    SUCCEED/FAIL
+ DESCRIPTION
+        This function prints debugging output to the stream passed as a 
+    parameter.
+--------------------------------------------------------------------------*/
+static herr_t
+H5O_dtype_debug (H5F_t *f, const void *mesg, FILE *stream,
+		intn indent, intn fwidth)
+{
+   const H5T_t	*dt = (const H5T_t *)mesg;
+   const char	*s;
+   char		buf[256];
+   intn		i, j;
+   
+   FUNC_ENTER (H5O_dtype_debug, FAIL);
+
+   /* check args */
+   assert (f);
+   assert (dt);
+   assert (stream);
+   assert (indent>=0);
+   assert (fwidth>=0);
+
+   switch (dt->type) {
+   case H5T_FIXED:
+      s = "fixed-point";
+      break;
+   case H5T_FLOAT:
+      s = "floating-point";
+      break;
+   case H5T_DATE:
+      s = "date and time";
+      break;
+   case H5T_STRING:
+      s = "text string";
+      break;
+   case H5T_BITFIELD:
+      s = "bit field";
+      break;
+   case H5T_OPAQUE:
+      s = "opaque";
+      break;
+   case H5T_COMPOUND:
+      s = "compound";
+      break;
+   default:
+      sprintf (buf, "H5T_CLASS_%d", (int)(dt->type));
+      s = buf;
+      break;
+   }
+   fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+	    "Type class:",
+	    s);
+
+   fprintf (stream, "%*s%-*s %lu byte%s\n", indent, "", fwidth,
+	    "Size:",
+	    (unsigned long)(dt->size), 1==dt->size?"":"s");
+
+   if (H5T_COMPOUND==dt->type) {
+      fprintf (stream, "%*s%-*s %d\n", indent, "", fwidth,
+	       "Number of members:",
+	       dt->u.compnd.nmembs);
+      for (i=0; i<dt->u.compnd.nmembs; i++) {
+	 sprintf (buf, "Member %d:", i);
+	 fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+		  buf,
+		  dt->u.compnd.memb[i].name);
+	 fprintf (stream, "%*s%-*s %lu\n", indent+3, "", MAX (0, fwidth-3),
+		  "Byte offset:",
+		  (unsigned long)(dt->u.compnd.memb[i].offset));
+	 fprintf (stream, "%*s%-*s %d%s\n", indent+3, "", MAX (0, fwidth-3),
+		  "Dimensionality:",
+		  dt->u.compnd.memb[i].ndims,
+		  0==dt->u.compnd.memb[i].ndims?" (scalar)":"");
+	 if (dt->u.compnd.memb[i].ndims>0) {
+	    fprintf (stream, "%*s%-*s {", indent+3, "", MAX (0, fwidth-3),
+		     "Size:");
+	    for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
+	       fprintf (stream, "%s%lu", j?", ":"",
+			(unsigned long)(dt->u.compnd.memb[i].dim[j]));
+	    }
+	    fprintf (stream, "}\n");
+	    fprintf (stream, "%*s%-*s {", indent+3, "", MAX (0, fwidth-3),
+		     "Permutation:");
+	    for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
+	       fprintf (stream, "%s%lu", j?", ":"",
+			(unsigned long)(dt->u.compnd.memb[i].perm[j]));
+	    }
+	    fprintf (stream, "}\n");
+	 }
+	 H5O_dtype_debug (f, &(dt->u.compnd.memb[i].type), stream,
+			  indent+3, MAX (0, fwidth-3));
+      }
+   } else {
+      switch (dt->u.atomic.order) {
+      case H5T_ORDER_LE:
+	 s = "little endian";
+	 break;
+      case H5T_ORDER_BE:
+	 s = "big endian";
+	 break;
+      case H5T_ORDER_VAX:
+	 s = "VAX";
+	 break;
+      case H5T_ORDER_NONE:
+	 s = "none";
+	 break;
+      default:
+	 sprintf (buf, "H5T_ORDER_%d", dt->u.atomic.order);
+	 s = buf;
+	 break;
+      }
+      fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+	       "Byte order:",
+	       s);
+      
+      fprintf (stream, "%*s%-*s %lu bit%s\n", indent, "", fwidth,
+	       "Precision:",
+	       (unsigned long)(dt->u.atomic.prec),
+	       1==dt->u.atomic.prec?"":"s");
+
+      fprintf (stream, "%*s%-*s %lu bit%s\n", indent, "", fwidth,
+	       "Offset:",
+	       (unsigned long)(dt->u.atomic.offset),
+	       1==dt->u.atomic.offset?"":"s");
+
+      switch (dt->u.atomic.lo_pad) {
+      case H5T_PAD_ZERO:
+	 s = "zero";
+	 break;
+      case H5T_PAD_ONE:
+	 s = "one";
+	 break;
+      default:
+	 if (dt->u.atomic.lo_pad<0) {
+	    sprintf (buf, "H5T_PAD_%d", -(dt->u.atomic.lo_pad));
+	 } else {
+	    sprintf (buf, "bit-%d", dt->u.atomic.lo_pad);
+	 }
+	 s = buf;
+	 break;
+      }
+      fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+	       "Low pad type:", s);
+
+      switch (dt->u.atomic.hi_pad) {
+      case H5T_PAD_ZERO:
+	 s = "zero";
+	 break;
+      case H5T_PAD_ONE:
+	 s = "one";
+	 break;
+      default:
+	 if (dt->u.atomic.hi_pad<0) {
+	    sprintf (buf, "H5T_PAD_%d", -(dt->u.atomic.hi_pad));
+	 } else {
+	    sprintf (buf, "bit-%d", dt->u.atomic.hi_pad);
+	 }
+	 s = buf;
+	 break;
+      }
+      fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+	       "High pad type:", s);
+
+      if (H5T_FLOAT==dt->type) {
+	 switch (dt->u.atomic.u.f.pad) {
+	 case H5T_PAD_ZERO:
+	    s = "zero";
+	    break;
+	 case H5T_PAD_ONE:
+	    s = "one";
+	    break;
+	 default:
+	    if (dt->u.atomic.u.f.pad<0) {
+	       sprintf (buf, "H5T_PAD_%d", -(dt->u.atomic.u.f.pad));
+	    } else {
+	       sprintf (buf, "bit-%d", dt->u.atomic.u.f.pad);
+	    }
+	    s = buf;
+	    break;
+	 }
+	 fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+		  "Internal pad type:", s);
+
+	 switch (dt->u.atomic.u.f.norm) {
+	 case H5T_NORM_IMPLIED:
+	    s = "implied";
+	    break;
+	 case H5T_NORM_MSBSET:
+	    s = "msb set";
+	    break;
+	 case H5T_NORM_NONE:
+	    s = "none";
+	    break;
+	 default:
+	    sprintf (buf, "H5T_NORM_%d", (int)(dt->u.atomic.u.f.norm));
+	    s = buf;
+	 }
+	 fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+		  "Normalization:", s);
+	 
+	 fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+		  "Sign bit location:",
+		  (unsigned long)(dt->u.atomic.u.f.sign));
+
+	 fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+		  "Exponent location:",
+		  (unsigned long)(dt->u.atomic.u.f.epos));
+
+	 fprintf (stream, "%*s%-*s 0x%08lx\n", indent, "", fwidth,
+		  "Exponent bias:",
+		  (unsigned long)(dt->u.atomic.u.f.ebias));
+
+	 fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+		  "Exponent size:",
+		  (unsigned long)(dt->u.atomic.u.f.esize));
+
+	 fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+		  "Mantissa location:",
+		  (unsigned long)(dt->u.atomic.u.f.mpos));
+
+	 fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+		  "Mantissa size:",
+		  (unsigned long)(dt->u.atomic.u.f.msize));
+	 
+      } else if (H5T_FIXED==dt->type) {
+	 switch (dt->u.atomic.u.i.sign) {
+	 case H5T_SGN_NONE:
+	    s = "none";
+	    break;
+	 case H5T_SGN_2:
+	    s = "2's comp";
+	    break;
+	 default:
+	    sprintf (buf, "H5T_SGN_%d", (int)(dt->u.atomic.u.i.sign));
+	    s = buf;
+	    break;
+	 }
+	 fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+		  "Sign scheme:", s);
+	 
+      }
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}