[svn-r139] ./src/*.[ch]

	Removed the interface initialization argument from
	FUNC_ENTER() and made it a locally-defined preprocessor
	symbol, INTERFACE_INIT.

	Changed `offset' to `address' and `length' to `size' in
	documentation so it's more consistent.  `Offset' still appears
	occassionally when it refers to a byte offset within some
	other data structure.

	Moved interface termination function prototypes from public
	header files to .c files and made them static.

./src/H5.c
./src/H5public.h
	Added H5init() because it's possible that the predefined data
	types are not initialized.  This happens only if the first
	call to the hdf5 library passes a predefined data type symbol
	as an argument.  There should be some way to fix this...

./src/H5A.c
./src/H5Aprivate.h
./src/H5Apublic.h
	The free_func returns SUCCEED or FAIL, although the return
	value is ignored by H5A.  This is so we can use the various
	H5*_close() functions to free things.

	H5Ainc_ref() and H5Adec_ref() are no longer public.  Many of
	the other atom functions should also be made private, but I'll
	save that for later...

	Added additional template groups called H5_TEMPLATE_0 through
	H5_TEMPLATE_7 that are used by the various template
	subclasses.

	Increased the number of bits used for atom groups to prevent
	negative atoms.

./src/H5AC.c
./src/H5ACprivate.h
	Changed H5AC_new() to H5AC_create() to make names more consistent.

./src/H5B.c
./src/H5Bprivate.h
	Changed H5B_new() to H5B_create() to make names more consistent.

./src/H5C.c
./src/H5Cprivate.h
./src/H5Cpublic.h
	Now supports multiple subclasses of templates, although it's
	done with big switch statements.  The default values for
	templates are defined in the source file to which that
	template belongs.  This got rid of lots of needless
	preprocessor constants.

	Added H5Ccreate() to create a new template.  Changed
	H5C_release() to H5Cclose() to make the naming more
	consistent.

./src/H5D.c
./src/H5Dprivate.h
./src/H5Dpublic.h
	Enhanced to use the new dataset interface, and uses the enhanced
	data type and data space interfaces, which haven't been
	completely implemented.  The dataset interface doesn't handle
	non-contiguous storage, compression, or data type and space
	conversions yet.

./src/H5F.c
./src/H5Fprivate.h
./src/H5Fpublic.h
	Removed H5Fflush() since just calls H5F_flush(), which doesn't
	do what the user would probably think it does, namely, flush
	everything.  It only flushes those things sitting in the H5AC
	cache and the boot block.

	Changed the `file_create_parms' field of H5F_low_t to just
	`create_parms' since the `file' part is obvious.

./src/H5Fistore.c
	Added some support for external files.  Mostly just in the
	file format and not supported much by the library yet. I need
	to finish some dataset functions first.

	Changed H5F_istore_new() to H5F_istore_create() to make names
	more uniform across packages.

./src/H5Flow.c
	Flushing a file causes the file to be physically extended to
	the logical eof.  This prevents H5F_open() from thinking a
	file has been truncated.  Most of the time the file will
	already be that large, and when it isn't Unix will often just
	allocate the final block anyway.

./src/H5G.c
./src/H5Gent.c
./src/H5Gnode.c
./src/H5Gpkg.h
./src/H5Gprivate.h
./src/H5Gstab.c
	Removed H5G_basename()

	Removed (temporarily) data type information from symbol table
	entries and renamed H5G_CACHED_SDATA to H5G_CACHED_SDSPACE to
	reflect that it's a simple data space and has nothing to do
	with raw data.

	Changed H5G_node_new() to H5G_node_create() and H5G_stab_new()
	to H5G_stab_create() to make names more uniform across
	packages.

	Fixed an undefined address bug that happens when H5G_node_debug()
	program doesn't pass enough info to H5G_node_load().

./src/H5H.c
./src/H5Hprivate.h
	Changed H5H_new() to H5H_create() to make the names more
	uniform across packages.

./src/H5M.c
./src/H5Mprivate.h
./src/H5Mpublic.h
	Nulled all the create functions.  Most of the other callbacks
	are to public functions.  Removed H5Mcreate().

	Changed hobjtype_t to group_t since it has to be the same
	thing anyway.

./src/H5O.c
./src/H5Oprivate.h
./src/H5Osdim.c
./src/H5Osdtyp.c
	Changed H5O_SIM_DIM to H5O_SDSPACE (simple data space) since
	`simple data space' is its official name, not `simple
	dimensions'.  Will eventually add H5O_CDSPACE for comples data
	spaces. Changed _sim_dim_ to _dspace_.

	Replaced H5O_SIM_DTYPE and the compound data type messages
	with a single H5O_DTYPE message. Changed _sim_dtype_ to _dtype_.

	Changed H5O_STD_STORE to H5O_CSTORE (contiguous storage) since
	contiguous storage is not necessarily standard.  Changed
	_std_store_ to _cstore_ in H5Ocstore.c

	Added the H5O_EFL (external file list) message.

	Changed H5O_new() to H5O_create() to make names more uniform
	across packages.

./src/H5Oefl.c		NEW
	External file list message for specifying which non-hdf5 files
	contain raw data for a dataset.

./src/H5P.c
./src/H5Pprivate.h
./src/H5Ppublic.h
	Renamed and moved data structures to make the names conform to
	our naming scheme.

./src/H5T.c
./src/H5Tprivate.h
./src/H5Tpublic.h
./src/H5Tpkg.h		NEW
	Data structures redesigned to be more flexible.  The interface
	was redesigned to make it more regular and to make some names
	more uniform across packages.

./src/H5detect.c
	Output was changed to produce a file that conforms to the hdf5
	coding standard.

./src/Makefile.in
	Generates H5Tinit.c by running H5detect.

./src/debug.c
	Moved command argument processing.

1 files changed, 184 insertions, 196 deletions

diff --git a/src/H5Osdim.c b/src/H5Osdim.c
index ffd9743..3bc1e04 100644
--- a/src/H5Osdim.c
+++ b/src/H5Osdim.c
@@ -1,13 +1,13 @@
 /****************************************************************************
-* 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.                                                        *
-*                                                                          *
+* 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
@@ -16,83 +16,71 @@ static char RcsId[] = "@(#)$Revision$";
 
 /* $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
+#define PABLO_MASK	H5O_sdspace_mask
 
 /* PRIVATE PROTOTYPES */
-static void *H5O_sim_dim_decode (H5F_t *f, size_t raw_size, const uint8 *p);
-static herr_t H5O_sim_dim_encode (H5F_t *f, size_t size, uint8 *p,
+static void *H5O_sdspace_decode (H5F_t *f, size_t raw_size, const uint8 *p);
+static herr_t H5O_sdspace_encode (H5F_t *f, size_t size, uint8 *p,
 			       const void *_mesg);
-static void *H5O_sim_dim_fast (const H5G_cache_t *cache, void *_mesg);
-static hbool_t H5O_sim_dim_cache (H5G_type_t *cache_type, H5G_cache_t *cache,
+static void *H5O_sdspace_fast (const H5G_cache_t *cache, void *_mesg);
+static hbool_t H5O_sdspace_cache (H5G_type_t *cache_type, H5G_cache_t *cache,
 				  const void *_mesg);
-static void *H5O_sim_dim_copy (const void *_mesg, void *_dest);
-static size_t H5O_sim_dim_size (H5F_t *f, const void *_mesg);
-static herr_t H5O_sim_dim_debug (H5F_t *f, const void *_mesg,
+static void *H5O_sdspace_copy (const void *_mesg, void *_dest);
+static size_t H5O_sdspace_size (H5F_t *f, const void *_mesg);
+static herr_t H5O_sdspace_debug (H5F_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 */
-   H5G_CACHED_SDATA,	    /* symtab entry `type' field */
-   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 */
+const H5O_class_t H5O_SDSPACE[1] = {{
+   H5O_SDSPACE_ID,		/* message id number			*/
+   "simple_dspace",		/* message name for debugging		*/
+   sizeof (H5P_simple_t),	/* native message size			*/
+   H5G_CACHED_SDSPACE,		/* symtab entry `type' field		*/
+   H5O_sdspace_decode,		/* decode message			*/
+   H5O_sdspace_encode,		/* encode message			*/
+   H5O_sdspace_fast,		/* get message from stab entry		*/
+   H5O_sdspace_cache,		/* put message into stab entry		*/
+   H5O_sdspace_copy,		/* copy the native value		*/
+   H5O_sdspace_size,		/* size of symbol table entry		*/
+   NULL,			/* default reset method			*/
+   H5O_sdspace_debug,		/* debug the message			*/
 }};
 
 /* Is the interface initialized? */
 static hbool_t interface_initialize_g = FALSE;
+#define INTERFACE_INIT NULL
 
 /*--------------------------------------------------------------------------
  NAME
-    H5O_sim_dim_decode
+    H5O_sdspace_decode
  PURPOSE
     Decode a simple dimensionality message and return a pointer to a memory
-        struct with the decoded information
+	struct with the decoded information
  USAGE
-    void *H5O_sim_dim_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
+    void *H5O_sdspace_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 dimensionality
+	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 (H5F_t *f, size_t raw_size, const uint8 *p)
+H5O_sdspace_decode (H5F_t *f, size_t raw_size, const uint8 *p)
 {
-    H5O_sim_dim_t *sdim=NULL;   /* New simple dimensionality structure */
-    uintn u;                    /* local counting variable */
+    H5P_simple_t *sdim=NULL;	/* New simple dimensionality structure */
+    uintn u;			/* local counting variable */
    
-    FUNC_ENTER (H5O_sim_dim_decode, NULL, NULL);
+    FUNC_ENTER (H5O_sdspace_decode, NULL);
 
     /* check args */
     assert (f);
@@ -100,28 +88,28 @@ H5O_sim_dim_decode (H5F_t *f, size_t raw_size, const uint8 *p)
     assert (p);
 
     /* decode */
-    if((sdim = H5MM_xcalloc (1, sizeof(H5O_sim_dim_t)))!=NULL)
+    if((sdim = H5MM_xcalloc (1, sizeof(H5P_simple_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->rank; u++)
-                UINT32DECODE(p,sdim->size[u]);
-            if(sdim->dim_flags&0x01)
-              {
-                sdim->max=H5MM_xmalloc(sizeof(uint32)*sdim->rank);
-                for(u=0; u<sdim->rank; 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->rank; u++)
-                    UINT32DECODE(p,sdim->perm[u]);
-              } /* end if */
-          } /* end if */
+	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->rank; u++)
+		UINT32DECODE(p,sdim->size[u]);
+	    if(sdim->dim_flags&0x01)
+	      {
+		sdim->max=H5MM_xmalloc(sizeof(uint32)*sdim->rank);
+		for(u=0; u<sdim->rank; 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->rank; u++)
+		    UINT32DECODE(p,sdim->perm[u]);
+	      } /* end if */
+	  } /* end if */
       } /* end if */
 
 #ifdef LATER
@@ -135,32 +123,32 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE (sdim);
-} /* end H5O_sim_dim_decode() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
-    H5O_sim_dim_encode
+    H5O_sdspace_encode
  PURPOSE
     Encode a simple dimensionality message 
  USAGE
-    herr_t H5O_sim_dim_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 dimensionality struct
+    herr_t H5O_sdspace_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 dimensionality struct
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
-        This function encodes the native memory form of the simple
+	This function encodes the native memory form of the simple
     dimensionality message in the "raw" disk form.
 --------------------------------------------------------------------------*/
 static herr_t
-H5O_sim_dim_encode (H5F_t *f, size_t raw_size, uint8 *p, const void *mesg)
+H5O_sdspace_encode (H5F_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 */
+    const H5P_simple_t *sdim = (const H5P_simple_t *)mesg;
+    uintn u;	    /* Local counting variable */
 
-    FUNC_ENTER (H5O_sim_dim_encode, NULL, FAIL);
+    FUNC_ENTER (H5O_sdspace_encode, FAIL);
 
     /* check args */
     assert (f);
@@ -173,165 +161,165 @@ H5O_sim_dim_encode (H5F_t *f, size_t raw_size, uint8 *p, const void *mesg)
     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 */
-        if(sdim->dim_flags&0x02)
-          {
-            for(u=0; u<sdim->rank; u++)
-                UINT32ENCODE(p,sdim->perm[u]);
-          } /* end if */
+	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 */
+	if(sdim->dim_flags&0x02)
+	  {
+	    for(u=0; u<sdim->rank; u++)
+		UINT32ENCODE(p,sdim->perm[u]);
+	  } /* end if */
       } /* end if */
 
     FUNC_LEAVE (SUCCEED);
-} /* end H5O_sim_dim_encode() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
-    H5O_sim_dim_fast
+    H5O_sdspace_fast
  PURPOSE
     Initializes a new simple dimensionality struct with info from a symbol
-        table entry.
+	table entry.
  USAGE
-    void *H5O_sim_dim_fast(ent, mesg)
-        const H5G_entry_t *ent; IN: pointer to the symbol table entry
-        const void *mesg;       IN: Pointer to the simple dimensionality struct
+    void *H5O_sdspace_fast(ent, mesg)
+	const H5G_entry_t *ent; IN: pointer to the symbol table entry
+	const void *mesg;	IN: Pointer to the simple dimensionality struct
  RETURNS
     Pointer to the message structure (allocated if none is supplied) on success,
-        NULL on failure
+	NULL on failure
  DESCRIPTION
-        This function fills the native memory form of the simple dimensionality
+	This function fills the native memory form of the simple dimensionality
     message from a symbol-table entry cache fields.  (This method is required
     for simple dimensionality, as they can be cached in the symbol-table entry)
 --------------------------------------------------------------------------*/
 static void *
-H5O_sim_dim_fast (const H5G_cache_t *cache, void *mesg)
+H5O_sdspace_fast (const H5G_cache_t *cache, void *mesg)
 {
-   H5O_sim_dim_t *sdim = (H5O_sim_dim_t *)mesg;
-   uintn u;                    /* local counting variable */
+   H5P_simple_t *sdim = (H5P_simple_t *)mesg;
+   uintn u;		       /* local counting variable */
    
-   FUNC_ENTER (H5O_sim_dim_fast, NULL, NULL);
+   FUNC_ENTER (H5O_sdspace_fast, NULL);
 
    /* check args */
    assert (cache);
 
-   if (!sdim) sdim = H5MM_xcalloc (1, sizeof(H5O_sim_dim_t));
-   sdim->rank = cache->sdata.ndim;
-   assert (sdim->rank<=NELMTS (cache->sdata.dim));
+   if (!sdim) sdim = H5MM_xcalloc (1, sizeof(H5P_simple_t));
+   sdim->rank = cache->sdspace.ndim;
+   assert (sdim->rank<=NELMTS (cache->sdspace.dim));
    sdim->dim_flags = 0;
    sdim->size = H5MM_xmalloc (sizeof(uint32) * sdim->rank);
    for (u=0; u<sdim->rank; u++) {
-      sdim->size[u] = cache->sdata.dim[u];
+      sdim->size[u] = cache->sdspace.dim[u];
    }
    
    FUNC_LEAVE (sdim);
-} /* end H5O_sim_dim_fast() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
-    H5O_sim_dim_cache
+    H5O_sdspace_cache
  PURPOSE
     Copies a simple dimensionality message into the cache portion of a symbol
-        table entry.
+	table entry.
  USAGE
-    hbool_t H5O_sim_dim_cache(ent, mesg)
-        const H5G_entry_t *ent; IN: Pointer to the symbol table entry
-        const void *mesg;       IN: Pointer to the simple dimensionality struct
+    hbool_t H5O_sdspace_cache(ent, mesg)
+	const H5G_entry_t *ent; IN: Pointer to the symbol table entry
+	const void *mesg;	IN: Pointer to the simple dimensionality struct
  RETURNS
     BTRUE if symbol-table modified, BFALSE if not modified, BFAIL on failure.
     The new cache type is returned through the CACHE_TYPE argument.
  DESCRIPTION
-        This function is the opposite of the H5O_sim_dim_fast method, it
+	This function is the opposite of the H5O_sdspace_fast method, it
     copies a message into the cached portion of a symbol-table entry.  (This
     method is required for simple dimensionalities, as they can be cached in
     the symbol-table entry)
 --------------------------------------------------------------------------*/
 static hbool_t
-H5O_sim_dim_cache (H5G_type_t *cache_type, H5G_cache_t *cache,
+H5O_sdspace_cache (H5G_type_t *cache_type, H5G_cache_t *cache,
 		   const void *mesg)
 {
-    const H5O_sim_dim_t *sdim = (const H5O_sim_dim_t *)mesg;
-    uintn u;        /* Local counting variable */
+    const H5P_simple_t *sdim = (const H5P_simple_t *)mesg;
+    uintn u;	    /* Local counting variable */
     hbool_t modified = BFALSE;
    
-    FUNC_ENTER (H5O_sim_dim_cache, NULL, BFAIL);
+    FUNC_ENTER (H5O_sdspace_cache, BFAIL);
 
     /* check args */
     assert (cache_type);
     assert (cache);
     assert (sdim);
 
-    if (sdim->rank <= NELMTS (cache->sdata.dim)) {
-       if (H5G_CACHED_SDATA != *cache_type) {
+    if (sdim->rank <= NELMTS (cache->sdspace.dim)) {
+       if (H5G_CACHED_SDSPACE != *cache_type) {
 	  modified = BTRUE;
-	  *cache_type = H5G_CACHED_SDATA;
-	  cache->sdata.ndim = sdim->rank;
+	  *cache_type = H5G_CACHED_SDSPACE;
+	  cache->sdspace.ndim = sdim->rank;
 	  for (u=0; u<=sdim->rank; u++) {
-	     cache->sdata.dim[u] = sdim->size[u];
+	     cache->sdspace.dim[u] = sdim->size[u];
 	  }
        } else {
-	  if(cache->sdata.ndim != sdim->rank) {
+	  if(cache->sdspace.ndim != sdim->rank) {
 	     modified = BTRUE;
-	     cache->sdata.ndim = sdim->rank;
-          }
+	     cache->sdspace.ndim = sdim->rank;
+	  }
 
 	  /* Check each dimension */
-	  if (NULL==cache->sdata.dim) {
+	  if (NULL==cache->sdspace.dim) {
 	     modified = BTRUE;
 	  } else {
 	     for (u=0; u<sdim->rank; u++) {
-                if (cache->sdata.dim[u] != sdim->size[u]) {
-                   modified = BTRUE;
-                   cache->sdata.dim[u] = sdim->size[u];
+		if (cache->sdspace.dim[u] != sdim->size[u]) {
+		   modified = BTRUE;
+		   cache->sdspace.dim[u] = sdim->size[u];
 		}
 	     }
-          }
+	  }
        }
-    } else if (H5G_CACHED_SDATA == *cache_type) {
+    } else if (H5G_CACHED_SDSPACE == *cache_type) {
        /*
-        * Number of dimensions is too large to cache.
-        */
+	* Number of dimensions is too large to cache.
+	*/
        modified = TRUE;
        *cache_type = H5G_NOTHING_CACHED;
     }
        
     FUNC_LEAVE (modified);
-} /* end H5O_sim_dim_cache() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
-    H5O_sim_dim_copy
+    H5O_sdspace_copy
  PURPOSE
     Copies a message from MESG to DEST, allocating DEST if necessary.
  USAGE
-    void *H5O_sim_dim_copy(mesg, dest)
-        const void *mesg;       IN: Pointer to the source simple dimensionality struct
-        const void *dest;       IN: Pointer to the destination simple dimensionality struct
+    void *H5O_sdspace_copy(mesg, dest)
+	const void *mesg;	IN: Pointer to the source simple dimensionality struct
+	const void *dest;	IN: Pointer to the destination simple dimensionality struct
  RETURNS
     Pointer to DEST on success, NULL on failure
  DESCRIPTION
-        This function copies a native (memory) simple dimensionality message,
+	This function copies a native (memory) simple dimensionality message,
     allocating the destination structure if necessary.
 --------------------------------------------------------------------------*/
 static void *
-H5O_sim_dim_copy (const void *mesg, void *dest)
+H5O_sdspace_copy (const void *mesg, void *dest)
 {
-   const H5O_sim_dim_t	*src = (const H5O_sim_dim_t *)mesg;
-   H5O_sim_dim_t		*dst = (H5O_sim_dim_t *)dest;
+   const H5P_simple_t	*src = (const H5P_simple_t *)mesg;
+   H5P_simple_t		*dst = (H5P_simple_t *)dest;
    
-   FUNC_ENTER (H5O_sim_dim_copy, NULL, NULL);
+   FUNC_ENTER (H5O_sdspace_copy, NULL);
 
    /* check args */
    assert (src);
    if (!dst)
-       dst = H5MM_xcalloc (1, sizeof(H5O_sim_dim_t));
+       dst = H5MM_xcalloc (1, sizeof(H5P_simple_t));
 
    /* deep copy -- pointed-to values are copied also */
-   HDmemcpy(dst,src,sizeof(H5O_sim_dim_t));
+   HDmemcpy(dst,src,sizeof(H5P_simple_t));
    if (src->size) dst->size = H5MM_xcalloc (src->rank, sizeof(uint32));
    if (src->max)  dst->max  = H5MM_xcalloc (src->rank, sizeof(uint32));
    if (src->perm) dst->perm = H5MM_xcalloc (src->rank, sizeof(uint32));
@@ -341,76 +329,76 @@ H5O_sim_dim_copy (const void *mesg, void *dest)
        HDmemcpy(dst->size,src->size,src->rank*sizeof(uint32));
        /* Check for maximum dimensions and copy those */
        if((src->dim_flags&0x01)>0)
-         {
-           HDmemcpy(dst->max,src->max,src->rank*sizeof(uint32));
-         } /* end if */
+	 {
+	   HDmemcpy(dst->max,src->max,src->rank*sizeof(uint32));
+	 } /* end if */
        /* Check for dimension permutation and copy those */
        if((src->dim_flags&0x02)>0)
-         {
-           HDmemcpy(dst->perm,src->perm,src->rank*sizeof(uint32));
-         } /* end if */
+	 {
+	   HDmemcpy(dst->perm,src->perm,src->rank*sizeof(uint32));
+	 } /* end if */
      } /* end if */
 
    FUNC_LEAVE ((void*)dst);
-} /* end H5O_sim_dim_copy() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
-    H5O_sim_dim_size
+    H5O_sdspace_size
  PURPOSE
     Return the raw message size in bytes
  USAGE
-    void *H5O_sim_dim_copy(f, mesg)
-        H5F_t *f;         IN: pointer to the HDF5 file struct
-        const void *mesg;       IN: Pointer to the source simple dimensionality struct
+    void *H5O_sdspace_copy(f, mesg)
+	H5F_t *f;	  IN: pointer to the HDF5 file struct
+	const void *mesg;	IN: Pointer to the source simple dimensionality struct
  RETURNS
     Size of message on success, FAIL on failure
  DESCRIPTION
-        This function returns the size of the raw simple dimensionality message on
+	This function returns the size of the raw simple dimensionality 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_dim_size (H5F_t *f, const void *mesg)
+H5O_sdspace_size (H5F_t *f, const void *mesg)
 {
-   const H5O_sim_dim_t	*sdim = (const H5O_sim_dim_t *)mesg;
-   size_t ret_value=8;  /* all dimensionality messages are at least 8 bytes long (rank and flags) */
+   const H5P_simple_t	*sdim = (const H5P_simple_t *)mesg;
+   size_t ret_value=8;	/* all dimensionality messages are at least 8 bytes long (rank and flags) */
 
-   FUNC_ENTER (H5O_sim_dtype_size, NULL, FAIL);
+   FUNC_ENTER (H5O_sim_dtype_size, FAIL);
 
    ret_value+=sdim->rank*4; /* add in the dimension sizes */
-   ret_value+=((sdim->dim_flags&0x01)>0)*sdim->rank*4;  /* add in the space for the maximum dimensions, if they are present */
-   ret_value+=((sdim->dim_flags&0x02)>0)*sdim->rank*4;  /* add in the space for the dimension permutations, if they are present */
+   ret_value+=((sdim->dim_flags&0x01)>0)*sdim->rank*4;	/* add in the space for the maximum dimensions, if they are present */
+   ret_value+=((sdim->dim_flags&0x02)>0)*sdim->rank*4;	/* add in the space for the dimension permutations, if they are present */
 
    FUNC_LEAVE (ret_value);
-} /* end H5O_sim_dim_size() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
-    H5O_sim_dim_debug
+    H5O_sdspace_debug
  PURPOSE
     Prints debugging information for a simple dimensionality message
  USAGE
-    void *H5O_sim_dim_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 dimensionality struct
-        FILE *stream;           IN: Pointer to the stream for output data
-        intn indent;            IN: Amount to indent information by
-        intn fwidth;            IN: Field width (?)
+    void *H5O_sdspace_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 dimensionality 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 
+	This function prints debugging output to the stream passed as a 
     parameter.
 --------------------------------------------------------------------------*/
 static herr_t
-H5O_sim_dim_debug (H5F_t *f, const void *mesg, FILE *stream,
+H5O_sdspace_debug (H5F_t *f, const void *mesg, FILE *stream,
 		intn indent, intn fwidth)
 {
-   const H5O_sim_dim_t	*sdim = (const H5O_sim_dim_t *)mesg;
-   uintn u;     /* local counting variable */
+   const H5P_simple_t	*sdim = (const H5P_simple_t *)mesg;
+   uintn u;	/* local counting variable */
    
-   FUNC_ENTER (H5O_sim_dim_debug, NULL, FAIL);
+   FUNC_ENTER (H5O_sdspace_debug, FAIL);
 
    /* check args */
    assert (f);
@@ -427,19 +415,19 @@ H5O_sim_dim_debug (H5F_t *f, const void *mesg, FILE *stream,
 	    (unsigned long)(sdim->dim_flags));
     for(u=0; u<sdim->rank; u++)
        fprintf (stream, "%*s%-*s %lx\n", indent, "", fwidth,
-            "Dim Size:",
-            (unsigned long)(sdim->size[u]));
+	    "Dim Size:",
+	    (unsigned long)(sdim->size[u]));
     if(sdim->dim_flags&0x01)
-        for(u=0; u<sdim->rank; u++)
-           fprintf (stream, "%*s%-*s %lx\n", indent, "", fwidth,
-                "Dim Max:",
-                (unsigned long)(sdim->max[u]));
+	for(u=0; u<sdim->rank; u++)
+	   fprintf (stream, "%*s%-*s %lx\n", indent, "", fwidth,
+		"Dim Max:",
+		(unsigned long)(sdim->max[u]));
     if(sdim->dim_flags&0x02)
-        for(u=0; u<sdim->rank; u++)
-           fprintf (stream, "%*s%-*s %lx\n", indent, "", fwidth,
-                "Dim Perm:",
-                (unsigned long)(sdim->perm[u]));
+	for(u=0; u<sdim->rank; u++)
+	   fprintf (stream, "%*s%-*s %lx\n", indent, "", fwidth,
+		"Dim Perm:",
+		(unsigned long)(sdim->perm[u]));
 
    FUNC_LEAVE (SUCCEED);
-} /* end H5O_sim_dim_debug() */
+}