[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, 549 insertions, 366 deletions

diff --git a/src/H5P.c b/src/H5P.c
index c6f3bcb..716f874 100644
--- a/src/H5P.c
+++ b/src/H5P.c
@@ -16,34 +16,21 @@ static char RcsId[] = "@(#)$Revision$";
 
 /* $Id$ */
 
-/*LINTLIBRARY */
-/*+
-   FILE
-       H5P.c
-   HDF5 Data-space routines
 
-   EXPORTED ROUTINES
-       H5Pcreate    -- Create a data-space
-       H5Prelease   -- Release access to a data-space
-
-   LIBRARY-SCOPED ROUTINES
-
-   LOCAL ROUTINES
-       H5P_init_interface    -- initialize the interface
-   + */
-
-#include <H5private.h>  /* Generic Functions */
-#include <H5Aprivate.h> /* Atom Functions */
-#include <H5Eprivate.h> /* Error handling */
-#include <H5MMprivate.h> /* Memory Management functions */
-#include <H5Pprivate.h> /* Data-space functions */
+#include <H5private.h>  	/* Generic Functions			*/
+#include <H5Aprivate.h> 	/* Atom Functions			*/
+#include <H5Eprivate.h> 	/* Error handling			*/
+#include <H5MMprivate.h> 	/* Memory Management functions		*/
+#include <H5Oprivate.h>		/*object headers			*/
+#include <H5Pprivate.h> 	/* Data-space functions			*/
 
 #define PABLO_MASK	H5P_mask
 
-/*--------------------- Locally scoped variables -----------------------------*/
-
-/* Whether we've installed the library termination function yet for this interface */
+/* Interface initialization */
 static intn interface_initialize_g = FALSE;
+#define INTERFACE_INIT	H5P_init_interface
+static herr_t H5P_init_interface (void);
+static void H5P_term_interface (void);
 
 /*--------------------------------------------------------------------------
 NAME
@@ -57,40 +44,21 @@ DESCRIPTION
     Initializes any interface-specific data or routines.
 
 --------------------------------------------------------------------------*/
-static herr_t H5P_init_interface(void)
+static herr_t
+H5P_init_interface (void)
 {
-    herr_t ret_value = SUCCEED;
-    FUNC_ENTER (H5P_init_interface, NULL, FAIL);
+   herr_t ret_value = SUCCEED;
+   FUNC_ENTER (H5P_init_interface, FAIL);
 
-    /* Initialize the atom group for the file IDs */
-    if((ret_value=H5Ainit_group(H5_DATASPACE,H5A_DATASPACEID_HASHSIZE,H5P_RESERVED_ATOMS,H5P_destroy))!=FAIL)
-        ret_value=H5_add_exit(&H5P_term_interface);
+   /* Initialize the atom group for the file IDs */
+   if ((ret_value=H5Ainit_group (H5_DATASPACE, H5A_DATASPACEID_HASHSIZE,
+				 H5P_RESERVED_ATOMS,
+				 (herr_t (*)(void*))H5P_close))!=FAIL) {
+      ret_value=H5_add_exit(&H5P_term_interface);
+   }
 
-    FUNC_LEAVE(ret_value);
-}	/* H5P_init_interface */
-
-/*--------------------------------------------------------------------------
-NAME
-   H5P_init -- Make certain that the interface has been initialized
-USAGE
-    herr_t H5P_init()
-   
-RETURNS
-   SUCCEED/FAIL
-DESCRIPTION
-    Library public routine to make certain the H5P interface has been properly
-    initialized.
-
---------------------------------------------------------------------------*/
-herr_t H5P_init(void)
-{
-    herr_t ret_value = SUCCEED;
-    FUNC_ENTER (H5P_init, H5P_init_interface, FAIL);
-
-    /* Actual work is done in the FUNC_ENTER macro */
-
-    FUNC_LEAVE(ret_value);
-}	/* H5P_init */
+   FUNC_LEAVE (ret_value);
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -109,58 +77,470 @@ herr_t H5P_init(void)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-void H5P_term_interface (void)
+static void
+H5P_term_interface (void)
+{
+   H5Adestroy_group (H5_DATASPACE);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Pcreate
+ *
+ * Purpose:	Creates a new data space object and opens it for access.
+ *
+ * Return:	Success:	The ID for the new data space object.
+ *
+ *		Failure:	FAIL
+ *
+ * Errors:
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Pcreate (H5P_class_t type)
 {
-    H5Adestroy_group(H5_DATASPACE);
-} /* end H5P_term_interface() */
+   H5P_t	*ds = NULL;
+   hid_t	ret_value = FAIL;
+   
+   FUNC_ENTER (H5Pcreate, FAIL);
+   H5ECLEAR;
 
-/*--------------------------------------------------------------------------
- NAME
-    H5P_create
- PURPOSE
-    Create a new HDF5 dimensionality object
- USAGE
-    hid_t H5P_create(owner_id, type, name)
-        hid_t owner_id;       IN: Group/file which owns this object
-        hobjtype_t type;        IN: Type of object to create
-        const char *name;       IN: Name of the object
- RETURNS
-    Returns ID (atom) on success, FAIL on failure
- DESCRIPTION
-        This function actually creates the dimensionality object.
---------------------------------------------------------------------------*/
-hid_t H5P_create(hid_t owner_id, hobjtype_t type, const char *name)
+   ds = H5MM_xcalloc (1, sizeof(H5P_t));
+   ds->type = type;
+   
+   switch (type) {
+   case H5P_SCALAR:
+      /*void*/
+      break;
+      
+   case H5P_SIMPLE:
+      ds->u.simple.rank = 0;
+      break;
+
+   case H5P_COMPLEX:
+      /* Complex types are not supported yet */
+      HGOTO_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+
+   default:
+      /* Unknown data space type */
+      HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);
+   }
+
+   /* Register the new data space and get an ID for it */
+   if ((ret_value = H5Aregister_atom (H5_DATASPACE, ds))<0) {
+      HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL);
+   }
+
+ done:
+   if (ret_value<0) {
+      H5MM_xfree (ds);
+   }
+
+   FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Pclose
+ *
+ * Purpose:	Release access to a data space object.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Errors:
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Pclose (hid_t space_id)
+{
+   FUNC_ENTER (H5Pclose, FAIL);
+   H5ECLEAR;
+
+   /* check args */
+   if (H5_DATASPACE!=H5Aatom_group (space_id) ||
+       NULL==H5Aatom_object (space_id)) {
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space*/
+   }
+   
+   /* When the reference count reaches zero the resources are freed */
+   if (H5A_dec_ref (space_id)<0) {
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*problem freeing id*/
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5P_close
+ *
+ * Purpose:	Releases all memory associated with a data space.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5P_close (H5P_t *ds)
+{
+   FUNC_ENTER (H5P_close, FAIL);
+
+   assert (ds);
+
+   switch (ds->type) {
+   case H5P_SCALAR:
+      /*void*/
+      break;
+      
+   case H5P_SIMPLE:
+      H5MM_xfree (ds->u.simple.size);
+      H5MM_xfree (ds->u.simple.max);
+      H5MM_xfree (ds->u.simple.perm);
+      break;
+
+   case H5P_COMPLEX:
+      /* nothing */
+      break;
+
+   default:
+      assert ("unknown data space type" && 0);
+      break;
+   }
+   H5MM_xfree (ds);
+   
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5P_copy
+ *
+ * Purpose:	Copies a data space.
+ *
+ * Return:	Success:	A pointer to a new copy of SRC
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *              Thursday, December  4, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5P_t *
+H5P_copy (const H5P_t *src)
+{
+   H5P_t	*dst = NULL;
+   int		i;
+   
+   FUNC_ENTER (H5P_copy, NULL);
+
+   dst = H5MM_xmalloc (sizeof(H5P_t));
+   *dst = *src;
+
+   switch (dst->type) {
+   case H5P_SCALAR:
+      /*void*/
+      break;
+      
+   case H5P_SIMPLE:
+      if (dst->u.simple.size) {
+	 dst->u.simple.size = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn));
+	 for (i=0; i<dst->u.simple.rank; i++) {
+	    dst->u.simple.size[i] = src->u.simple.size[i];
+	 }
+      }
+      if (dst->u.simple.max) {
+	 dst->u.simple.max = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn));
+	 for (i=0; i<dst->u.simple.rank; i++) {
+	    dst->u.simple.max[i] = src->u.simple.max[i];
+	 }
+      }
+      if (dst->u.simple.perm) {
+	 dst->u.simple.perm = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn));
+	 for (i=0; i<dst->u.simple.rank; i++) {
+	    dst->u.simple.perm[i] = src->u.simple.perm[i];
+	 }
+      }
+      break;
+
+   case H5P_COMPLEX:
+      /*void*/
+      break;
+
+   default:
+      assert ("unknown data space type" && 0);
+      break;
+   }
+
+   FUNC_LEAVE (dst);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Pget_npoints
+ *
+ * Purpose:	Determines how many data points a data set has.
+ *
+ * Return:	Success:	Number of data points in the data set.
+ *
+ *		Failure:	0
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5Pget_npoints (hid_t space_id)
+{
+   H5P_t	*ds = NULL;
+   size_t	ret_value = 0;
+
+   FUNC_ENTER(H5Pget_npoints, 0);
+   H5ECLEAR;
+
+   /* check args */
+   if (H5_DATASPACE!=H5Aatom_group (space_id) ||
+       NULL==(ds=H5Aatom_object (space_id))) {
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0); /*not a data space*/
+   }
+
+   ret_value = H5P_get_npoints (ds);
+
+   FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5P_get_npoints
+ *
+ * Purpose:	Determines how many data points a data set has.
+ *
+ * Return:	Success:	Number of data points in the data set.
+ *
+ *		Failure:	0
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5P_get_npoints (const H5P_t *ds)
 {
-    H5P_dim_t *new_dim;               /* new dimensionality object to create */
-    hid_t ret_value = SUCCEED;
+   size_t	ret_value = 0;
+   intn		i;
+   
+   FUNC_ENTER(H5P_get_npoints, 0);
 
-    FUNC_ENTER(H5P_create, H5P_init_interface, FAIL);
+   /* check args */
+   assert (ds);
 
-    /* Clear errors and check args and all the boring stuff. */
-    H5ECLEAR;
+   switch (ds->type) {
+   case H5P_SCALAR:
+      ret_value = 1;
+      break;
 
-    /* Allocate space for the new data-type */
-    if((new_dim=HDcalloc(1,sizeof(H5P_dim_t)))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
-    
-    /* Initialize the dimensionality object */
-    new_dim->type=H5P_TYPE_UNKNOWN;
-    new_dim->s=NULL;
+   case H5P_SIMPLE:
+      for (ret_value=1, i=0; i<ds->u.simple.rank; i++) {
+	 ret_value *= ds->u.simple.size[i];
+      }
+      break;
+
+   case H5P_COMPLEX:
+      /* complex data spaces are not supported yet */
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0);
+
+   default:
+      /* unknown data space class */
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0);
+   }
+
+   FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5P_modify
+ *
+ * Purpose:	Updates a data space by writing a message to an object
+ *		header.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5P_modify (H5F_t *f, H5G_entry_t *ent, const H5P_t *ds)
+{
+   FUNC_ENTER (H5O_modify, FAIL);
 
-    /* Register the new datatype and get an ID for it */
-    if((ret_value=H5Aregister_atom(H5_DATASPACE, (const VOIDP)new_dim))==FAIL)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL);
+   assert (f);
+   assert (ent);
+   assert (ds);
 
-done:
-  if(ret_value == FAIL)   
-    { /* Error condition cleanup */
+   switch (ds->type) {
+   case H5P_SCALAR:
+      /* Scalar data spaces are not implemented yet */
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
 
-    } /* end if */
+   case H5P_SIMPLE:
+      if (H5O_modify (f, NO_ADDR, ent, H5O_SDSPACE, 0, &(ds->u.simple))<0) {
+	 /* Can't update simple data space message */
+	 HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL);
+      }
+      break;
+
+   case H5P_COMPLEX:
+      /* Complex data spaces are not implemented yet */
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+
+   default:
+      assert ("unknown data space class" && 0);
+      break;
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5P_read
+ *
+ * Purpose:	Reads the data space from an object header.
+ *
+ * Return:	Success:	Pointer to a new data space.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5P_t *
+H5P_read (H5F_t *f, H5G_entry_t *ent)
+{
+   H5P_t	*ds = NULL;
+   
+   FUNC_ENTER (H5P_read, NULL);
+
+   /* check args */
+   assert (f);
+   assert (ent);
+
+   ds = H5MM_xcalloc (1, sizeof(H5P_t));
+
+   if (H5O_read (f, NO_ADDR, ent, H5O_SDSPACE, 0, &(ds->u.simple))) {
+      ds->type = H5P_SIMPLE;
+      
+   } else {
+      ds->type = H5P_SCALAR;
+   }
+
+   FUNC_LEAVE (ds);
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5P_cmp
+ *
+ * Purpose:	Compares two data spaces.
+ *
+ * Return:	Success:	0 if DS1 and DS2 are the same.
+ *				<0 if DS1 is less than DS2.
+ * 				>0 if DS1 is greater than DS2.
+ *
+ *		Failure:	0, never fails
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, December 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5P_cmp (const H5P_t *ds1, const H5P_t *ds2)
+{
+   intn		i;
+   
+   FUNC_ENTER (H5P_cmp, 0);
 
-    /* Normal function cleanup */
+   /* check args */
+   assert (ds1);
+   assert (ds2);
 
-    FUNC_LEAVE(ret_value);
-} /* end H5P_create() */
+   /* compare */
+   if (ds1->type < ds2->type) HRETURN (-1);
+   if (ds1->type > ds2->type) HRETURN (1);
+
+   switch (ds1->type) {
+   case H5P_SIMPLE:
+      if (ds1->u.simple.rank < ds2->u.simple.rank) HRETURN (-1);
+      if (ds1->u.simple.rank > ds2->u.simple.rank) HRETURN (1);
+
+      /* don't compare flags */
+
+      for (i=0; i<ds1->u.simple.rank; i++) {
+	 if (ds1->u.simple.size[i] < ds2->u.simple.size[i]) HRETURN (-1);
+	 if (ds1->u.simple.size[i] > ds2->u.simple.size[i]) HRETURN (1);
+      }
+
+      /* don't compare max dimensions */
+      
+      for (i=0; i<ds1->u.simple.rank; i++) {
+	 if ((ds1->u.simple.perm?ds1->u.simple.perm[i]:i) <
+	     (ds2->u.simple.perm?ds2->u.simple.perm[i]:i)) HRETURN (-1);
+	 if ((ds1->u.simple.perm?ds2->u.simple.perm[i]:i) >
+	     (ds2->u.simple.perm?ds2->u.simple.perm[i]:i)) HRETURN (1);
+      }
+
+      break;
+
+   default:
+      assert ("not implemented yet" && 0);
+   }
+
+   FUNC_LEAVE (0);
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -168,8 +548,8 @@ done:
  PURPOSE
     Return the logical rank of a dataspace (internal)
  USAGE
-    uint32 H5P_get_lrank(sdim)
-        H5P_sdim_t *sdim;            IN: Pointer to dataspace object to query
+    intn H5P_get_lrank(sdim)
+        H5P_t *sdim;            IN: Pointer to dataspace object to query
  RETURNS
     The logical rank of a dataspace on success, UFAIL on failure
  DESCRIPTION
@@ -178,11 +558,12 @@ done:
     dataspace, not the dimensionality of the space its embedded in.
     UFAIL is returned on an error, otherwise the rank is returned.
 --------------------------------------------------------------------------*/
-uint32 H5P_get_lrank(const H5P_sdim_t *sdim)
+intn
+H5P_get_lrank (const H5P_simple_t *sdim)
 {
-    uint32 ret_value = UFAIL;
+    intn ret_value = UFAIL;
 
-    FUNC_ENTER(H5P_get_lrank, H5P_init_interface, UFAIL);
+    FUNC_ENTER(H5P_get_lrank, UFAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
@@ -201,7 +582,7 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5P_get_lrank() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -209,7 +590,7 @@ done:
  PURPOSE
     Return the logical rank of a dataspace
  USAGE
-    uint32 H5P_get_lrank(sid)
+    intn H5P_get_lrank(sid)
         hid_t sid;            IN: ID of dataspace object to query
  RETURNS
     The logical rank of a dataspace on success, UFAIL on failure
@@ -219,12 +600,13 @@ done:
     dataspace, not the dimensionality of the space its embedded in.
     UFAIL is returned on an error, otherwise the rank is returned.
 --------------------------------------------------------------------------*/
-uint32 H5Pget_lrank(hid_t sid)
+intn
+H5Pget_lrank (hid_t sid)
 {
-    H5P_dim_t *space=NULL;      /* dataspace to modify */
-    uint32        ret_value = UFAIL;
+    H5P_t *space=NULL;      /* dataspace to modify */
+    intn        ret_value = UFAIL;
 
-    FUNC_ENTER(H5Pget_lrank, H5P_init_interface, UFAIL);
+    FUNC_ENTER(H5Pget_lrank, UFAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
@@ -232,7 +614,7 @@ uint32 H5Pget_lrank(hid_t sid)
     if((space=H5Aatom_object(sid))==NULL)
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
 
-    ret_value=H5P_get_lrank(space->s);
+    ret_value=H5P_get_lrank(&(space->u.simple));
 
 done:
   if(ret_value == UFAIL)
@@ -243,7 +625,7 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5Pget_lrank() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -252,8 +634,8 @@ done:
     Return the logical dimensions of a dataspace (internal)
  USAGE
     herr_t H5P_get_ldims(sdim, dims)
-        H5P_sdim_t *sdim;            IN: Pointer to dataspace object to query
-        uint32 *dims;                OUT: Pointer to array to store dimensions in
+        H5P_simple_t *sdim;            IN: Pointer to dataspace object to query
+        intn *dims;                OUT: Pointer to array to store dimensions in
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
@@ -261,18 +643,19 @@ done:
     dataspace.  The logical dimensions are the actual sizes of the
     dataspace, not the size of the space it is embedded in.
 --------------------------------------------------------------------------*/
-herr_t H5P_get_ldims(const H5P_sdim_t *sdim, uint32 *dims)
+herr_t
+H5P_get_ldims (const H5P_simple_t *sdim, intn *dims)
 {
     herr_t ret_value = FAIL;
 
-    FUNC_ENTER(H5P_get_ldims, H5P_init_interface, UFAIL);
+    FUNC_ENTER(H5P_get_ldims, UFAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
 
     assert(sdim);
     assert(dims);
-    HDmemcpy(dims, sdim->size,sdim->rank*sizeof(uint32));
+    HDmemcpy(dims, sdim->size,sdim->rank*sizeof(intn));
     ret_value=SUCCEED;
 
 #ifdef LATER
@@ -286,7 +669,7 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5P_get_ldims() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -296,7 +679,7 @@ done:
  USAGE
     herr_t H5P_get_ldims(sdim, dims)
         hid_t sid;            IN: ID of dataspace object to query
-        uint32 *dims;         OUT: Pointer to array to store dimensions in
+        intn *dims;         OUT: Pointer to array to store dimensions in
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
@@ -304,12 +687,12 @@ done:
     dataspace.  The logical dimensions are the actual sizes of the
     dataspace, not the size of the space it is embedded in.
 --------------------------------------------------------------------------*/
-herr_t H5Pget_ldims(hid_t sid, uint32 *dims)
+herr_t H5Pget_ldims(hid_t sid, intn *dims)
 {
-    H5P_dim_t *space=NULL;      /* dataspace to modify */
-    uint32        ret_value = UFAIL;
+    H5P_t *space=NULL;      /* dataspace to modify */
+    intn        ret_value = UFAIL;
 
-    FUNC_ENTER(H5Pget_lrank, H5P_init_interface, UFAIL);
+    FUNC_ENTER(H5Pget_lrank, UFAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
@@ -320,7 +703,7 @@ herr_t H5Pget_ldims(hid_t sid, uint32 *dims)
     if(dims==NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL);
 
-    ret_value=H5P_get_ldims(space->s,dims);
+    ret_value=H5P_get_ldims(&(space->u.simple),dims);
 
 done:
   if(ret_value == FAIL)
@@ -331,7 +714,7 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5Pget_ldims() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -340,40 +723,29 @@ done:
     Check if a dataspace is simple (internal)
  USAGE
     hbool_t H5P_is_simple(sdim)
-        H5P_sdim_t *sdim;            IN: Pointer to dataspace object to query
+        H5P_t *sdim;            IN: Pointer to dataspace object to query
  RETURNS
     BTRUE/BFALSE/BFAIL
  DESCRIPTION
         This function determines the if a dataspace is "simple". ie. if it
     has orthogonal, evenly spaced dimensions.
 --------------------------------------------------------------------------*/
-hbool_t H5P_is_simple(const H5P_dim_t *sdim)
+hbool_t
+H5P_is_simple (const H5P_t *sdim)
 {
     hbool_t ret_value = BFAIL;
 
-    FUNC_ENTER(H5P_is_simple, H5P_init_interface, UFAIL);
+    FUNC_ENTER(H5P_is_simple, UFAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
 
     assert(sdim);
-    if(sdim->type==H5P_TYPE_UNKNOWN)
-      {
-        HGOTO_ERROR (H5E_INTERNAL, H5E_UNINITIALIZED, FAIL);
-      }
-    else 
-        ret_value=sdim->type==H5P_TYPE_SIMPLE ? BTRUE : BFALSE; /* Currently all dataspaces are simple, but check anyway */
+    ret_value=sdim->type==H5P_SIMPLE ? BTRUE : BFALSE; /* Currently all dataspaces are simple, but check anyway */
 
-done:
-  if(ret_value == BFAIL)
-    { /* Error condition cleanup */
-
-    } /* end if */
-
-    /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5P_is_simple() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -391,10 +763,10 @@ done:
 --------------------------------------------------------------------------*/
 hbool_t H5Pis_simple(hid_t sid)
 {
-    H5P_dim_t *space=NULL;      /* dataspace to modify */
+    H5P_t *space=NULL;      /* dataspace to modify */
     hbool_t        ret_value = BFAIL;
 
-    FUNC_ENTER(H5Pis_simple, H5P_init_interface, BFAIL);
+    FUNC_ENTER(H5Pis_simple, BFAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
@@ -413,7 +785,7 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5Pis_simple() */
+}
 
 /*--------------------------------------------------------------------------
  NAME
@@ -423,8 +795,8 @@ done:
  USAGE
     herr_t H5Pset_space(sid, rank, dims)
         hid_t sid;            IN: Dataspace object to query
-        uint32 rank;            IN: # of dimensions for the dataspace
-        const uint32 *dims;     IN: Size of each dimension for the dataspace
+        intn rank;            IN: # of dimensions for the dataspace
+        const intn *dims;     IN: Size of each dimension for the dataspace
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
@@ -436,13 +808,13 @@ done:
     expand.  Currently, only the first dimension in the array (the slowest) may
     be unlimited in size.
 --------------------------------------------------------------------------*/
-herr_t H5Pset_space(hid_t sid, uint32 rank, const uint32 *dims)
+herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims)
 {
-    H5P_dim_t *space=NULL;      /* dataspace to modify */
-    uintn u;                    /* local counting variable */
+    H5P_t *space=NULL;      /* dataspace to modify */
+    intn u;                    /* local counting variable */
     herr_t        ret_value = SUCCEED;
 
-    FUNC_ENTER(H5Pset_space, H5P_init_interface, FAIL);
+    FUNC_ENTER(H5Pset_space, FAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
@@ -456,64 +828,62 @@ herr_t H5Pset_space(hid_t sid, uint32 rank, const uint32 *dims)
     /* shift out of the previous state to a "simple" dataspace */
     switch(space->type)
       {
-        case H5P_TYPE_UNKNOWN:
-            if((space->s=HDcalloc(sizeof(H5P_sdim_t),1))==NULL)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
-            break;
-
-        case H5P_TYPE_SIMPLE:
+        case H5P_SIMPLE:
             /* do nothing */
             break;
 
-        case H5P_TYPE_COMPLEX:
-            /* eventually this will destroy whatever "complex" dataspace info is retained, right now it's an error */
+        case H5P_COMPLEX:
+            /*
+	     * eventually this will destroy whatever "complex" dataspace info
+	     * is retained, right now it's an error
+	     */
             /* Fall through to report error */
 
         default:
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL);
       } /* end switch */
-    space->type=H5P_TYPE_SIMPLE;
+    space->type=H5P_SIMPLE;
 
     if(rank==0)
       { /* scalar variable */
-        space->s->rank=0;      /* set to scalar rank */
-        space->s->dim_flags=0; /* no maximum dimensions or dimension permutations */
-        if(space->s->size!=NULL)
-            space->s->size=H5MM_xfree(space->s->size);
-        if(space->s->max!=NULL)
-            space->s->max=H5MM_xfree(space->s->max);
-        if(space->s->perm!=NULL)
-            space->s->max=H5MM_xfree(space->s->perm);
+        space->u.simple.rank=0;      /* set to scalar rank */
+        space->u.simple.dim_flags=0; /* no maximum dimensions or dimension permutations */
+        if(space->u.simple.size!=NULL)
+            space->u.simple.size=H5MM_xfree(space->u.simple.size);
+        if(space->u.simple.max!=NULL)
+            space->u.simple.max=H5MM_xfree(space->u.simple.max);
+        if(space->u.simple.perm!=NULL)
+            space->u.simple.max=H5MM_xfree(space->u.simple.perm);
       } /* end if */
     else 
       {
         /* Reset the dataspace flags */
-        space->s->dim_flags=0;
+        space->u.simple.dim_flags=0;
 
         /* Free the old space for now */
-        if(space->s->size!=NULL)
-            space->s->size=H5MM_xfree(space->s->size);
-        if(space->s->max!=NULL)
-            space->s->max=H5MM_xfree(space->s->max);
-        if(space->s->perm!=NULL)
-            space->s->perm=H5MM_xfree(space->s->perm);
+        if(space->u.simple.size!=NULL)
+            space->u.simple.size=H5MM_xfree(space->u.simple.size);
+        if(space->u.simple.max!=NULL)
+            space->u.simple.max=H5MM_xfree(space->u.simple.max);
+        if(space->u.simple.perm!=NULL)
+            space->u.simple.perm=H5MM_xfree(space->u.simple.perm);
 
         /* Set the rank and copy the dims */
-        space->s->rank=rank;
-        if((space->s->size=HDcalloc(sizeof(uint32),rank))==NULL)
+        space->u.simple.rank=rank;
+        if((space->u.simple.size=HDcalloc(sizeof(intn),rank))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
-        HDmemcpy(space->s->size,dims,sizeof(uint32)*rank);
+        HDmemcpy(space->u.simple.size,dims,sizeof(intn)*rank);
 
         /* check if there are unlimited dimensions and create the maximum dims array */
-        for(u=0; u<(uintn)rank; u++)
+        for(u=0; u<rank; u++)
             if(dims[u]==0)
               {
                 if(u>0) /* sanity check for unlimited dimensions not in the lowest dimensionality */
                     HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
-                if((space->s->max=HDcalloc(sizeof(uint32),rank))==NULL)
+                if((space->u.simple.max=HDcalloc(sizeof(intn),rank))==NULL)
                     HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
-                HDmemcpy(space->s->max,dims,sizeof(uint32)*rank);
-                space->s->dim_flags|=H5P_VALID_MAX;
+                HDmemcpy(space->u.simple.max,dims,sizeof(intn)*rank);
+                space->u.simple.dim_flags|=H5P_VALID_MAX;
                 break;
               } /* end if */
       } /* end else */
@@ -527,191 +897,4 @@ done:
     /* Normal function cleanup */
 
     FUNC_LEAVE(ret_value);
-} /* end H5Pset_space() */
-
-/*--------------------------------------------------------------------------
- NAME
-    H5P_nelem
- PURPOSE
-    Return the number of elements in a dataspace (internal)
- USAGE
-    uintn H5P_nelem(space)
-        const H5P_dim_t *space;        IN: Pointer to the dataspace object to query
- RETURNS
-    The number of elements in a dataspace on success, UFAIL on failure
- DESCRIPTION
-        This function determines the number of dataset elements in a 
-    dataspace.  For example, a simple 3-dimensional dataspace with dimensions
-    2, 3 and 4 would have 24 elements.
-    UFAIL is returned on an error, otherwise the number of elements is returned.
---------------------------------------------------------------------------*/
-uintn H5P_nelem(const H5P_dim_t *space)
-{
-    uintn u;                    /* local counting variable */
-    uintn        ret_value = UFAIL;
-
-    FUNC_ENTER(H5P_nelem, H5P_init_interface, UFAIL);
-
-    /* Clear errors and check args and all the boring stuff. */
-    H5ECLEAR;
-
-    assert(space);
-
-    /* Check for anything but simple dataspaces for now */
-    if(space->type!=H5P_TYPE_SIMPLE)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
-    
-    /* Check for other form of scalar dataspaces */
-    if(space->s->rank==0)
-        ret_value=1;
-    else
-      {
-        for(ret_value=1, u=0; u<(uintn)space->s->rank; u++)
-            ret_value*=space->s->size[u];
-      } /* end else */
-
-done:
-  if(ret_value == UFAIL)
-    { /* Error condition cleanup */
-
-    } /* end if */
-
-    /* Normal function cleanup */
-
-    FUNC_LEAVE(ret_value);
-} /* end H5P_nelem() */
-
-/*--------------------------------------------------------------------------
- NAME
-    H5Pnelem
- PURPOSE
-    Return the number of elements in a dataspace
- USAGE
-    uintn H5Pnelem(sid)
-        hid_t sid;            IN: Dataspace object to query
- RETURNS
-    The number of elements in a dataspace on success, UFAIL on failure
- DESCRIPTION
-        This function determines the number of dataset elements in a 
-    dataspace.  For example, a simple 3-dimensional dataspace with dimensions
-    2, 3 and 4 would have 24 elements.
-    UFAIL is returned on an error, otherwise the number of elements is returned.
---------------------------------------------------------------------------*/
-uintn H5Pnelem(hid_t sid)
-{
-    H5P_dim_t *space=NULL;      /* dataspace to modify */
-    uintn        ret_value = UFAIL;
-
-    FUNC_ENTER(H5Pnelem, H5P_init_interface, UFAIL);
-
-    /* Clear errors and check args and all the boring stuff. */
-    H5ECLEAR;
-
-    if(sid==H5P_SCALAR)
-        ret_value=1;
-    else
-     {
-        if((space=H5Aatom_object(sid))==NULL)
-            HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
-        ret_value=H5P_nelem(space);
-     } /* end else */
-
-done:
-  if(ret_value == UFAIL)
-    { /* Error condition cleanup */
-
-    } /* end if */
-
-    /* Normal function cleanup */
-
-    FUNC_LEAVE(ret_value);
-} /* end H5Pnelem() */
-
-/*--------------------------------------------------------------------------
- NAME
-    H5P_destroy
- PURPOSE
-    Private function to destroy dataspace objects.
- USAGE
-    void H5P_destroy(dataspace)
-        void *dataspace;       IN: Pointer to dataspace object to destroy
- RETURNS
-    none
- DESCRIPTION
-    This function releases whatever memory is used by a dataspace object.
-    It should only be called from the atom manager when the reference count
-    for a dataspace drops to zero.
---------------------------------------------------------------------------*/
-void H5P_destroy(void *dataspace)
-{
-    H5P_dim_t *dim=(H5P_dim_t *)dataspace;  /* dimensionality object to release */
-
-    /* Don't call standard init/leave code, this is a private void function */
-    /* FUNC_ENTER(H5T_destroy, H5T_init_interface, FAIL); */
-
-    if(dim->type==H5P_TYPE_SIMPLE)
-      {
-        if(dim->s!=NULL)
-          {
-            if(dim->s->size!=NULL)
-                HDfree(dim->s->size);
-            if(dim->s->max!=NULL)
-                HDfree(dim->s->max);
-            if(dim->s->perm!=NULL)
-                HDfree(dim->s->perm);
-            HDfree(dim->s);
-          } /* end if */
-      } /* end if */
-    HDfree(dim);
-
-#ifdef LATER
-done:
-  if(ret_value == FAIL)   
-    { /* Error condition cleanup */
-
-    } /* end if */
-
-    /* Normal function cleanup */
-    FUNC_LEAVE(ret_value);
-#endif /* LATER */
-
-} /* H5P_destroy */
-
-/*--------------------------------------------------------------------------
- NAME
-    H5P_release
- PURPOSE
-    Release access to an HDF5 dimensionality object.
- USAGE
-    herr_t H5P_release(oid)
-        hid_t oid;       IN: Object to release access to
- RETURNS
-    SUCCEED/FAIL
- DESCRIPTION
-        This function releases a dimensionality from active use by a user.
---------------------------------------------------------------------------*/
-herr_t H5P_release(hid_t oid)
-{
-    herr_t        ret_value = SUCCEED;
-
-    FUNC_ENTER(H5P_release, H5P_init_interface, FAIL);
-
-    /* Clear errors and check args and all the boring stuff. */
-    H5ECLEAR;
-
-    /* Chuck the object! :-) */
-    if(H5Adec_ref(oid)==FAIL)
-        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
-
-done:
-  if(ret_value == FAIL)   
-    { /* Error condition cleanup */
-
-    } /* end if */
-
-    /* Normal function cleanup */
-
-    FUNC_LEAVE(ret_value);
-} /* end H5P_release() */
-
+}