[svn-r41] Interim checkpoint of dataset code for Robb to look at.

7 files changed, 896 insertions, 11 deletions

diff --git a/src/H5Apublic.h b/src/H5Apublic.h
index a987a62..3823b28 100644
--- a/src/H5Apublic.h
+++ b/src/H5Apublic.h
@@ -31,6 +31,7 @@ typedef enum {
    H5_DATATYPE,                 /* Group ID for Datatype objects */
    H5_DATASPACE,                /* Group ID for Dataspace objects */
    H5_DATASET,                  /* Group ID for Dataset objects */
+   H5_DIRECTORY,                /* Group ID for Directory objects */
    MAXGROUP                     /* Highest group in group_t (Invalid as true group) */
 } group_t;
 
diff --git a/src/H5D.c b/src/H5D.c
index b2abb70..5c93840 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -142,7 +142,7 @@ done:
 --------------------------------------------------------------------------*/
 herr_t H5Dset_info(hatom_t oid, hatom_t tid, hatom_t did)
 {
-    H5D_dataset_t *dataset;         /* dataset object to release */
+    H5D_dataset_t *dataset;         /* dataset object to modify */
     herr_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Dset_info, H5D_init_interface, FAIL);
@@ -236,7 +236,7 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5Dset_info() */
+} /* end H5Dwrite() */
 
 /*--------------------------------------------------------------------------
  NAME
@@ -256,9 +256,6 @@ done:
 herr_t H5D_flush(hatom_t oid)
 {
     H5D_dataset_t *dataset;         /* dataset object to release */
-#ifdef QUINCEY
-    H5F_
-#endif
     herr_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5D_flush, H5D_init_interface, FAIL);
@@ -275,20 +272,66 @@ herr_t H5D_flush(hatom_t oid)
         /* Check if we need to create the dataset header and insert the dataset in the file's hierarchy */
         if(dataset->header==0)
           {
+            H5G_entry_t d_sym;
             H5F_root_symtype_t root_type=H5F_root_type(dataset->file);
+            hdf5_file_t *file;
+            group_t dset_parent=H5Aatom_group(dataset->parent);
+
+            /* Get the dataset's file... (I'm not fond of this. -QAK) */
+            if((file=H5Aatom_object(dataset->file))==NULL)
+                HGOTO_ERROR(H5E_INTERNAL, H5E_BADATOM, FAIL);
 
             /* Flush object header, etc. to the file... */
             if(root_type==H5F_ROOT_ERROR)
                 HGOTO_ERROR(H5E_SYM, H5E_BADVALUE, FAIL);
-            if(root_type==H5F_ROOT_DATASET || H5F_ROOT_UNKNOWN)
+
+            /* construct dataset symbol-table entry */
+            d_sym.name_off=0;
+            /* allocate the dataset's object header */
+            if((d_sym.header=H5O_new(file, 1, 0))<0)
+                HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+            d_sym.type=H5G_NOTHING_CACHED;
+            dataset->header=d_sym.header;
+
+            /* Insert dataset into parent directory, if there is one */
+            if(dset_parent!=H5_FILE ||
+                    (dset_parent==H5_FILE && root_type==H5F_ROOT_DIRECTORY))
               {
+                uintn namelen;  /* length of parent directory's name */
+                char *name;     /* pointer to parent directory's name */
+
+                /* Get the name of the parent directory */
+                if((namelen=H5Mname_len(dataset->parent))==UFAIL)
+                    HGOTO_ERROR(H5E_DIRECTORY, H5E_BADVALUE, FAIL);
+                if((name=HDmalloc(namelen+1))==NULL);
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
+                if(H5Mget_name(dataset->parent,name)==FAIL)
+                    HGOTO_ERROR(H5E_DIRECTORY, H5E_NOTFOUND, FAIL);
+
+                /* Insert the dataset into the parent directory */
+                if(H5G_insert (file, NULL, name, dataset->name, &d_sym)==FAIL)
+                    HGOTO_ERROR(H5E_DIRECTORY, H5E_CANTINSERT, FAIL);
+                HDfree(name);
               } /* end if */
-            else
+            else    /* insert dataset as root-object, or into root-directory */
               {
-#ifdef QUINCEY
-                if(root_type
-#endif
-              } /* end if */
+                if(root_type==H5F_ROOT_DATASET || H5F_ROOT_UNKNOWN)
+                  {
+                    /* Make the root directory and stuff the dataset into it */
+                    if(H5G_mkroot (file, H5G_DEFAULT_ROOT_SIZE)==FAIL)
+                        HGOTO_ERROR(H5E_DIRECTORY, H5E_CANTCREATE, FAIL);
+                    if(H5G_insert (file, NULL, NULL, dataset->name, &d_sym)==FAIL)
+                        HGOTO_ERROR(H5E_DIRECTORY, H5E_CANTINSERT, FAIL);
+                  } /* end if */
+                else
+                  {
+                    /* Set the root of the file to point to the dataset */
+                    if(root_type==H5F_ROOT_NONE)
+                        H5G_set_root(file, dataset->name, &d_sym);
+                  } /* end else */
+              } /* end else */
+            
+            /* Add the appropriate messages for the dataset */
           } /* end if */
       } /* end if */
 
diff --git a/src/H5G.c b/src/H5G.c
index 24583a7..bea4a9a 100644
--- a/src/H5G.c
+++ b/src/H5G.c
@@ -557,6 +557,53 @@ H5G_insert (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
    FUNC_LEAVE (SUCCEED);
 }
    
+/*--------------------------------------------------------------------------
+ NAME
+    H5G_set_root
+ PURPOSE
+    Inserts symbol table ENT as the file's root object giving it the specified
+    NAME.  NAME is not allowed to be relative.
+ USAGE
+    herr_t H5G_set_root(f, name, ent)
+        hatom_t f;          IN: File to set root entry
+        const char *name;   IN: Root object's name
+        H5G_entry_t *ent;   IN: Root object's symbol-table entry
+ RETURNS
+    SUCCEED/FAIL
+ DESCRIPTION
+        This function sets the root object of a file to be the symbol-table
+    table passed as an argument.  The primary function of this routine is to
+    make a dataset the root object of a file.  (The dataset may be replaced
+    with a "real" root directory, but at this point, the dataset is the only
+    object in the file)
+--------------------------------------------------------------------------*/
+herr_t
+H5G_set_root (hdf5_file_t *f, const char *name, H5G_entry_t *ent)
+{
+   herr_t	status;
+   const char	*rest=NULL;
+   H5G_entry_t	_parent;
+   size_t	nchars;
+   char		_comp[1024];
+   
+   FUNC_ENTER (H5G_set_root, NULL, FAIL);
+
+   /* check args */
+   assert (f);
+   assert (name && *name);
+   assert (ent);
+
+   /* lookup base-name */
+   if(HDstrlen(rest = H5G_basename (name, NULL))<=0)
+      HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, FAIL); /* invalid base name */
+   H5ECLEAR; 
+
+   /* insert entry as root object */
+   HDmemcpy(file->root_sym,ent,sizeof(H5G_entry_t));
+      
+   FUNC_LEAVE (SUCCEED);
+}
+   
 
 /*-------------------------------------------------------------------------
  * Function:	H5G_modify
diff --git a/src/H5Gpublic.h b/src/H5Gpublic.h
index 797b16a..049c823 100644
--- a/src/H5Gpublic.h
+++ b/src/H5Gpublic.h
@@ -21,6 +21,9 @@
 /* Public headers needed by this file */
 #include <H5public.h>
 
+/* Default root directory size */
+#define H5G_DEFAULT_ROOT SIZE   256
+
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 65d76db..34acff9 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -124,6 +124,33 @@ typedef struct H5O_stab_t {
    haddr_t	heap;			/*address of name heap		*/
 } H5O_stab_t;
 
+/*
+ * Simple Datatype message.
+ */
+#define H5O_SIM_DTYPE_ID	0x0003
+extern const H5O_class_t H5O_SIM_DTYPE[1];
+
+typedef struct {
+    uint8 length;   /* Number of bytes */
+    uint8 arch;     /* Architecture format of the data */
+    hatom_t type;   /* Type of the data */
+} H5O_sim_dtype_t;
+
+/*
+ * Simple Dimensionality message.
+ */
+#define H5O_SIM_DIM_ID	0x0001
+extern const H5O_class_t H5O_SIM_DIM[1];
+
+typedef struct {
+    uint32 rank;        /* Number of dimensions */
+    uint32 dim_flags;   /* Dimension flags */
+    uint32 *size;       /* Dimension sizes */
+    uint32 *max;        /* Maximum dimension sizes */
+    uint32 *perm;       /* Dimension permutations */
+} H5O_sim_dim_t;
+
+
 
 haddr_t H5O_new (hdf5_file_t *f, intn nlink, size_t size_hint);
 intn H5O_link (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent, intn adjust);
diff --git a/src/H5Osdim.c b/src/H5Osdim.c
new file mode 100644
index 0000000..a5f3e29
--- /dev/null
+++ b/src/H5Osdim.c
@@ -0,0 +1,400 @@
+/****************************************************************************
+* 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$ */
+
+/*LINTLIBRARY */
+/*+
+   FILE
+       H5Osdim.c
+   HDF5 Simple Dimensionality Object Header Message routines
+
+   EXPORTED ROUTINES
+
+   LIBRARY-SCOPED ROUTINES
+
+   LOCAL ROUTINES
+   + */
+
+#include <H5private.h>
+#include <H5Eprivate.h>
+#include <H5Gprivate.h>
+#include <H5MMprivate.h>
+#include <H5Oprivate.h>
+
+#define PABLO_MASK	H5O_sim_dim_mask
+
+/* PRIVATE PROTOTYPES */
+static void *H5O_sim_dim_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p);
+static herr_t H5O_sim_dim_encode (hdf5_file_t *f, size_t size, uint8 *p,
+			       const void *_mesg);
+static void *H5O_sim_dim_fast (const H5G_entry_t *ent, void *_mesg);
+static hbool_t H5O_sim_dim_cache (H5G_entry_t *ent, const void *_mesg);
+static void *H5O_sim_dim_copy (const void *_mesg, void *_dest);
+static size_t H5O_sim_dim_size (hdf5_file_t *f, const void *_mesg);
+static herr_t H5O_sim_dim_debug (hdf5_file_t *f, const void *_mesg,
+			      FILE *stream, intn indent, intn fwidth);
+
+/* This message derives from H5O */
+const H5O_class_t H5O_SIM_DIM[1] = {{
+   H5O_SIM_DIM_ID,          /* message id number */
+   "sim_dim",               /* message name for debugging */
+   sizeof (H5O_sim_dim_t),  /* native message size */
+   H5O_sim_dim_decode,      /* decode message */
+   H5O_sim_dim_encode,      /* encode message */
+   H5O_sim_dim_fast,        /* get message from stab entry */
+   H5O_sim_dim_cache,       /* put message into stab entry */
+   H5O_sim_dim_copy,        /* copy the native value */
+   H5O_sim_dim_size,        /* size of symbol table entry */
+   NULL,                    /* default reset method */
+   H5O_sim_dim_debug,       /* debug the message */
+}};
+
+/* Is the interface initialized? */
+static hbool_t interface_initialize_g = FALSE;
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dim_decode
+ PURPOSE
+    Decode a simple dimensionality message and return a pointer to a memory
+        struct with the decoded information
+ USAGE
+    void *H5O_sim_dim_decode(f, raw_size, p)
+        hdf5_file_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 dimensionality
+    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_sim_dim_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p)
+{
+    H5O_sim_dim_t *sdim=NULL;   /* New simple dimensionality structure */
+    uintn u;                    /* local counting variable */
+   
+    FUNC_ENTER (H5O_sim_dim_decode, NULL, NULL);
+
+    /* check args */
+    assert (f);
+    assert (raw_size >= 8); /* at least the rank and flags must be present */
+    assert (p);
+
+    /* decode */
+    if((sdim = H5MM_xcalloc (1, sizeof(H5O_sim_dim_t)))!=NULL)
+      {
+        UINT32DECODE(p,sdim->rank);
+        UINT32DECODE(p,sdim->dim_flags);
+        if(sdim->rank>0)
+          {
+            sdim->size=H5MM_xmalloc(sizeof(uint32)*sdim->rank);
+            for(u=0; u<sdim->size; u++)
+                UINT32DECODE(p,sdim->size[u]);
+            if(sdim->dim_flags&0x01)
+              {
+                sdim->max=H5MM_xmalloc(sizeof(uint32)*sdim->rank);
+                for(u=0; u<sdim->size; u++)
+                    UINT32DECODE(p,sdim->max[u]);
+              } /* end if */
+            if(sdim->dim_flags&0x02)
+              {
+                sdim->perm=H5MM_xmalloc(sizeof(uint32)*sdim->rank);
+                for(u=0; u<sdim->size; u++)
+                    UINT32DECODE(p,sdim->perm[u]);
+              } /* end if */
+          } /* end if */
+      } /* end if */
+
+done:
+  if(sdim == NULL)   
+    { /* Error condition cleanup */
+
+    } /* end if */
+
+    /* Normal function cleanup */
+
+    FUNC_LEAVE (sdim);
+} /* end H5O_sim_dim_decode() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dim_encode
+ PURPOSE
+    Encode a simple dimensionality message 
+ USAGE
+    herr_t H5O_sim_dim_encode(f, raw_size, p, mesg)
+        hdf5_file_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 dimensionality struct
+ RETURNS
+    SUCCEED/FAIL
+ DESCRIPTION
+        This function encodes the native memory form of the simple
+    dimensionality message in the "raw" disk form.
+--------------------------------------------------------------------------*/
+static herr_t
+H5O_sim_dim_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *mesg)
+{
+    const H5O_sim_dim_t *sdim = (const H5O_sim_dim_t *)mesg;
+    uintn u;        /* Local counting variable */
+
+    FUNC_ENTER (H5O_sim_dim_encode, NULL, FAIL);
+
+    /* check args */
+    assert (f);
+    assert (raw_size >= 8); /* at least the rank & flags must be present */
+    assert (p);
+    assert (sdtype);
+
+    /* encode */
+    UINT32ENCODE(p,sdim->rank);
+    UINT32ENCODE(p,sdim->dim_flags);
+    if(sdim->rank>0)
+      {
+        for(u=0; u<=sdim->rank; u++);
+            UINT32ENCODE(p,sdim->size[u]);
+        if(sdim->dim_flags&0x01)
+          {
+            for(u=0; u<=sdim->rank; u++);
+                UINT32ENCODE(p,sdim->max[u]);
+          } /* end if */
+      } /* end if */
+
+    FUNC_LEAVE (SUCCEED);
+} /* end H5O_sim_dtype_encode() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_fast
+ PURPOSE
+    Initializes a new simple datatype struct with info from a symbol table
+        entry.
+ USAGE
+    void *H5O_sim_dtype_fast(ent, mesg)
+        const H5G_entry_t *ent; IN: pointer to the symbol table entry
+        const void *mesg;       IN: Pointer to the simple datatype struct
+ RETURNS
+    Pointer to the message structure (allocated if none is supplied) on success,
+        NULL on failure
+ DESCRIPTION
+        This function fills the native memory form of the simple datatype
+    message from a symbol-table entry cache fields.  (This method is required
+    for simple datatypes, as they can be cached in the symbol-table entry)
+--------------------------------------------------------------------------*/
+static void *
+H5O_sim_dtype_fast (const H5G_entry_t *ent, void *mesg)
+{
+   H5O_sim_dtype_t *sdtype = (H5O_sim_dtype_t *)mesg;
+   const uint8 *p;
+   
+   FUNC_ENTER (H5O_sim_dtype_fast, NULL, NULL);
+
+   /* check args */
+   assert (ent);
+
+   if (H5G_CACHED_SDATA==ent->type)
+     {
+      if (!sdtype)
+          if((sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)))!=NULL)
+            {
+              p=&(uint8 *)ent->cache.sdata.nt;
+              sdtype->length=*p++;
+              sdtype->arch=*p++;
+              UINT16DECODE(p,sdtype->type);
+            } /* end if */
+     } /* end if */
+   else
+      sdtype = NULL;
+
+   FUNC_LEAVE (sdtype);
+} /* end H5O_sim_dtype_fast() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_cache
+ PURPOSE
+    Copies a simple datatype message into the cache portion of a symbol table
+        entry.
+ USAGE
+    hbool_t H5O_sim_dtype_cache(ent, mesg)
+        const H5G_entry_t *ent; IN: Pointer to the symbol table entry
+        const void *mesg;       IN: Pointer to the simple datatype struct
+ RETURNS
+    BTRUE if symbol-table modified, BFALSE if not modified, BFAIL on failure.
+ DESCRIPTION
+        This function is the opposite of the H5O_sim_dtype_fast method, it
+    copies a message into the cached portion of a symbol-table entry.  (This
+    method is required for simple datatypes, as they can be cached in the
+    symbol-table entry)
+--------------------------------------------------------------------------*/
+static hbool_t
+H5O_sim_dtype_cache (H5G_entry_t *ent, const void *mesg)
+{
+    const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg;
+    const uint8 *p;
+    hbool_t modified = BFALSE;
+   
+    FUNC_ENTER (H5O_sim_dtype_cache, NULL, BFAIL);
+
+    /* check args */
+    assert (ent);
+    assert (sdtype);
+
+    /*
+     * We do this in two steps so Purify doesn't complain about
+     * uninitialized memory reads even though they don't bother
+     * anything.
+     */
+    p=(uint8 *)&(ent->cache.sdata);
+    if (H5G_CACHED_SDATA != ent->type)
+      {
+        modified = BTRUE;
+        ent->type = H5G_CACHED_SDATA;
+        *p++=sdtype->length;
+        *p++=sdtype->arch;
+        UINT16ENCODE(p,sdtype->type);
+      } /* end if */
+    else
+      {
+        if(ent->cache.sdata.length= sdtype->length)
+          {
+            modified = BTRUE;
+            ent->cache.sdata.length = sdtype->length;
+          } /* end if */
+
+        if (ent->cache.sdata.arch != sdtype->arch)
+          {
+           modified = BTRUE;
+           ent->cache.sdata.arch = sdtype->arch;
+          } /* end if */
+
+        if (ent->cache.sdata.type != sdtype->type)
+          {
+           modified = BTRUE;
+           ent->cache.sdata.type = sdtype->type;
+          } /* end if */
+      } /* end else */
+
+    FUNC_LEAVE (modified);
+} /* end H5O_sim_dtype_cache() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_copy
+ PURPOSE
+    Copies a message from MESG to DEST, allocating DEST if necessary.
+ USAGE
+    void *H5O_sim_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_sim_dtype_copy (const void *mesg, void *dest)
+{
+   const H5O_sim_dtype_t	*src = (const H5O_sim_dtype_t *)mesg;
+   H5O_sim_dtype_t		*dst = (H5O_sim_dtype_t *)dest;
+   
+   FUNC_ENTER (H5O_sim_dtype_copy, NULL, NULL);
+
+   /* check args */
+   assert (src);
+   if (!dst) dst = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t));
+
+   /* copy */
+   HDmempcy(dst,src,sizeof(H5O_sim_dtype_t));
+
+   FUNC_LEAVE ((void*)dst);
+} /* end H5O_sim_dtype_copy() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_size
+ PURPOSE
+    Return the raw message size in bytes
+ USAGE
+    void *H5O_sim_dtype_copy(f, mesg)
+        hdf5_file_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_sim_dtype_size (hdf5_file_t *f, const void *mesg)
+{
+   FUNC_ENTER (H5O_sim_dtype_size, NULL, FAIL);
+   FUNC_LEAVE (4);
+} /* end H5O_sim_dtype_size() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_debug
+ PURPOSE
+    Prints debugging information for a simple datatype message
+ USAGE
+    void *H5O_sim_dtype_debug(f, mesg, stream, indent, fwidth)
+        hdf5_file_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_sim_dtype_debug (hdf5_file_t *f, const void *mesg, FILE *stream,
+		intn indent, intn fwidth)
+{
+   const H5O_sim_dtype_t	*sdtype = (const H5O_sim_dtype_t *)mesg;
+   
+   FUNC_ENTER (H5O_sim_dtype_debug, NULL, FAIL);
+
+   /* check args */
+   assert (f);
+   assert (sdtype);
+   assert (stream);
+   assert (indent>=0);
+   assert (fwidth>=0);
+
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Length:",
+	    (unsigned long)(sdtype->length));
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Architecture:",
+	    (unsigned long)(sdtype->arch));
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Data-Type:",
+	    (unsigned long)(sdtype->type));
+
+   FUNC_LEAVE (SUCCEED);
+} /* end H5O_sim_dtype_debug() */
+
diff --git a/src/H5Osdtyp.c b/src/H5Osdtyp.c
new file mode 100644
index 0000000..3c881a1
--- /dev/null
+++ b/src/H5Osdtyp.c
@@ -0,0 +1,364 @@
+/****************************************************************************
+* 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$ */
+
+/*LINTLIBRARY */
+/*+
+   FILE
+       H5Osdtyp.c
+   HDF5 Simple Datatype Object Header Message routines
+
+   EXPORTED ROUTINES
+
+   LIBRARY-SCOPED ROUTINES
+
+   LOCAL ROUTINES
+   + */
+
+#include <H5private.h>
+#include <H5Eprivate.h>
+#include <H5Gprivate.h>
+#include <H5MMprivate.h>
+#include <H5Oprivate.h>
+
+#define PABLO_MASK	H5O_sim_dtype_mask
+
+/* PRIVATE PROTOTYPES */
+static void *H5O_sim_dtype_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p);
+static herr_t H5O_sim_dtype_encode (hdf5_file_t *f, size_t size, uint8 *p,
+			       const void *_mesg);
+static void *H5O_sim_dtype_fast (const H5G_entry_t *ent, void *_mesg);
+static hbool_t H5O_sim_dtype_cache (H5G_entry_t *ent, const void *_mesg);
+static void *H5O_sim_dtype_copy (const void *_mesg, void *_dest);
+static size_t H5O_sim_dtype_size (hdf5_file_t *f, const void *_mesg);
+static herr_t H5O_sim_dtype_debug (hdf5_file_t *f, const void *_mesg,
+			      FILE *stream, intn indent, intn fwidth);
+
+/* This message derives from H5O */
+const H5O_class_t H5O_SIM_DTYPE[1] = {{
+   H5O_SIM_DTYPE_ID,		    /* message id number */
+   "sim_dtype",				    /* message name for debugging */
+   sizeof (H5O_sim_dtype_t),	/* native message size */
+   H5O_sim_dtype_decode,		/* decode message */
+   H5O_sim_dtype_encode,		/* encode message */
+   H5O_sim_dtype_fast,			/* get message from stab entry */
+   H5O_sim_dtype_cache,			/* put message into stab entry */
+   H5O_sim_dtype_copy,			/* copy the native value */
+   H5O_sim_dtype_size,			/* size of symbol table entry */
+   NULL,				        /* default reset method */
+   H5O_sim_dtype_debug,			/* debug the message */
+}};
+
+/* Is the interface initialized? */
+static hbool_t interface_initialize_g = FALSE;
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_decode
+ PURPOSE
+    Decode a simple datatype message and return a pointer to a memory struct
+        with the decoded information
+ USAGE
+    void *H5O_sim_dtype_decode(f, raw_size, p)
+        hdf5_file_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_sim_dtype_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p)
+{
+    H5O_sim_dtype_t	*sdtype;
+   
+    FUNC_ENTER (H5O_sim_dtype_decode, NULL, NULL);
+
+    /* check args */
+    assert (f);
+    assert (raw_size == 4);
+    assert (p);
+
+    /* decode */
+    if((sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)))!=NULL)
+      {
+        sdtype->length=*p++;
+        sdtype->arch=*p++;
+        UINT16DECODE(p,sdtype->type);
+      } /* end if */
+
+    FUNC_LEAVE (sdtype);
+} /* end H5O_sim_dtype_decode() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_encode
+ PURPOSE
+    Encode a simple datatype message 
+ USAGE
+    herr_t H5O_sim_dtype_encode(f, raw_size, p, mesg)
+        hdf5_file_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_sim_dtype_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *mesg)
+{
+    const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg;
+
+    FUNC_ENTER (H5O_sim_dtype_encode, NULL, FAIL);
+
+    /* check args */
+    assert (f);
+    assert (raw_size == 4);
+    assert (p);
+    assert (sdtype);
+
+    /* encode */
+    *p++=sdtype->length;
+    *p++=sdtype->arch;
+    UINT16ENCODE(p,sdtype->type);
+
+    FUNC_LEAVE (SUCCEED);
+} /* end H5O_sim_dtype_encode() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_fast
+ PURPOSE
+    Initializes a new simple datatype struct with info from a symbol table
+        entry.
+ USAGE
+    void *H5O_sim_dtype_fast(ent, mesg)
+        const H5G_entry_t *ent; IN: pointer to the symbol table entry
+        const void *mesg;       IN: Pointer to the simple datatype struct
+ RETURNS
+    Pointer to the message structure (allocated if none is supplied) on success,
+        NULL on failure
+ DESCRIPTION
+        This function fills the native memory form of the simple datatype
+    message from a symbol-table entry cache fields.  (This method is required
+    for simple datatypes, as they can be cached in the symbol-table entry)
+--------------------------------------------------------------------------*/
+static void *
+H5O_sim_dtype_fast (const H5G_entry_t *ent, void *mesg)
+{
+   H5O_sim_dtype_t *sdtype = (H5O_sim_dtype_t *)mesg;
+   const uint8 *p;
+   
+   FUNC_ENTER (H5O_sim_dtype_fast, NULL, NULL);
+
+   /* check args */
+   assert (ent);
+
+   if (H5G_CACHED_SDATA==ent->type)
+     {
+      if (!sdtype)
+          if((sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)))!=NULL)
+            {
+              p=&(uint8 *)ent->cache.sdata.nt;
+              sdtype->length=*p++;
+              sdtype->arch=*p++;
+              UINT16DECODE(p,sdtype->type);
+            } /* end if */
+     } /* end if */
+   else
+      sdtype = NULL;
+
+   FUNC_LEAVE (sdtype);
+} /* end H5O_sim_dtype_fast() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_cache
+ PURPOSE
+    Copies a simple datatype message into the cache portion of a symbol table
+        entry.
+ USAGE
+    hbool_t H5O_sim_dtype_cache(ent, mesg)
+        const H5G_entry_t *ent; IN: Pointer to the symbol table entry
+        const void *mesg;       IN: Pointer to the simple datatype struct
+ RETURNS
+    BTRUE if symbol-table modified, BFALSE if not modified, BFAIL on failure.
+ DESCRIPTION
+        This function is the opposite of the H5O_sim_dtype_fast method, it
+    copies a message into the cached portion of a symbol-table entry.  (This
+    method is required for simple datatypes, as they can be cached in the
+    symbol-table entry)
+--------------------------------------------------------------------------*/
+static hbool_t
+H5O_sim_dtype_cache (H5G_entry_t *ent, const void *mesg)
+{
+    const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg;
+    const uint8 *p;
+    hbool_t modified = BFALSE;
+   
+    FUNC_ENTER (H5O_sim_dtype_cache, NULL, BFAIL);
+
+    /* check args */
+    assert (ent);
+    assert (sdtype);
+
+    /*
+     * We do this in two steps so Purify doesn't complain about
+     * uninitialized memory reads even though they don't bother
+     * anything.
+     */
+    p=(uint8 *)&(ent->cache.sdata);
+    if (H5G_CACHED_SDATA != ent->type)
+      {
+        modified = BTRUE;
+        ent->type = H5G_CACHED_SDATA;
+        *p++=sdtype->length;
+        *p++=sdtype->arch;
+        UINT16ENCODE(p,sdtype->type);
+      } /* end if */
+    else
+      {
+        if(ent->cache.sdata.length= sdtype->length)
+          {
+            modified = BTRUE;
+            ent->cache.sdata.length = sdtype->length;
+          } /* end if */
+
+        if (ent->cache.sdata.arch != sdtype->arch)
+          {
+           modified = BTRUE;
+           ent->cache.sdata.arch = sdtype->arch;
+          } /* end if */
+
+        if (ent->cache.sdata.type != sdtype->type)
+          {
+           modified = BTRUE;
+           ent->cache.sdata.type = sdtype->type;
+          } /* end if */
+      } /* end else */
+
+    FUNC_LEAVE (modified);
+} /* end H5O_sim_dtype_cache() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_copy
+ PURPOSE
+    Copies a message from MESG to DEST, allocating DEST if necessary.
+ USAGE
+    void *H5O_sim_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_sim_dtype_copy (const void *mesg, void *dest)
+{
+   const H5O_sim_dtype_t	*src = (const H5O_sim_dtype_t *)mesg;
+   H5O_sim_dtype_t		*dst = (H5O_sim_dtype_t *)dest;
+   
+   FUNC_ENTER (H5O_sim_dtype_copy, NULL, NULL);
+
+   /* check args */
+   assert (src);
+   if (!dst) dst = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t));
+
+   /* copy */
+   HDmempcy(dst,src,sizeof(H5O_sim_dtype_t));
+
+   FUNC_LEAVE ((void*)dst);
+} /* end H5O_sim_dtype_copy() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_size
+ PURPOSE
+    Return the raw message size in bytes
+ USAGE
+    void *H5O_sim_dtype_copy(f, mesg)
+        hdf5_file_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_sim_dtype_size (hdf5_file_t *f, const void *mesg)
+{
+   FUNC_ENTER (H5O_sim_dtype_size, NULL, FAIL);
+   FUNC_LEAVE (4);
+} /* end H5O_sim_dtype_size() */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5O_sim_dtype_debug
+ PURPOSE
+    Prints debugging information for a simple datatype message
+ USAGE
+    void *H5O_sim_dtype_debug(f, mesg, stream, indent, fwidth)
+        hdf5_file_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_sim_dtype_debug (hdf5_file_t *f, const void *mesg, FILE *stream,
+		intn indent, intn fwidth)
+{
+   const H5O_sim_dtype_t	*sdtype = (const H5O_sim_dtype_t *)mesg;
+   
+   FUNC_ENTER (H5O_sim_dtype_debug, NULL, FAIL);
+
+   /* check args */
+   assert (f);
+   assert (sdtype);
+   assert (stream);
+   assert (indent>=0);
+   assert (fwidth>=0);
+
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Length:",
+	    (unsigned long)(sdtype->length));
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Architecture:",
+	    (unsigned long)(sdtype->arch));
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Data-Type:",
+	    (unsigned long)(sdtype->type));
+
+   FUNC_LEAVE (SUCCEED);
+} /* end H5O_sim_dtype_debug() */
+