[svn-r106] Fixed some symbol table bugs. Fixed a free memory read in H5Osdim.c.

17 files changed, 1778 insertions, 1185 deletions

diff --git a/src/H5AC.c b/src/H5AC.c
index 9dc49ed..d82cb6f 100644
--- a/src/H5AC.c
+++ b/src/H5AC.c
@@ -310,7 +310,8 @@ H5AC_compare (const void *_a, const void *_b)
  *
  * Return:	Success:	SUCCEED
  *
- *		Failure:	FAIL
+ *		Failure:	FAIL if there was a request to flush all
+ *				items and something was protected.
  *
  * Programmer:	Robb Matzke
  *		matzke@llnl.gov
@@ -374,6 +375,14 @@ H5AC_flush (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
       }
       map = H5MM_xfree (map);
 
+      /*
+       * If there are protected object then fail.  However, everything
+       * else should have been flushed.
+       */
+      if (f->cache->nprots>0) {
+	 HRETURN_ERROR (H5E_CACHE, H5E_PROTECT, FAIL);
+      }
+      
    } else if ((!type || f->cache->slot[i].type==type) &&
 	      f->cache->slot[i].addr==addr) {
       /*
@@ -389,14 +398,6 @@ H5AC_flush (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
 
    }
 
-   /*
-    * If there are protected objects then fail.  However, everything
-    * else should have been flushed.
-    */
-   if (f->cache->nprots>0) {
-      HRETURN_ERROR (H5E_CACHE, H5E_PROTECT, FAIL);
-   }
-
    FUNC_LEAVE (SUCCEED);
 }
 
diff --git a/src/H5D.c b/src/H5D.c
index 8566816..08dfd81 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -130,7 +130,6 @@ hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name)
     H5D_t *new_dset;        /* new dataset object to create */
     hatom_t ret_value = SUCCEED;
     hdf5_file_t *file = NULL;
-    H5G_entry_t	tmp_ent;
     
     FUNC_ENTER(H5D_create, H5D_init_interface, FAIL);
 
@@ -153,33 +152,11 @@ hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name)
     new_dset->data_addr = -1;		/* No data yet */
     new_dset->dirty = FALSE;		/* There are no messages yet */
 
-    /* Create the (empty) object header in the file */
-    memset (&tmp_ent, 0, sizeof(tmp_ent));
-    if ((tmp_ent.header = H5O_new (file, 0, H5D_MINHDR_SIZE))<0) {
-       HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create header*/
+    /* Open (and create) a new file object */
+    if (NULL==(new_dset->ent = H5G_create (file, name, H5D_MINHDR_SIZE))) {
+       HGOTO_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL);
     }
 
-    /*
-     * Link the (empty) object header into the symbol table so others can
-     * access it.  At least that way no one will try to create another one of
-     * these things with the same name.  We also hold the object open while
-     * H5D has a handle, preventing others from moving or deleting it from
-     * under us.
-     */
-#ifdef LATER
-    /* We should use the real CWD instead of always the root object! */
-#else
-    H5G_shadow_sync (file->root_sym);
-    if (H5G_insert (file, file->root_sym, NULL, name, &tmp_ent)<0) {
-       /* Something by that name already exists, or some other failure */
-       HGOTO_ERROR (H5E_SYM, H5E_EXISTS, FAIL);
-    }
-    if (NULL==(new_dset->ent = H5G_open (file, file->root_sym, name))) {
-       /* Can't open the header we just created -- should never happen */
-       HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
-    }
-#endif
-
     /* Register the new datatype and get an ID for it */
     if((ret_value=H5Aregister_atom(H5_DATASET, (const VOIDP)new_dset))<0)
         HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL);
@@ -236,22 +213,10 @@ hatom_t H5D_find_name(hatom_t grp_id, hobjtype_t type, const char *name)
     dset->file = file;
     dset->dirty = FALSE;
     
-#ifdef LATER
-    /* We should really use the real CWD instead of the root object! */
-#else
-    /*
-     *                     WARNING! WARNING! WARNING!
-     * The following line explicitly uses the root symbol as the current
-     * working directory.  This should be changed to something more
-     * appropriate and is only hacked in here to get the prototype working.
-     * -QAK
-     *                     WARNING! WARNING! WARNING!
-     */
-    H5G_shadow_sync (file->root_sym);
-    if (NULL==(dset->ent=H5G_open (file, file->root_sym, name))) {
+    /* Open the dataset object */
+    if (NULL==(dset->ent=H5G_open (file, name))) {
        HGOTO_ERROR (H5E_DATASET, H5E_NOTFOUND, FAIL);
     }
-#endif
 
     /* Get the dataset's type (currently only atomic types) */
     if((dset->type=HDcalloc(1,sizeof(h5_datatype_t)))==NULL)
@@ -422,7 +387,7 @@ done:
 herr_t H5Dread(hatom_t oid, hatom_t did, VOIDP buf)
 {
     H5D_t *dataset; /* dataset object to do I/O on */
-    void *readbuf;         /* pointer to buffer to write out */
+    void *readbuf=NULL;     /* pointer to buffer to write out */
     uintn   free_buf=0;     /* if temporary conversion buffer needs to be free'd */
     uintn   toread;         /* number of bytes to read in */
     herr_t  ret_value = SUCCEED;
@@ -507,7 +472,7 @@ herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf)
 {
     H5D_t *dataset;         /* dataset object to do I/O on */
     uintn   towrite;        /* number of bytes to write out */
-    void *writebuf;         /* pointer to buffer to write out */
+    void *writebuf=NULL;    /* pointer to buffer to write out */
     uintn   free_buf=0;     /* if temporary conversion buffer needs to be free'd */
     herr_t        ret_value = SUCCEED;
 
@@ -649,11 +614,6 @@ herr_t H5D_flush(hatom_t oid)
 	   }
 	}
 
-	/* Flush dataset header to disk -- just for debugging */
-	if (H5AC_flush (dataset->file, NULL, dataset->ent->header, FALSE)<0) {
-          HRETURN_ERROR (H5E_OHDR, H5E_CANTFLUSH, FAIL);
-       }
-       
 	dataset->dirty = FALSE;	/*it's clean now*/
     }
        
diff --git a/src/H5F.c b/src/H5F.c
index 6d1aec0..c3f0a66 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -395,11 +395,15 @@ H5F_new (void)
 {
    hdf5_file_t	*f = H5MM_xcalloc (1, sizeof(hdf5_file_t));
 
-   /* Create a cache */
+   /* Create a main cache */
    H5AC_new (f, H5AC_NSLOTS);
 
+   /* Create the shadow hash table */
+   f->nshadows = H5G_NSHADOWS;
+   f->shadow = H5MM_xcalloc (f->nshadows, sizeof(struct H5G_hash_t*));
+
    /* Create a root symbol slot */
-   f->root_sym = H5G_new_entry ();
+   f->root_sym = H5G_ent_calloc ();
    
    return f;
 }
@@ -434,6 +438,8 @@ H5F_dest (hdf5_file_t *f)
       f->dir = H5MM_xfree (f->dir);
       f->filename = H5MM_xfree (f->filename);
       f->root_sym = H5MM_xfree (f->root_sym);
+      f->nshadows = 0;
+      f->shadow = H5MM_xfree (f->shadow);
       H5MM_xfree (f);
    }
    return NULL;
@@ -777,7 +783,7 @@ hatom_t H5Fopen(const char *filename, uintn flags, hatom_t access_temp)
     H5F_decode_length(new_file,p,new_file->logical_len); /* Decode logical length of file */
 
     /* Decode the root symbol table entry */
-    if (H5G_decode (new_file, &p, new_file->root_sym)<0) {
+    if (H5G_ent_decode (new_file, &p, new_file->root_sym)<0) {
        /*can't decode root symbol table entry */
        HGOTO_ERROR (H5E_IO, H5E_READERROR, FAIL);
     }
@@ -870,6 +876,8 @@ H5Fflush (hatom_t fid, hbool_t invalidate)
  * Return:	Success:	SUCCEED
  *
  *		Failure:	FAIL
+ *				-2 if the there are open objects and
+ * 				INVALIDATE was non-zero.
  *
  * Programmer:	Robb Matzke
  *		robb@maya.nuance.com
@@ -883,12 +891,19 @@ static herr_t
 H5F_flush (hdf5_file_t *f, hbool_t invalidate)
 {
    uint8	buf[2048], *p=buf;
+   herr_t	shadow_flush;
    
    FUNC_ENTER (H5F_flush, H5F_init_interface, FAIL);
 
    /* nothing to do if the file is read only */
    if (0==(H5ACC_WRITE & f->acc_perm)) HRETURN (SUCCEED);
 
+   /*
+    * Flush all open object info. If this fails just remember it and return
+    * failure at the end.  At least that way we get a consistent file.
+    */
+   shadow_flush = H5G_shadow_flush (f,  invalidate);
+      
    /* flush (and invalidate) the entire cache */
    if (H5AC_flush (f, NULL, 0, invalidate)<0) {
       HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL); /*can't flush cache*/
@@ -912,7 +927,7 @@ H5F_flush (hdf5_file_t *f, hbool_t invalidate)
    H5F_encode_offset (f, p, f->smallobj_off);
    H5F_encode_offset (f, p, f->freespace_off);
    H5F_encode_length (f, p, f->logical_len);
-   H5G_encode (f, &p, f->root_sym);
+   H5G_ent_encode (f, &p, f->root_sym);
 
    /* write the boot block to disk */
    if (H5F_block_write (f, 0, p-buf, buf)<0) {
@@ -922,6 +937,11 @@ H5F_flush (hdf5_file_t *f, hbool_t invalidate)
    /* update file length if necessary */
    if (f->logical_len<=0) f->logical_len = p-buf;
 
+   /* Did shadow flush fail above? */
+   if (shadow_flush<0) {
+      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, -2);/*object are still open*/
+   }
+   
    FUNC_LEAVE (SUCCEED);
 }
 
@@ -978,7 +998,9 @@ herr_t H5Fclose(hatom_t fid)
     if((--file->ref_count)==0)
       {
         if(file->file_handle!=H5F_INVALID_FILE) {
-	   if (H5F_flush (file, TRUE)<0) {
+	   if (-2==(ret_value=H5F_flush (file, TRUE))) {
+	      /*objects are still open*/
+	   } else if (ret_value<0) {
 	      /*can't flush cache*/
 	      HGOTO_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
 	   }
@@ -990,6 +1012,11 @@ herr_t H5Fclose(hatom_t fid)
         }
       } /* end if */
 
+      /* Did the H5F_flush() fail because of open objects? */
+      if (ret_value<0) {
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL);
+      }
+	
 done:
   if(ret_value == FAIL)   
     { /* Error condition cleanup */
@@ -1180,7 +1207,7 @@ H5F_debug (hdf5_file_t *f, haddr_t addr, FILE *stream, intn indent,
 	    (unsigned)(f->file_create_parms.sharedheader_ver));
 
    fprintf (stream, "%*sRoot symbol table entry:\n", indent, "");
-   H5G_debug (f, f->root_sym, stream, indent+3, MAX(0, fwidth-3));
+   H5G_ent_debug (f, f->root_sym, stream, indent+3, MAX(0, fwidth-3));
 	    
    FUNC_LEAVE (SUCCEED);
 }
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index f1c7b59..08cfd8f 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -352,6 +352,8 @@ typedef struct {
     file_access_temp_t file_access_parms; /* File-access template	*/
 #endif
     struct H5G_entry_t *root_sym; /* Root symbol table entry		*/
+    uintn nshadows;		/* Size of shadow hash table		*/
+    struct H5G_hash_t **shadow; /* The shadow hash table		*/
   } hdf5_file_t;
 
 
diff --git a/src/H5G.c b/src/H5G.c
index 88c8576..0c38a00 100644
--- a/src/H5G.c
+++ b/src/H5G.c
@@ -47,11 +47,10 @@
 #define H5G_INIT_HEAP		8192
 #define PABLO_MASK		H5G_mask
 
-static herr_t H5G_mkroot (hdf5_file_t *f, size_t size_hint);
-
 /* Is the interface initialized? */
 static hbool_t interface_initialize_g = FALSE;
 
+
 
 /*-------------------------------------------------------------------------
  * Function:	H5G_component
@@ -315,6 +314,8 @@ H5G_namei (hdf5_file_t *f, H5G_entry_t *cwd, const char *name,
  *		is removed).  If the root object doesn't have a name message
  *		then the name `Root Object' is used.
  *
+ * Warning:	This function has a few subtleties. Be warned!
+ *
  * Errors:
  *		DIRECTORY CANTINIT      Can't create root. 
  *		DIRECTORY CANTINIT      Can't insert old root object in
@@ -323,7 +324,9 @@ H5G_namei (hdf5_file_t *f, H5G_entry_t *cwd, const char *name,
  *
  * Return:	Success:	SUCCEED
  *
- *		Failure:	FAIL
+ *		Failure:	FAIL.  This function returns -2 if the
+ *				failure is because a root directory already
+ *				exists.
  *
  * Programmer:	Robb Matzke
  *		robb@maya.nuance.com
@@ -336,104 +339,103 @@ H5G_namei (hdf5_file_t *f, H5G_entry_t *cwd, const char *name,
 static herr_t
 H5G_mkroot (hdf5_file_t *f, size_t size_hint)
 {
+   H5G_entry_t	*handle=NULL;		/*handle to open object		*/
+   herr_t	ret_value=FAIL;		/*return value			*/
+   H5O_name_t	name={NULL};		/*object name			*/
    H5O_stab_t	stab;			/*symbol table message		*/
-   H5O_name_t	name={0};		/*object name message		*/
-   H5G_entry_t	root;			/*old root entry		*/
-   const char	*root_name=NULL;	/*name of old root object	*/
-   intn		nlinks;			/*number of links		*/
-   H5G_entry_t	*handle;		/*handle for open object	*/
+   H5G_entry_t	*ent_ptr=NULL;		/*pointer to a symbol table entry*/
+   const char	*obj_name=NULL;		/*name of old root object	*/
    
    FUNC_ENTER (H5G_mkroot, NULL, FAIL);
 
    /*
-    * Make sure we have the latest info since someone might have the root
-    * object open for modifications.
+    * Make sure that the file descriptor has the latest info -- someone might
+    * have the root object open.
     */
    H5G_shadow_sync (f->root_sym);
    
    /*
-    * Is there already a root object that needs to move into the new
-    * root symbol table?  The root object is a symbol table if we can
-    * read the H5O_STAB message.
+    * If we already have a root object, then open it and get it's name. The
+    * root object had better not already be a directory.  Once the old root
+    * object is opened and we have a HANDLE, set the dirty bit on the handle.
+    * This causes the handle data to be written back into f->root_sym by
+    * H5G_close() if something goes wrong before the old root object is
+    * re-inserted back into the directory hierarchy.  We might leak file
+    * memory, but at least we don't loose the original root object.
     */
    if (f->root_sym->header>0) {
       if (H5O_read (f, NO_ADDR, f->root_sym, H5O_STAB, 0, &stab)) {
 	 /* root directory already exists */
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_EXISTS, FAIL);
-	 
-      } else if (H5O_read (f, f->root_sym->header, f->root_sym, H5O_NAME,
-			   0, &name)) {
-	 root_name = name.s; /*dont reset name until root_name is done!*/
-	 root = *(f->root_sym);
-	 
+	 HGOTO_ERROR (H5E_DIRECTORY, H5E_EXISTS, -2);
+      } else if (NULL==(handle=H5G_shadow_open (f, NULL, f->root_sym))) {
+	 /* can't open root object */
+	 HGOTO_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL);
+      } else if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &name)) {
+	 obj_name = "Root Object";
       } else {
-	 root = *(f->root_sym);
-	 root_name = "Root Object";
+	 obj_name = name.s; /*don't reset message until the end!*/
       }
+      handle->dirty = TRUE;
    }
 
    /*
-    * Create the root directory.
+    * Create the new root directory directly into the file descriptor. If
+    * something goes wrong at this step, closing the `handle' will rewrite
+    * info back into f->root_sym because we set the dirty bit.
     */
    if (H5G_stab_new (f, f->root_sym, size_hint)<0) {
-      H5O_reset (H5O_NAME, &name);
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL); /*can't create root*/
+      HGOTO_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL); /*cant create root*/
+   }
+   if (1!=H5O_link (f, f->root_sym, 1)) {
+      HGOTO_ERROR (H5E_DIRECTORY, H5E_LINK, FAIL);
    }
 
    /*
-    * Increase the link count for the root symbol table!
-    */
-   nlinks = H5O_link (f, f->root_sym->header, f->root_sym, 1);
-   assert (1==nlinks);
-
-   /*
-    * Insert the old root object.  It should already have a link count
-    * of 1.
+    * If there was a previous root object then insert it into the new root
+    * symbol table with the specified name.  Inserting the object will update
+    * the handle to point to the new symbol table slot instead of f->root_sym.
     */
-   if (root_name) {
-
-#ifndef NDEBUG
-      nlinks = H5O_link (f, root.header, &root, 0);
-      assert (1==nlinks);
-#endif
-      if (H5G_stab_insert (f, f->root_sym, root_name, &root)<0) {
-	 /*
-	  * This should never happen.  If it does and the root object is
-	  * open, then bad things are going to happen because we've just
-	  * deleted the symbol table entry for the open root object!
-	  */
-#ifndef NDEBUG
-	 abort ();
-#endif
-
-	 /* can't insert old root object in new root directory */
-	 H5O_reset (H5O_NAME, &name);
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL);
+   if (obj_name) {
+      if (1!=H5O_link (f, handle, 0)) {
+	 HGOTO_ERROR (H5E_DIRECTORY, H5E_LINK, FAIL);
       }
-
-      /* remove all name messages -- don't care if it fails */
-      if ((handle = H5G_open (f, f->root_sym, root_name))) {
-	 H5O_remove (f, NO_ADDR, handle, H5O_NAME, H5O_ALL);
-	 H5G_shadow_close (f, handle);
-	 handle = NULL;
+      if (NULL==(ent_ptr=H5G_stab_insert (f, f->root_sym, obj_name,
+					  handle))) {
+	 HGOTO_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL);
       }
-      H5ECLEAR;
+      
+      /*
+       * Remove all `name' messages from the old root object.  The only time
+       * a name message should ever appear is to give the root object a name,
+       * but the old root object is no longer the root object.
+       */
+      H5O_remove (f, NO_ADDR, handle, H5O_NAME, H5O_ALL);
+      H5ECLEAR; /*who really cares?*/
    }
-
+   
+   ret_value = SUCCEED;
+   
+ done:
+   /*
+    * If the handle is closed before the H5G_stab_insert() call that
+    * reinserts the root object into the directory hierarchy, then
+    * H5G_close() will reset f->root_sym to point to the old root symbol and
+    * the new root directory (if it was created) will be unlinked from the
+    * directory hierarchy (and memory leaked).
+    */
+   if (handle) H5G_close (f, handle);
    H5O_reset (H5O_NAME, &name);
-   FUNC_LEAVE (SUCCEED);
+   
+   FUNC_LEAVE (ret_value);
 }
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_new
+ * Function:	H5G_mkdir
  *
- * Purpose:	Creates a new empty directory with the specified name.  The
- *		name is either an absolute name or is relative to the
- *		directory whose symbol table entry is CWD. On return, the
- *		optional DIR_ENT pointer is initialized with the symbol
- *		table entry for the new directory's parent and ENT will
- *		contain the symbol table entry for the new directory.
+ * Purpose: 	Creates a new empty directory with the specified name,
+ *		opening it as an object. The name is either an absolute name
+ *		or is relative to the current working directory.
  *
  * 		A root directory is created implicitly by this function
  *		when necessary.  Calling this function with the name "/"
@@ -448,12 +450,10 @@ H5G_mkroot (hdf5_file_t *f, size_t size_hint)
  *		DIRECTORY EXISTS        Already exists. 
  *		DIRECTORY NOTFOUND      Missing component. 
  *
- * Return:	Success:	SUCCEED, if DIR_ENT is not the null pointer
- *				then it will be initialized with the
- *				symbol table entry for the new directory.
+ * Return:	Success:	A handle to the open directory.  Please call
+ *				H5G_close() when you're done with it.
  *
- *		Failure:	FAIL, the memory pointed to by CWD is
- *				not modified.
+ *		Failure:	NULL
  *
  * Programmer:	Robb Matzke
  *		robb@maya.nuance.com
@@ -463,31 +463,43 @@ H5G_mkroot (hdf5_file_t *f, size_t size_hint)
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5G_new (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
-	 const char *name, size_t size_hint, H5G_entry_t *ent)
+H5G_entry_t *
+H5G_mkdir (hdf5_file_t *f, const char *name, size_t size_hint)
 {
-   const char	*rest=NULL;
-   H5G_entry_t	_parent, _child;
-   char		_comp[1024];
-   size_t	nchars;
+   const char	*rest=NULL;		/*the base name			*/
+   H5G_entry_t	*cwd=NULL;		/*current working directory	*/
+   H5G_entry_t	dir_ent;		/*directory containing new dir	*/
+   H5G_entry_t	ent;			/*new directory entry		*/
+   H5G_entry_t	*ent_ptr=NULL;		/*ptr to new directory entry	*/
+   H5G_entry_t	*ret_value=NULL;	/*handle return value		*/
+   char		_comp[1024];		/*name component		*/
+   size_t	nchars;			/*number of characters in compon*/
+   herr_t	status;			/*function return status	*/
    
-   FUNC_ENTER (H5G_new, NULL, FAIL);
+   FUNC_ENTER (H5G_mkdir, NULL, NULL);
 
    /* check args */
    assert (f);
    assert (name && *name);
+#ifndef LATER
+   /* Get current working directory */
+   H5G_shadow_sync (f->root_sym);
+   cwd = f->root_sym;
+#endif
    assert (cwd || '/'==*name);
-   if (!dir_ent) dir_ent = &_parent;
-   if (!ent) ent = &_child;
 
-   /* Create root directory if necessary */
-   H5G_mkroot (f, H5G_SIZE_HINT);
+   /*
+    * Try to create the root directory.  Ignore the error if this function
+    * fails because the root directory already exists.
+    */
+   if ((status=H5G_mkroot (f, H5G_SIZE_HINT))<0 && -2!=status) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL);
+   }
    H5ECLEAR;
 
    /* lookup name */
-   if (H5G_namei (f, cwd, name, &rest, dir_ent)) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_EXISTS, FAIL); /*already exists*/
+   if (H5G_namei (f, cwd, name, &rest, &dir_ent)) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_EXISTS, NULL); /*already exists*/
    }
    H5ECLEAR; /*it's OK that we didn't find it*/
 
@@ -497,10 +509,10 @@ H5G_new (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
    if (rest[nchars]) {
       if (H5G_component (rest+nchars, NULL)) {
 	 /* missing component */
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, FAIL);
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, NULL);
       } else if (nchars+1 > sizeof _comp) {
 	 /* component is too long */
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_COMPLEN, FAIL);
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_COMPLEN, NULL);
       } else {
 	 /* null terminate */
 	 HDmemcpy (_comp, rest, nchars);
@@ -510,266 +522,165 @@ H5G_new (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
    }
    
    /* create directory */
-   if (H5G_stab_new (f, ent, size_hint)<0) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL); /*can't create dir*/
+   if (H5G_stab_new (f, &ent, size_hint)<0) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL); /*can't create dir*/
    }
 
    /* insert child name into parent */
-   if (H5G_stab_insert (f, dir_ent, rest, ent)<0) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL); /*can't insert*/
+   if (NULL==(ent_ptr=H5G_stab_insert (f, &dir_ent, rest, &ent))) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL); /*can't insert*/
    }
 
-   FUNC_LEAVE (SUCCEED);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5G_open
- *
- * Purpose:	Opens an object.  That is, it prepares the object for
- *		modification by returning a handle to the object
- *		symbol table entry. Opening an object twice with the
- *		same name (or more precisely, through the same final
- *		symbol table entry) will return pointers to the same
- *		H5G_entry_t struct. But opening an object through
- *		different final H5G_entry_t structs (which implies
- *		different names) returns pointers to different
- *		structs.  The structs that are returned should be
- *		released by calling H5G_close().
- *
- * Return:	Success:	Ptr to a handle for the object.
- *
- *		Failure:	NULL
- *
- * Programmer:	Robb Matzke
- *              Wednesday, September 17, 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-H5G_entry_t *
-H5G_open (hdf5_file_t *f, H5G_entry_t *cwd, const char *name)
-{
-   H5G_entry_t	*ent=NULL;
-   H5G_entry_t	*handle=NULL;
-   H5G_entry_t	dir;
-
-   FUNC_ENTER (H5G_open, NULL, NULL);
-
-   /* check args */
-   assert (f);
-   assert (name && *name);
-   assert (cwd || '/'==*name);
-
-   if (f->root_sym->header<=0) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, NULL); /*object not found*/
-   }
-
-   if (NULL==(ent=H5G_namei (f, cwd, name, NULL, &dir))) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, NULL); /*object not found*/
-   }
-
-   if (NULL==(handle=H5G_shadow_open (f, &dir, ent))) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTOPENOBJ, NULL);
+   /* open the directory */
+   if (NULL==(ret_value=H5G_shadow_open (f, &dir_ent, ent_ptr))) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL); /*can't open*/
    }
 
-   FUNC_LEAVE (handle);
+   FUNC_LEAVE (ret_value);
 }
 
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_close
+ * Function:	H5G_pushd
  *
- * Purpose:	Closes an object that was open for modification.
+ * Purpose:	Pushes a new current working directory onto the stack.
  *
  * Return:	Success:	SUCCEED
  *
  *		Failure:	FAIL
  *
  * Programmer:	Robb Matzke
- *              Thursday, September 18, 1997
+ *              Friday, September 19, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_close (hdf5_file_t *f, H5G_entry_t *ent)
+H5G_pushd (hdf5_file_t *f, const char *name)
 {
-   FUNC_ENTER (H5G_close, NULL, FAIL);
+   FUNC_ENTER (H5G_pushd, NULL, FAIL);
 
-   if (H5G_shadow_close (f,  ent)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL);
+#ifndef LATER
+   /*
+    * Current working directories are not implemented yet.
+    */
+   if (strcmp (name, "/")) {
+      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
    }
+#endif
    
    FUNC_LEAVE (SUCCEED);
 }
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_find
- *
- * Purpose:	Finds an object with the specified NAME in file F.  If
- *		the name is relative then it is interpretted relative
- *		to CWD, a symbol table entry for a symbol table.  On
- *		successful return, DIR_ENT (if non-null) will be
- *		initialized with the symbol table information for the
- *		directory in which the object appears (or all zero if
- *		the returned object is the root object) and ENT will
- *		be initialized with the symbol table entry for the
- *		object (ENT is optional when the caller is interested
- *		only in the existence of the object).
+ * Function:	H5G_popd
  *
- * 		This function will fail if the root object is
- * 		requested and there is none.
- *
- * Errors:
- *		DIRECTORY NOTFOUND      Object not found. 
+ * Purpose:	Pops the top current working directory off the stack.
  *
- * Return:	Success:	SUCCEED with DIR_ENT and ENT initialized. ENT
- *				is intended for immediate read-only access.
- *				If the object that ENT refers to is open
- *				through the ENT entry (see H5G_open()) then
- *				the returned ENT will contain the latest
- *				information.  However, subsequent changes to
- *				the symbol table entry will not be reflected
- *				in ENT since it is a copy of the symbol table.
+ * Return:	Success:	SUCCEED
  *
  *		Failure:	FAIL
  *
  * Programmer:	Robb Matzke
- *		robb@maya.nuance.com
- *		Aug 12 1997
+ *              Friday, September 19, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_find (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
-	  const char *name, H5G_entry_t *ent)
+H5G_popd (hdf5_file_t *f)
 {
-   H5G_entry_t	*ent_p = NULL;
-   FUNC_ENTER (H5G_find, NULL, FAIL);
-
-   /* check args */
-   assert (f);
-   assert (name && *name);
-   assert (cwd || '/'==*name);
-
-   if (f->root_sym->header<=0) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, FAIL); /*object not found*/
-   }
+   FUNC_ENTER (H5G_popd, NULL, FAIL);
 
-   if (NULL==(ent_p=H5G_namei (f, cwd, name, NULL, dir_ent))) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, FAIL); /*object not found*/
-   }
+#ifndef LATER
+   /* CWD is not implemented yet. */
+#endif
 
-   if (ent) *ent = *ent_p;
    FUNC_LEAVE (SUCCEED);
 }
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_insert
- *
- * Purpose:	Inserts symbol table ENT into the directory hierarchy
- *		giving it the specified NAME.  If NAME is relative then
- *		it is interpreted with respect to the CWD pointer.  If
- *		non-null, DIR_ENT will be initialized with the symbol table
- *		entry for the directory which contains the new ENT (or all
- *		zero if the new ENT is the root object).
- *
- * 		This function attempts to use a non-directory file if
- * 		the file contains just one object.  The one object
- * 		will be the root object.
- *
- * 		Inserting an object entry into the symbol table increments
- *		the link counter for that object.
+ * Function:	H5G_create
  *
- * Errors:
- *		DIRECTORY CANTINIT      Can't insert. 
- *		DIRECTORY CANTINIT      Cannot add/change name message. 
- *		DIRECTORY CANTINIT      Lookup failed. 
- *		DIRECTORY COMPLEN       Component is too long. 
- *		DIRECTORY EXISTS        Already exists. 
- *		DIRECTORY EXISTS        Root exists. 
- *		DIRECTORY LINK          Bad link count. 
- *		DIRECTORY LINK          Link inc failure. 
- *		DIRECTORY NOTFOUND      Component not found. 
+ * Purpose:	Creates a new empty object header, gives it a name, opens
+ *		the object for modification, and returns a handle to the
+ *		object.  The initial size of the object header can be
+ *		supplied with the OHDR_HINT argument.
  *
- * Return:	Success:	SUCCEED with optional DIR_ENT initialized with
- *				the symbol table entry for the directory
- *				which contains the new ENT.
+ * Return:	Success:	A handle for the object.  Be sure to
+ *				eventually close it.
  *
- *		Failure:	FAIL (DIR_ENT is not modified).
+ *		Failure:	FAIL
  *
  * Programmer:	Robb Matzke
- *		robb@maya.nuance.com
- *		Aug 11 1997
+ *              Friday, September 19, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5G_insert (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
-	    const char *name, H5G_entry_t *ent)
+H5G_entry_t *
+H5G_create (hdf5_file_t *f, const char *name, size_t ohdr_hint)
 {
-   const char	*rest=NULL;
-   H5G_entry_t	_parent;
-   size_t	nchars;
-   char		_comp[1024];
-   H5O_stab_t	stab;
+   H5G_entry_t	ent;			/*entry data for the new object	*/
+   H5G_entry_t	*ent_ptr;		/*ptr into symbol node for entry*/
+   H5G_entry_t	*cwd=NULL;		/*ptr to CWD handle		*/
+   const char	*rest = NULL;		/*part of name not existing yet	*/
+   H5G_entry_t	dir;			/*entry for dir to contain obj	*/
+   H5G_entry_t	*ret_value=NULL;	/*the object handle		*/
+   size_t	nchars;			/*number of characters in name	*/
+   char		_comp[1024];		/*name component		*/
    
-   FUNC_ENTER (H5G_insert, NULL, FAIL);
+   FUNC_ENTER (H5G_create, NULL, NULL);
 
-   /* check args */
+   /* Check args. */
    assert (f);
    assert (name && *name);
-   assert (cwd || '/'==*name);
-   assert (ent);
-   assert (!ent->shadow);
-   if (!dir_ent) dir_ent = &_parent;
-   
+   HDmemset (&ent, 0, sizeof(H5G_entry_t));
+
    /*
-    * If there's already an object or if this object is a directory then
-    * create a root directory. The object is a directory if we can read
-    * the symbol table message from its header.  H5G_mkroot() fails if
-    * the root object is already a directory, but we don't care.
+    * Get the current working directory.
     */
-   if (f->root_sym->header>0 ||
-       H5O_read (f, ent->header, ent, H5O_STAB, 0, &stab)) {
-      H5G_mkroot (f, H5G_SIZE_HINT);
-      H5ECLEAR;
-   }
+#ifndef LATER
+   H5G_shadow_sync (f->root_sym);
+   cwd = f->root_sym;
+#endif
 
    /*
     * Look up the name -- it shouldn't exist yet.
     */
-   if (H5G_namei (f, cwd, name, &rest, dir_ent)) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_EXISTS, FAIL); /*already exists*/
+   if (H5G_namei (f, cwd, name, &rest, &dir)) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_EXISTS, NULL); /*already exists*/
    }
    H5ECLEAR; /*it's OK that we didn't find it*/
-
-   /*
-    * The caller may be attempting to insert a root object that either
-    * doesn't have a name or we shouldn't interfere with the name
-    * it already has.
-    */
    rest = H5G_component (rest, &nchars);
+
    if (!rest || !*rest) {
+      /*
+       * The caller is attempting to insert a root object that either
+       * doesn't have a name or we shouldn't interfere with the name
+       * it already has as a message.
+       */
       if (f->root_sym->header>0) {
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_EXISTS, FAIL); /*root exists*/
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_EXISTS, NULL); /*root exists*/
+      }
+      if ((ent.header = H5O_new (f, 0, ohdr_hint))<0) {
+	 /* can't create header */
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL);
       }
-      HDmemset (dir_ent, 0, sizeof(H5G_entry_t));
-      if (1!=H5O_link (f, ent->header, ent, 1)) {
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_LINK, FAIL); /*bad link count*/
+      if (1!=H5O_link (f, &ent, 1)) {
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_LINK, NULL); /*bad link count*/
       }
-      *(f->root_sym) = *ent;
-      HRETURN (SUCCEED);
+      *(f->root_sym) = ent;
+      if (NULL==(ret_value=H5G_shadow_open (f, &dir, f->root_sym))) {
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL);
+      }
+      HRETURN (ret_value);
    }
 
    /*
@@ -779,10 +690,10 @@ H5G_insert (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
    if (rest[nchars]) {
       if (H5G_component (rest+nchars, NULL)) {
 	 /* component not found */
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, FAIL);
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, NULL);
       } else if (nchars+1 > sizeof _comp) {
 	 /* component is too long */
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_COMPLEN, FAIL);
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_COMPLEN, NULL);
       } else {
 	 /* null terminate */
 	 HDmemcpy (_comp, rest, nchars);
@@ -792,654 +703,219 @@ H5G_insert (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
    }
 
    /*
-    * If this is the only object then insert it as the root object.  Add
-    * a name messaage to the object header (or modify the first one we
-    * find).  We don't have to worry about it being open.
+    * Create the object header.
     */
+   if ((ent.header = H5O_new (f, 0, ohdr_hint))<0) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL);
+   }
+   
+
    if (f->root_sym->header<=0) {
+      /*
+       * This will be the only object in the file. Insert it as the root
+       * object and add a name messaage to the object header (or modify
+       * the first one we find). Although the header exists we can guarantee
+       * that it isn't open since it has no name.
+       */
       H5O_name_t name_mesg;
       name_mesg.s = rest;
-      if (H5O_modify (f, NO_ADDR, ent, H5O_NAME, 0, &name_mesg)<0) {
+      if (H5O_modify (f, NO_ADDR, &ent, H5O_NAME, 0, &name_mesg)<0) {
 	 /* cannot add/change name message */
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL);
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL);
       }
-      if (1!=H5O_link (f, ent->header, ent, 1)) {
-	 HRETURN_ERROR (H5E_DIRECTORY, H5E_LINK, FAIL); /*bad link count*/
+      if (1!=H5O_link (f, &ent, 1)) {
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_LINK, NULL); /*bad link count*/
       }
-      *(f->root_sym) = *ent;
-      HRETURN (SUCCEED);
-   }
-   
-   /* increment the link count */
-   if (H5O_link (f, ent->header, ent, 1)<0) {
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_LINK, FAIL); /*link inc failure*/
-   }
-
-   /* insert entry into parent */
-   if (H5G_stab_insert (f, dir_ent, rest, ent)<0) {
-      H5O_link (f, ent->header, ent, -1); /*don't care if it fails*/
-      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, FAIL); /*can't insert*/
-   }
-      
-   FUNC_LEAVE (SUCCEED);
-}
-   
-
-/*-------------------------------------------------------------------------
- * Function:	H5G_stab_new
- *
- * Purpose:	Creates a new empty symbol table (object header, name heap,
- *		and B-tree).  The caller can specify an initial size for the
- *		name heap.
- *
- * 		In order for the B-tree to operate correctly, the first
- *		item in the heap is the empty string, and must appear at
- *		heap offset zero.
- *
- * Errors:
- *		INTERNAL  CANTINIT      B-tree's won't work if the first
- *		                        name isn't at the beginning of the
- *		                        heap. 
- *		SYM       CANTINIT      Can't create B-tree. 
- *		SYM       CANTINIT      Can't create header. 
- *		SYM       CANTINIT      Can't create heap. 
- *		SYM       CANTINIT      Can't create message. 
- *		SYM       CANTINIT      Can't initialize heap. 
- *
- * Return:	Success:	Address of new symbol table header.  If
- *				the caller supplies a symbol table entry
- *				SELF then it will be initialized to point to
- *				this symbol table.
- *
- *		Failure:	FAIL
- *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug  1 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-haddr_t
-H5G_stab_new (hdf5_file_t *f, H5G_entry_t *self, size_t init)
-{
-   off_t	name;				/*offset of "" name	*/
-   haddr_t	addr;				/*object header address	*/
-   H5O_stab_t	stab;				/*symbol table message	*/
-
-   FUNC_ENTER (H5G_stab_new, NULL, FAIL);
-
-   /*
-    * Check arguments.
-    */
-   assert (f);
-   init = MAX(init, H5H_SIZEOF_FREE(f)+2);
-
-   /* Create symbol table private heap */
-   if ((stab.heap_addr = H5H_new (f, H5H_LOCAL, init))<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create heap*/
-   }
-   if ((name = H5H_insert (f, stab.heap_addr, 1, "")<0)) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't initialize heap*/
-   }
-   if (0!=name) {
+      *(f->root_sym) = ent;
+      if (NULL==(ret_value=H5G_shadow_open (f, &dir, f->root_sym))) {
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL);
+      }
+      HRETURN (ret_value);
+   } else {
       /*
-       * B-tree's won't work if the first name isn't at the beginning
-       * of the heap.
+       * Make sure the root directory exists.  Ignore the failure if it's
+       * because the directory already exists.
        */
-      HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL);
-   }
-
-   /* Create the B-tree */
-   if ((stab.btree_addr = H5B_new (f, H5B_SNODE))<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create B-tree*/
+      hbool_t update_dir = (dir.header==f->root_sym->header);
+      herr_t status = H5G_mkroot (f, H5G_SIZE_HINT);
+      if (status<0 && -2!=status) {
+	 HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL);
+      }
+      H5ECLEAR;
+      if (update_dir) dir = *(f->root_sym);
    }
-
+   
    /*
-    * Create symbol table object header.  It has a zero link count
-    * since nothing refers to it yet.  The link count will be
-    * incremented if the object is added to the directory hierarchy.
+    * This is the normal case.  The object is just being inserted as a normal
+    * entry into a symbol table.
     */
-   if ((addr = H5O_new (f, 0, 4+2*H5F_SIZEOF_OFFSET(f)))<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create header*/
+   if (H5O_link (f, &ent, 1)<0) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_LINK, NULL); /*link inc failure*/
    }
-   
-   /* insert the symbol table message */
-   if (self) {
-      memset (self, 0, sizeof(H5G_entry_t));
-      self->header = addr;
+   if (NULL==(ent_ptr=H5G_stab_insert (f, &dir, rest, &ent))) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL); /*can't insert*/
    }
-   if (H5O_modify(f, addr, self, H5O_STAB, H5O_NEW_MESG, &stab)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create message*/
+   if (NULL==(ret_value=H5G_shadow_open (f, &dir, ent_ptr))) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTINIT, NULL); /*can't open object*/
    }
-
-   FUNC_LEAVE (addr);
+   FUNC_LEAVE (ret_value);
 }
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_stab_find
- *
- * Purpose:	Finds a symbol named NAME in the symbol table whose
- *		description is stored in SELF in file F and returns a
- *		pointer to the symbol table entry.  SELF is optional if the
- *		symbol table address is supplied through ADDR.
+ * Function:	H5G_open
  *
- * Errors:
- *		SYM       BADMESG       Can't read message. 
- *		SYM       NOTFOUND      Not found. 
+ * Purpose:	Opens an object.  That is, it prepares the object for
+ *		modification by returning a handle to the object
+ *		symbol table entry. Opening an object twice with the
+ *		same name (or more precisely, through the same final
+ *		symbol table entry) will return pointers to the same
+ *		H5G_entry_t struct. But opening an object through
+ *		different final H5G_entry_t structs (which implies
+ *		different names) returns pointers to different
+ *		structs.  The structs that are returned should be
+ *		released by calling H5G_close().
  *
- * Return:	Success:	Pointer to the symbol table entry.
- *				The pointer is intended for immediate
- *				read-only access since it points
- *				directly to an entry in a cached
- *				symbol table node.  The pointer is
- *				guaranteed to be valid only until the
- *				next call to one of the H5AC functions.
+ * Return:	Success:	Ptr to a handle for the object.
  *
  *		Failure:	NULL
  *
  * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug  1 1997
+ *              Wednesday, September 17, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 H5G_entry_t *
-H5G_stab_find (hdf5_file_t *f, haddr_t addr, H5G_entry_t *self,
-	       const char *name)
+H5G_open (hdf5_file_t *f, const char *name)
 {
-   H5G_bt_ud1_t         udata;		/*data to pass through B-tree	*/
-   H5O_stab_t		stab;		/*symbol table message		*/
-
-   FUNC_ENTER (H5G_stab_find, NULL, NULL);
+   H5G_entry_t	*ent=NULL;
+   H5G_entry_t	*ret_value=NULL;
+   H5G_entry_t	dir;
+   H5G_entry_t	*cwd=NULL;
+   
+   FUNC_ENTER (H5G_open, NULL, NULL);
 
-   /* Check arguments */
+   /* check args */
    assert (f);
-   if (addr<=0 && (!self || self->header<=0)) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
-   }
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_BADVALUE, NULL);
    }
-   if (addr<=0) addr = self->header;
 
-   /* set up the udata */
-   if (NULL==H5O_read (f, addr, self, H5O_STAB, 0, &stab)) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL); /*can't read message*/
-   }
-   udata.operation = H5G_OPER_FIND;
-   udata.name = name;
-   udata.heap_addr = stab.heap_addr;
-   udata.dir_addr = addr;
+   /* Get CWD */
+#ifndef LATER
+   H5G_shadow_sync (f->root_sym);
+   cwd = f->root_sym;
+#endif
+   assert (cwd || '/'==*name);
 
-   /* search the B-tree */
-   if (H5B_find (f, H5B_SNODE, stab.btree_addr, &udata)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL); /*not found*/
+   if (f->root_sym->header<=0) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, NULL); /*object not found*/
    }
-
-   /* return the result */
-   FUNC_LEAVE (udata.entry_ptr);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5G_stab_insert
- *
- * Purpose:	Insert a new symbol into the table described by SELF in
- *		file F.  The name of the new symbol is NAME and its symbol
- *		table entry is ENT.
- *
- * Errors:
- *		SYM       BADMESG       Can't read message. 
- *		SYM       CANTINSERT    Can't insert entry. 
- *
- * Return:	Success:	SUCCEED
- *
- *		Failure:	FAIL
- *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug  1 1997
- *
- * Modifications:
- *
- * 	Robb Matzke, 18 Sep 1997
- *	If ENT has a shadow, then the shadow will be associated with the
- *	entry when it is added to the symbol table.
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_stab_insert (hdf5_file_t *f, H5G_entry_t *self, const char *name,
-		 H5G_entry_t *ent)
-{
-   H5O_stab_t		stab;		/*symbol table message		*/
-   H5G_bt_ud1_t		udata;		/*data to pass through B-tree	*/
-
-   FUNC_ENTER (H5G_stab_insert, NULL, FAIL);
-
-   /* check arguments */
-   assert (f);
-   assert (self && self->header>=0);
-   assert (name && *name);
-   assert (ent);
-   
-   /* initialize data to pass through B-tree */
-   if (NULL==H5O_read (f, self->header, self, H5O_STAB, 0, &stab)) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL); /*can't read message*/
+   if (NULL==(ent=H5G_namei (f, cwd, name, NULL, &dir))) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, NULL); /*object not found*/
    }
-
-   udata.operation = H5G_OPER_INSERT;
-   udata.name = name;
-   udata.heap_addr = stab.heap_addr;
-   udata.dir_addr = self->header;
-   udata.entry = *ent;
-   udata.entry.name_off = -1;
-
-   /* insert */
-   if (H5B_insert (f, H5B_SNODE, stab.btree_addr, &udata)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINSERT, FAIL); /*can't insert entry*/
+   if (NULL==(ret_value=H5G_shadow_open (f, &dir, ent))) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_CANTOPENOBJ, NULL);
    }
 
-   /* update the name offset in the entry */
-   ent->name_off = udata.entry.name_off;
-   FUNC_LEAVE (SUCCEED);
+   FUNC_LEAVE (ret_value);
 }
 
-
-/*-------------------------------------------------------------------------
- * Function:	H5G_stab_list
- *
- * Purpose:	Returns a list of all the symbols in a symbol table.
- *		The caller allocates an array of pointers which this
- *		function will fill in with malloc'd names.  The caller
- *		also allocates an array of symbol table entries which will
- *		be filled in with data from the symbol table.  Each of these
- *		arrays should have at least MAXENTRIES elements.
- *
- * Errors:
- *		SYM       BADMESG       Not a symbol table. 
- *		SYM       CANTLIST      B-tree list failure. 
- *
- * Return:	Success:	The total number of symbols in the
- *				symbol table.  This may exceed MAXENTRIES,
- *				but at most MAXENTRIES values are copied
- *				into the NAMES and ENTRIES arrays.
- *
- *		Failure:	FAIL, the pointers in NAMES are undefined but
- *			 	no memory is allocated.  The values in
- *				ENTRIES are undefined.
- *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug  1 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-intn
-H5G_stab_list (hdf5_file_t *f, H5G_entry_t *self, intn maxentries,
-	       char *names[], H5G_entry_t entries[])
-{
-   H5G_bt_ud2_t		udata;
-   H5O_stab_t		stab;
-   intn			i;
-
-   FUNC_ENTER (H5G_stab_list, NULL, FAIL);
-
-   /* check args */
-   assert (f);
-   assert (self && self->header>=0);
-   assert (maxentries>=0);
-
-   /* initialize data to pass through B-tree */
-   if (NULL==H5O_read (f, self->header, self, H5O_STAB, 0, &stab)) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL); /*not a symbol table*/
-   }
-   udata.entry = entries;
-   udata.name = names;
-   udata.dir_addr = self->header;
-   udata.heap_addr = stab.heap_addr;
-   udata.maxentries = maxentries;
-   udata.nsyms = 0;
-   if (names) HDmemset (names, 0, maxentries);
-
-   /* list */
-   if (H5B_list (f, H5B_SNODE, stab.btree_addr, &udata)<0) {
-      if (names) {
-	 for (i=0; i<maxentries; i++) H5MM_xfree (names[i]);
-      }
-      HRETURN_ERROR (H5E_SYM, H5E_CANTLIST, FAIL); /*B-tree list failure*/
-   }
 
-   FUNC_LEAVE (udata.nsyms);
-}
-   
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_decode_vec
- *
- * Purpose:	Same as H5G_decode() except it does it for an array of
- *		symbol table entries.
+ * Function:	H5G_close
  *
- * Errors:
- *		SYM       CANTDECODE    Can't decode. 
+ * Purpose:	Closes an object that was open for modification.
  *
- * Return:	Success:	SUCCEED, with *pp pointing to the first byte
- *				after the last symbol.
+ * Return:	Success:	SUCCEED
  *
  *		Failure:	FAIL
  *
  * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 18 1997
+ *              Thursday, September 18, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_decode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent, intn n)
+H5G_close (hdf5_file_t *f, H5G_entry_t *ent)
 {
-   intn		i;
-
-   FUNC_ENTER (H5G_decode_vec, NULL, FAIL);
+   FUNC_ENTER (H5G_close, NULL, FAIL);
 
-   /* check arguments */
    assert (f);
-   assert (pp);
-   assert (ent);
-   assert (n>=0);
 
-   /* decode entries */
-   for (i=0; i<n; i++) {
-      if (H5G_decode (f, pp, ent+i)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTDECODE, FAIL); /*can't decode*/
-      }
+   if (ent && H5G_shadow_close (f,  ent)<0) {
+      HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL);
    }
-
+   
    FUNC_LEAVE (SUCCEED);
 }
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_decode
- *
- * Purpose:	Decodes a symbol table entry pointed to by `*pp'.
- *
- * Errors:
- *
- * Return:	Success:	SUCCEED with *pp pointing to the first byte
- *				following the symbol table entry.
- *
- *		Failure:	FAIL
- *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 18 1997
- *
- * Modifications:
+ * Function:	H5G_find
  *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_decode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent)
-{
-   uint8	*p_ret = *pp;
-
-   FUNC_ENTER (H5G_decode, NULL, FAIL);
-
-   /* check arguments */
-   assert (f);
-   assert (pp);
-   assert (ent);
-
-   /* decode header */
-   H5F_decode_offset (f, *pp, ent->name_off);
-   H5F_decode_offset (f, *pp, ent->header);
-   UINT32DECODE (*pp, ent->type);
-
-   /* decode scratch-pad */
-   switch (ent->type) {
-   case H5G_NOTHING_CACHED:
-      break;
-
-   case H5G_CACHED_SDATA:
-      ent->cache.sdata.nt.length= *(*pp)++;
-      ent->cache.sdata.nt.arch= *(*pp)++;
-      UINT16DECODE (*pp, ent->cache.sdata.nt.type);
-      UINT32DECODE (*pp, ent->cache.sdata.ndim);
-      UINT32DECODE (*pp, ent->cache.sdata.dim[0]);
-      UINT32DECODE (*pp, ent->cache.sdata.dim[1]);
-      UINT32DECODE (*pp, ent->cache.sdata.dim[2]);
-      UINT32DECODE (*pp, ent->cache.sdata.dim[3]);
-      break;
-
-   case H5G_CACHED_STAB:
-      UINT32DECODE (*pp, ent->cache.stab.btree_addr);
-      UINT32DECODE (*pp, ent->cache.stab.heap_addr);
-      break;
-
-   default:
-      HDabort();
-   }
-
-   *pp = p_ret + H5G_SIZEOF_ENTRY(f);
-   FUNC_LEAVE (SUCCEED);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5G_encode_vec
+ * Purpose:	Finds an object with the specified NAME in file F.  If
+ *		the name is relative then it is interpretted relative
+ *		to CWD, a symbol table entry for a symbol table.  On
+ *		successful return, DIR_ENT (if non-null) will be
+ *		initialized with the symbol table information for the
+ *		directory in which the object appears (or all zero if
+ *		the returned object is the root object) and ENT will
+ *		be initialized with the symbol table entry for the
+ *		object (ENT is optional when the caller is interested
+ *		only in the existence of the object).
  *
- * Purpose:	Same as H5G_encode() except it does it for an array of
- *		symbol table entries.
+ * 		This function will fail if the root object is
+ * 		requested and there is none.
  *
  * Errors:
- *		SYM       CANTENCODE    Can't encode. 
+ *		DIRECTORY NOTFOUND      Object not found. 
  *
- * Return:	Success:	SUCCEED, with *pp pointing to the first byte
- *				after the last symbol.
+ * Return:	Success:	SUCCEED with DIR_ENT and ENT initialized. ENT
+ *				is intended for immediate read-only access.
+ *				If the object that ENT refers to is open
+ *				through the ENT entry (see H5G_open()) then
+ *				the returned ENT will contain the latest
+ *				information.  However, subsequent changes to
+ *				the symbol table entry will not be reflected
+ *				in ENT since it is a copy of the symbol table.
  *
  *		Failure:	FAIL
  *
  * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 18 1997
+ *		robb@maya.nuance.com
+ *		Aug 12 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_encode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent, intn n)
+H5G_find (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
+	  const char *name, H5G_entry_t *ent)
 {
-   intn		i;
-
-   FUNC_ENTER (H5G_encode_vec, NULL, FAIL);
+   H5G_entry_t	*ent_p = NULL;
+   FUNC_ENTER (H5G_find, NULL, FAIL);
 
-   /* check arguments */
+   /* check args */
    assert (f);
-   assert (pp);
-   assert (ent);
-   assert (n>=0);
+   assert (name && *name);
+   assert (cwd || '/'==*name);
 
-   /* encode entries */
-   for (i=0; i<n; i++) {
-      if (H5G_encode (f, pp, ent+i)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTENCODE, FAIL); /*can't encode*/
-      }
+   if (f->root_sym->header<=0) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, FAIL); /*object not found*/
    }
 
-   FUNC_LEAVE (SUCCEED);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5G_encode
- *
- * Purpose:	Encodes the specified symbol table entry into the buffer
- *		pointed to by *pp.
- *
- * Errors:
- *
- * Return:	Success:	SUCCEED, with *pp pointing to the first byte
- *				after the symbol table entry.
- *
- *		Failure:	FAIL
- *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 18 1997
- *
- * Modifications:
- *
- * 	Robb Matzke, 8 Aug 1997
- *	Writes zeros for the bytes that aren't used so the file doesn't
- *	contain junk.
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_encode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent)
-{
-   uint8	*p_ret = *pp + H5G_SIZEOF_ENTRY(f);
-
-   FUNC_ENTER (H5G_encode, NULL, FAIL);
-
-   /* check arguments */
-   assert (f);
-   assert (pp);
-   assert (ent);
-
-   /* encode header */
-   H5F_encode_offset (f, *pp, ent->name_off);
-   H5F_encode_offset (f, *pp, ent->header);
-   UINT32ENCODE (*pp, ent->type);
-
-   /* encode scratch-pad */
-   switch (ent->type) {
-   case H5G_NOTHING_CACHED:
-      break;
-
-   case H5G_CACHED_SDATA:
-      *(*pp)++= ent->cache.sdata.nt.length;
-      *(*pp)++= ent->cache.sdata.nt.arch;
-      UINT16ENCODE (*pp, ent->cache.sdata.nt.type);
-      UINT32ENCODE (*pp, ent->cache.sdata.ndim);
-      UINT32ENCODE (*pp, ent->cache.sdata.dim[0]);
-      UINT32ENCODE (*pp, ent->cache.sdata.dim[1]);
-      UINT32ENCODE (*pp, ent->cache.sdata.dim[2]);
-      UINT32ENCODE (*pp, ent->cache.sdata.dim[3]);
-      break;
-
-   case H5G_CACHED_STAB:
-      UINT32ENCODE (*pp, ent->cache.stab.btree_addr);
-      UINT32ENCODE (*pp, ent->cache.stab.heap_addr);
-      break;
-
-   default:
-      HDabort();
+   if (NULL==(ent_p=H5G_namei (f, cwd, name, NULL, dir_ent))) {
+      HRETURN_ERROR (H5E_DIRECTORY, H5E_NOTFOUND, FAIL); /*object not found*/
    }
 
-   /* fill with zero */
-   while (*pp<p_ret) *(*pp)++ = 0;
-   
-   *pp = p_ret;
+   if (ent) *ent = *ent_p;
    FUNC_LEAVE (SUCCEED);
 }
 
-
-/*-------------------------------------------------------------------------
- * Function:	H5G_debug
- *
- * Purpose:	Prints debugging information about a symbol table entry.
- *
- * Errors:
- *
- * Return:	Success:	SUCCEED
- *
- *		Failure:	FAIL
- *
- * Programmer:	Robb Matzke
- *		robb@maya.nuance.com
- *		Aug 29 1997
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5G_debug (hdf5_file_t *f, H5G_entry_t *ent, FILE *stream, intn indent,
-	   intn fwidth)
-{
-   int		i;
-   char		buf[64];
-   
-   FUNC_ENTER (H5G_debug, NULL, FAIL);
-
-   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
-	    "Name offset into private heap:",
-	    (unsigned long)(ent->name_off));
-   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
-	    "Object header address:",
-	    (unsigned long)(ent->header));
-   fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
-	    "Dirty:",
-	    ent->dirty ? "Yes" : "No");
-   fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
-	    "Has a shadow:",
-	    H5G_shadow_p (ent)?"This is a shadow!" :
-	       (ent->shadow ? "Yes" : "No"));
-      
-   fprintf (stream, "%*s%-*s ", indent, "", fwidth,
-	    "Symbol type:");
-   switch (ent->type) {
-   case H5G_NOTHING_CACHED:
-      fprintf (stream, "Nothing Cached\n");
-      break;
-	 
-   case H5G_CACHED_SDATA:
-      fprintf (stream, "S-data\n");
-      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
-	       "Number type length:",
-	       (unsigned)(ent->cache.sdata.nt.length));
-      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
-	       "Number type architecture:",
-	       (unsigned)(ent->cache.sdata.nt.arch));
-      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
-	       "Number type type:",
-	       (unsigned)(ent->cache.sdata.nt.type));
-      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
-	       "Dimensionality:",
-	       (unsigned)(ent->cache.sdata.ndim));
-      for (i=0; i<ent->cache.sdata.ndim && i<4; i++) {
-	 sprintf (buf, "Dimension %d", i);
-	 fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
-		  buf,
-		  (unsigned)(ent->cache.sdata.dim[i]));
-      }
-      break;
-	 
-   case H5G_CACHED_STAB:
-      fprintf (stream, "Symbol Table\n");
-      fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
-	       "B-tree address:",
-	       (unsigned long)(ent->cache.stab.btree_addr));
-      fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
-	       "Heap address:",
-	       (unsigned long)(ent->cache.stab.heap_addr));
-      break;
-
-   default:
-      fprintf (stream, "*** Unknown symbol type %d\n", ent->type);
-      break;
-   }
-
-   FUNC_LEAVE (SUCCEED);
-}
diff --git a/src/H5Gent.c b/src/H5Gent.c
new file mode 100644
index 0000000..bc54161
--- /dev/null
+++ b/src/H5Gent.c
@@ -0,0 +1,488 @@
+/*
+ * Copyright (C) 1997 National Center for Supercomputing Applications.
+ *                    All rights reserved.
+ *
+ * Programmer: Robb Matzke <matzke@llnl.gov>
+ *             Friday, September 19, 1997
+ */
+#define H5G_PACKAGE
+
+#include <H5private.h>
+#include <H5Eprivate.h>
+#include <H5Gpkg.h>
+#include <H5MMprivate.h>
+
+#define PABLO_MASK	H5G_ent_mask
+
+static hbool_t interface_initialize_g = FALSE;
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_calloc
+ *
+ * Purpose:	Returns a pointer to a malloc'd, zeroed symbol table entry.
+ *
+ * Return:	Success:	Ptr to entry
+ *
+ *		Failure:	never fails
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, September 19, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5G_entry_t *
+H5G_ent_calloc (void)
+{
+   return H5MM_xcalloc (1, sizeof(H5G_entry_t));
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_invalidate
+ *
+ * Purpose:	Invalidates the cache in a symbol table entry.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, September 19, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_ent_invalidate (H5G_entry_t *ent)
+{
+   FUNC_ENTER (H5G_ent_invalidate, NULL, FAIL);
+   
+   if (ent && H5G_NOTHING_CACHED!=ent->type) {
+      ent->dirty = TRUE;
+      ent->type = H5G_NOTHING_CACHED;
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_addr
+ *
+ * Purpose:	Returns the header address associated with a symbol table
+ *		entry.
+ *
+ * Return:	Success:	Address
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, September 19, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+haddr_t
+H5G_ent_addr (H5G_entry_t *ent)
+{
+   FUNC_ENTER (H5G_ent_addr, NULL, FAIL);
+   assert (ent);
+   
+   FUNC_LEAVE (ent->header);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_cache
+ *
+ * Purpose:	Returns a pointer to the cache associated with the symbol
+ *		table entry.  You should modify the cache directly, then call
+ *		H5G_modified() with the new cache type (even if the type is
+ *		still the same).
+ *
+ * Return:	Success:	Ptr to the cache in the symbol table entry.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, September 19, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5G_cache_t *
+H5G_ent_cache (H5G_entry_t *ent, H5G_type_t *cache_type)
+{
+   FUNC_ENTER (H5G_ent_cache, NULL, NULL);
+   if (!ent) {
+      HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, NULL);
+   }
+   if (cache_type) *cache_type = ent->type;
+   
+   FUNC_LEAVE (&(ent->cache));
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_modified
+ *
+ * Purpose:	This function should be called after you make any
+ *		modifications to a symbol table entry cache.  Supply the new
+ *		type for the cache.  If CACHE_TYPE is the constant
+ *		H5G_NO_CHANGE then the cache type isn't changed--just the
+ *		dirty bit is set.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, September 19, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_ent_modified (H5G_entry_t *ent, H5G_type_t cache_type)
+{
+   FUNC_ENTER (H5G_ent_modified, NULL, FAIL);
+   assert (ent);
+   if (H5G_NO_CHANGE!=ent->type) ent->type = cache_type;
+   ent->dirty = TRUE;
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_decode_vec
+ *
+ * Purpose:	Same as H5G_ent_decode() except it does it for an array of
+ *		symbol table entries.
+ *
+ * Errors:
+ *		SYM       CANTDECODE    Can't decode. 
+ *
+ * Return:	Success:	SUCCEED, with *pp pointing to the first byte
+ *				after the last symbol.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 18 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_ent_decode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent, intn n)
+{
+   intn		i;
+
+   FUNC_ENTER (H5G_ent_decode_vec, NULL, FAIL);
+
+   /* check arguments */
+   assert (f);
+   assert (pp);
+   assert (ent);
+   assert (n>=0);
+
+   /* decode entries */
+   for (i=0; i<n; i++) {
+      if (H5G_ent_decode (f, pp, ent+i)<0) {
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTDECODE, FAIL); /*can't decode*/
+      }
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_decode
+ *
+ * Purpose:	Decodes a symbol table entry pointed to by `*pp'.
+ *
+ * Errors:
+ *
+ * Return:	Success:	SUCCEED with *pp pointing to the first byte
+ *				following the symbol table entry.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 18 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_ent_decode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent)
+{
+   uint8	*p_ret = *pp;
+
+   FUNC_ENTER (H5G_ent_decode, NULL, FAIL);
+
+   /* check arguments */
+   assert (f);
+   assert (pp);
+   assert (ent);
+
+   /* decode header */
+   H5F_decode_offset (f, *pp, ent->name_off);
+   H5F_decode_offset (f, *pp, ent->header);
+   UINT32DECODE (*pp, ent->type);
+
+   /* decode scratch-pad */
+   switch (ent->type) {
+   case H5G_NOTHING_CACHED:
+      break;
+
+   case H5G_CACHED_SDATA:
+      ent->cache.sdata.nt.length= *(*pp)++;
+      ent->cache.sdata.nt.arch= *(*pp)++;
+      UINT16DECODE (*pp, ent->cache.sdata.nt.type);
+      UINT32DECODE (*pp, ent->cache.sdata.ndim);
+      UINT32DECODE (*pp, ent->cache.sdata.dim[0]);
+      UINT32DECODE (*pp, ent->cache.sdata.dim[1]);
+      UINT32DECODE (*pp, ent->cache.sdata.dim[2]);
+      UINT32DECODE (*pp, ent->cache.sdata.dim[3]);
+      break;
+
+   case H5G_CACHED_STAB:
+      UINT32DECODE (*pp, ent->cache.stab.btree_addr);
+      UINT32DECODE (*pp, ent->cache.stab.heap_addr);
+      break;
+
+   default:
+      HDabort();
+   }
+
+   *pp = p_ret + H5G_SIZEOF_ENTRY(f);
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_encode_vec
+ *
+ * Purpose:	Same as H5G_ent_encode() except it does it for an array of
+ *		symbol table entries.
+ *
+ * Errors:
+ *		SYM       CANTENCODE    Can't encode. 
+ *
+ * Return:	Success:	SUCCEED, with *pp pointing to the first byte
+ *				after the last symbol.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 18 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_ent_encode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent, intn n)
+{
+   intn		i;
+
+   FUNC_ENTER (H5G_ent_encode_vec, NULL, FAIL);
+
+   /* check arguments */
+   assert (f);
+   assert (pp);
+   assert (ent);
+   assert (n>=0);
+
+   /* encode entries */
+   for (i=0; i<n; i++) {
+      if (H5G_ent_encode (f, pp, ent+i)<0) {
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTENCODE, FAIL); /*can't encode*/
+      }
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_encode
+ *
+ * Purpose:	Encodes the specified symbol table entry into the buffer
+ *		pointed to by *pp.
+ *
+ * Errors:
+ *
+ * Return:	Success:	SUCCEED, with *pp pointing to the first byte
+ *				after the symbol table entry.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 18 1997
+ *
+ * Modifications:
+ *
+ * 	Robb Matzke, 8 Aug 1997
+ *	Writes zeros for the bytes that aren't used so the file doesn't
+ *	contain junk.
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_ent_encode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent)
+{
+   uint8	*p_ret = *pp + H5G_SIZEOF_ENTRY(f);
+
+   FUNC_ENTER (H5G_ent_encode, NULL, FAIL);
+
+   /* check arguments */
+   assert (f);
+   assert (pp);
+   assert (ent);
+
+   /* encode header */
+   H5F_encode_offset (f, *pp, ent->name_off);
+   H5F_encode_offset (f, *pp, ent->header);
+   UINT32ENCODE (*pp, ent->type);
+
+   /* encode scratch-pad */
+   switch (ent->type) {
+   case H5G_NOTHING_CACHED:
+      break;
+
+   case H5G_CACHED_SDATA:
+      *(*pp)++= ent->cache.sdata.nt.length;
+      *(*pp)++= ent->cache.sdata.nt.arch;
+      UINT16ENCODE (*pp, ent->cache.sdata.nt.type);
+      UINT32ENCODE (*pp, ent->cache.sdata.ndim);
+      UINT32ENCODE (*pp, ent->cache.sdata.dim[0]);
+      UINT32ENCODE (*pp, ent->cache.sdata.dim[1]);
+      UINT32ENCODE (*pp, ent->cache.sdata.dim[2]);
+      UINT32ENCODE (*pp, ent->cache.sdata.dim[3]);
+      break;
+
+   case H5G_CACHED_STAB:
+      UINT32ENCODE (*pp, ent->cache.stab.btree_addr);
+      UINT32ENCODE (*pp, ent->cache.stab.heap_addr);
+      break;
+
+   default:
+      HDabort();
+   }
+
+   /* fill with zero */
+   while (*pp<p_ret) *(*pp)++ = 0;
+   
+   *pp = p_ret;
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_ent_debug
+ *
+ * Purpose:	Prints debugging information about a symbol table entry.
+ *
+ * Errors:
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		robb@maya.nuance.com
+ *		Aug 29 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_ent_debug (hdf5_file_t *f, H5G_entry_t *ent, FILE *stream, intn indent,
+	       intn fwidth)
+{
+   int		i;
+   char		buf[64];
+   
+   FUNC_ENTER (H5G_ent_debug, NULL, FAIL);
+
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Name offset into private heap:",
+	    (unsigned long)(ent->name_off));
+   fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Object header address:",
+	    (unsigned long)(ent->header));
+   fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+	    "Dirty:",
+	    ent->dirty ? "Yes" : "No");
+   fprintf (stream, "%*s%-*s %s\n", indent, "", fwidth,
+	    "Has a shadow:",
+	    H5G_shadow_p (ent)?"This is a shadow!" :
+	       (ent->shadow ? "Yes" : "No"));
+      
+   fprintf (stream, "%*s%-*s ", indent, "", fwidth,
+	    "Symbol type:");
+   switch (ent->type) {
+   case H5G_NOTHING_CACHED:
+      fprintf (stream, "Nothing Cached\n");
+      break;
+	 
+   case H5G_CACHED_SDATA:
+      fprintf (stream, "S-data\n");
+      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
+	       "Number type length:",
+	       (unsigned)(ent->cache.sdata.nt.length));
+      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
+	       "Number type architecture:",
+	       (unsigned)(ent->cache.sdata.nt.arch));
+      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
+	       "Number type type:",
+	       (unsigned)(ent->cache.sdata.nt.type));
+      fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
+	       "Dimensionality:",
+	       (unsigned)(ent->cache.sdata.ndim));
+      for (i=0; i<ent->cache.sdata.ndim && i<4; i++) {
+	 sprintf (buf, "Dimension %d", i);
+	 fprintf (stream, "%*s%-*s %u\n", indent, "", fwidth,
+		  buf,
+		  (unsigned)(ent->cache.sdata.dim[i]));
+      }
+      break;
+	 
+   case H5G_CACHED_STAB:
+      fprintf (stream, "Symbol Table\n");
+      fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	       "B-tree address:",
+	       (unsigned long)(ent->cache.stab.btree_addr));
+      fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	       "Heap address:",
+	       (unsigned long)(ent->cache.stab.heap_addr));
+      break;
+
+   default:
+      fprintf (stream, "*** Unknown symbol type %d\n", ent->type);
+      break;
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
diff --git a/src/H5Gnode.c b/src/H5Gnode.c
index aa3175c..ffa1f86 100644
--- a/src/H5Gnode.c
+++ b/src/H5Gnode.c
@@ -60,7 +60,7 @@ static herr_t H5G_node_list (hdf5_file_t *f, haddr_t addr, void *_udata);
 static size_t H5G_node_sizeof_rkey (hdf5_file_t *f);
 
 /* H5G inherits cache-like properties from H5AC */
-static const H5AC_class_t H5AC_SNODE[1] = {{
+const H5AC_class_t H5AC_SNODE[1] = {{
       (void*(*)(hdf5_file_t*,haddr_t,void*))H5G_node_load,
       (herr_t(*)(hdf5_file_t*,hbool_t,haddr_t,void*))H5G_node_flush,
 }};
@@ -310,6 +310,7 @@ H5G_node_flush (hdf5_file_t *f, hbool_t destroy, haddr_t addr, H5G_node_t *sym)
       if (H5G_shadow_sync (sym->entry+i)<0) {
 	 HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL);
       }
+      if (sym->entry[i].dirty) sym->dirty = TRUE;
    }
 
    /*
@@ -333,7 +334,7 @@ H5G_node_flush (hdf5_file_t *f, hbool_t destroy, haddr_t addr, H5G_node_t *sym)
       UINT16ENCODE (p, sym->nsyms);
 
       /* entries */
-      H5G_encode_vec (f, &p, sym->entry, sym->nsyms);
+      H5G_ent_encode_vec (f, &p, sym->entry, sym->nsyms);
       HDmemset (p, 0, size - (p-buf));
       
       status = H5F_block_write (f, addr, size, buf);
@@ -424,7 +425,7 @@ H5G_node_load (hdf5_file_t *f, haddr_t addr, void *_udata)
    UINT16DECODE (p, sym->nsyms);
 
    /* entries */
-   if (H5G_decode_vec (f, &p, sym->entry, sym->nsyms)<0) {
+   if (H5G_ent_decode_vec (f, &p, sym->entry, sym->nsyms)<0) {
       HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL);
    }
    buf = H5MM_xfree (buf);
@@ -588,6 +589,8 @@ H5G_node_found (hdf5_file_t *f, haddr_t addr, const void *_lt_key,
        */
       H5G_shadow_sync (sn->entry+idx);
       bt_udata->entry_ptr = sn->entry+idx;
+      bt_udata->node_addr = addr;
+      bt_udata->node_ptr = sn;
       break;
 
    default:
@@ -597,9 +600,17 @@ H5G_node_found (hdf5_file_t *f, haddr_t addr, const void *_lt_key,
    ret_value = SUCCEED;
 
 done:
-   if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL);
+   /*
+    * Don't unprotect the symbol table entry if we're returning success since
+    * this might invalidate the bt_udata->entry_ptr and bt_udata->node_ptr
+    * pointers. Instead, we unprotect it in H5G_stab_find().
+    */
+   if (ret_value<0) {
+      if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL);
+      }
    }
+
    FUNC_LEAVE (ret_value);
 }
 
@@ -663,6 +674,8 @@ H5G_node_insert (hdf5_file_t *f, haddr_t addr, intn *anchor,
    intn			i;
    haddr_t		ret_value = FAIL;
    H5G_shadow_t		*shadow = NULL;
+   H5G_node_t		*insert_into=NULL;	/*node that gets new entry*/
+   haddr_t		insert_addr=-1;		/*address of that node	*/
 
    FUNC_ENTER (H5G_node_insert, NULL, FAIL);
 
@@ -675,6 +688,8 @@ H5G_node_insert (hdf5_file_t *f, haddr_t addr, intn *anchor,
    assert (md_key);
    assert (rt_key);
    assert (bt_udata);
+   bt_udata->node_addr = -1;
+   bt_udata->node_ptr = NULL;
    bt_udata->entry_ptr = NULL;
 
    /*
@@ -757,90 +772,77 @@ H5G_node_insert (hdf5_file_t *f, haddr_t addr, intn *anchor,
       sn->nsyms = H5G_NODE_K (f);
       sn->dirty += 1;
 
-      /* Insert the new entry */
-      if (idx<=H5G_NODE_K(f)) {
-	 
-	 /* Adjust shadows */
-	 for (i=idx; i<sn->nsyms; i++) {
-	    if (sn->entry[i].shadow) {
-	       sn->entry[i].shadow->main = sn->entry + i + 1;
-	    }
-	 }
-	 if (bt_udata->entry.shadow) {
-	    bt_udata->entry.shadow->main = sn->entry + idx;
-	 }
+      /* The middle key */
+      md_key->offset = sn->entry[sn->nsyms-1].name_off;
 
-	 /* Move entries */
-	 HDmemmove (sn->entry + idx + 1,
-		    sn->entry + idx,
-		    (H5G_NODE_K(f)-idx) * sizeof(H5G_entry_t));
-	 sn->entry[idx] = bt_udata->entry;
-	 sn->entry[idx].name_off = offset;
-	 sn->entry[idx].dirty = TRUE;
-	 sn->nsyms += 1;
-	 
+      /* Where to insert the new entry? */
+      if (idx<=H5G_NODE_K(f)) {
+	 insert_into = sn;
+	 insert_addr = addr;
+	 if (idx==H5G_NODE_K(f)) md_key->offset = offset;
       } else {
 	 idx -= H5G_NODE_K (f);
-
-	 /* Adjust shadows */
-	 for (i=idx; i<snrt->nsyms; i++) {
-	    if (snrt->entry[i].shadow) {
-	       snrt->entry[i].shadow->main = snrt->entry + i + 1;
-	    }
-	 }
-	 if (bt_udata->entry.shadow) {
-	    bt_udata->entry.shadow->main = snrt->entry + idx;
-	 }
-
-	 /* Move entries */
-	 HDmemmove (snrt->entry + idx + 1,
-		    snrt->entry + idx,
-		    (H5G_NODE_K(f)-idx) * sizeof (H5G_entry_t));
-	 snrt->entry[idx] = bt_udata->entry;
-	 snrt->entry[idx].name_off = offset;
-	 snrt->entry[idx].dirty = TRUE;
-	 snrt->nsyms += 1;
-
-	 if (idx+1 == sn->nsyms) {
-	    rt_key->offset = offset;
-	    *rt_key_changed = TRUE;
-	 }
+	 insert_into = snrt;
+	 insert_addr = new_node;
       }
-
-      /* The middle key */
-      md_key->offset = sn->entry[sn->nsyms-1].name_off;
+      ret_value = new_node;
 
    } else {
-      /*
-       * Add the new symbol to the node.
-       */
+      /* Where to insert the new entry? */
       sn->dirty += 1;
-      for (i=idx; i<sn->nsyms; i++) {
-	 if (sn->entry[i].shadow) {
-	    sn->entry[i].shadow->main = sn->entry + i + 1;
-	 }
-      }
-      if (bt_udata->entry.shadow) {
-	 bt_udata->entry.shadow->main = sn->entry + idx;
-      }
-      HDmemmove (sn->entry+idx+1, sn->entry+idx,
-		 (sn->nsyms-idx) * sizeof (H5G_entry_t));
-      sn->nsyms += 1;
-      sn->entry[idx] = bt_udata->entry;
-      sn->entry[idx].name_off = offset;
-      sn->entry[idx].dirty = TRUE;
-      
-      if (idx+1==sn->nsyms) {
+      insert_into = sn;
+      insert_addr = addr;
+      if (idx==sn->nsyms) {
 	 rt_key->offset = offset;
 	 *rt_key_changed = TRUE;
       }
+      ret_value = 0;
+   }
+
+   /* Adjust shadows */
+   for (i=idx; i<insert_into->nsyms; i++) {
+      if (insert_into->entry[i].shadow) {
+	 insert_into->entry[i].shadow->main = insert_into->entry + i + 1;
+      }
+   }
+   if (bt_udata->entry.shadow) {
+      H5G_shadow_move (f, bt_udata->entry.shadow,
+		       bt_udata->name, 
+		       insert_into->entry + idx,
+		       bt_udata->dir_addr);
    }
 
-   ret_value = new_node; /*successful return */
+   /* Move entries */
+   HDmemmove (insert_into->entry + idx + 1,
+	      insert_into->entry + idx,
+	      (insert_into->nsyms-idx) * sizeof(H5G_entry_t));
+   insert_into->entry[idx] = bt_udata->entry;
+   insert_into->entry[idx].name_off = offset;
+   insert_into->entry[idx].dirty = TRUE;
+   insert_into->nsyms += 1;
+
+   /* Update udata return values */
+   bt_udata->node_addr = insert_addr;
+   bt_udata->node_ptr = insert_into;
+   bt_udata->entry_ptr = insert_into->entry + idx;
 
 done:
-   if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL);
+   if (ret_value<0) {
+      /* failing... */
+      if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL);
+      }
+   } else if (insert_into!=sn) {
+      /* unprotect the first node and protect the return value */
+      if (H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL);
+      }
+      if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, insert_addr, &ac_udata))) {
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL);
+      }
+      assert (sn==bt_udata->node_ptr);
+   } else {
+      /* keep the node protected until we get back to H5G_stab_insert() */
    }
 
    FUNC_LEAVE (ret_value);
@@ -988,7 +990,7 @@ H5G_node_debug (hdf5_file_t *f, haddr_t addr, FILE *stream, intn indent,
     * If we couldn't load the symbol table node, then try loading the
     * B-tree node.
     */
-   if (NULL==(sn=H5AC_find(f, H5AC_SNODE, addr, NULL))) {
+   if (NULL==(sn=H5AC_find(f, H5AC_SNODE, addr, &ac_udata))) {
       H5ECLEAR; /*discard that error*/
       status = H5B_debug (f, addr, stream, indent, fwidth, H5B_SNODE);
       if (status<0) HRETURN_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL);
@@ -1019,7 +1021,7 @@ H5G_node_debug (hdf5_file_t *f, haddr_t addr, FILE *stream, intn indent,
 		  "Name:",
 		  s);
       }
-      H5G_debug (f, sn->entry+i, stream, indent, fwidth);
+      H5G_ent_debug (f, sn->entry+i, stream, indent, fwidth);
       fprintf (stream, "%*s%-*s %s\n", indent+3, "", MAX (0, fwidth-3),
 	       "Shadow:",
 	       sn->entry[i].shadow ? "Yes":"No");
diff --git a/src/H5Gpkg.h b/src/H5Gpkg.h
index c5ccae9..74881f7 100644
--- a/src/H5Gpkg.h
+++ b/src/H5Gpkg.h
@@ -16,6 +16,7 @@
 #ifndef _H5Gpkg_H
 #define _H5Gpkg_H
 
+#include <H5ACprivate.h>
 #include <H5Gprivate.h>
 
 #define H5G_NODE_VERS	1	/*symbol table node version number	*/
@@ -24,6 +25,20 @@
 #define H5G_NODE_SIZEOF_HDR(F) (H5G_NODE_SIZEOF_MAGIC + 4)
 #define H5G_DEFAULT_ROOT_SIZE  32
 
+/*
+ * A symbol table entry.  The two important fields are `name_off' and
+ * `header'.  The remaining fields are used for caching information that
+ * also appears in the object header to which this symbol table entry
+ * points.
+ */
+struct H5G_entry_t {
+   hbool_t	dirty;		/*entry out-of-date?			*/
+   off_t	name_off;	/*offset of name within name heap	*/
+   haddr_t	header;		/*file address of object header		*/
+   H5G_type_t	type;		/*type of information cached		*/
+   H5G_cache_t	cache;		/*cached data from object header	*/
+   H5G_shadow_t *shadow;	/*optional ptr to the shadow		*/
+};
 
 /*
  * A shadow is a copy of a symbol table entry which corresponds to an
@@ -68,7 +83,7 @@ typedef struct H5G_node_key_t {
  */
 typedef enum H5G_oper_t {
    H5G_OPER_FIND	=0,	/*find a symbol				*/
-   H5G_OPER_INSERT	=1, 	/*insert a new symbol			*/
+   H5G_OPER_INSERT	=1 	/*insert a new symbol			*/
 } H5G_oper_t;
 
 /*
@@ -87,7 +102,9 @@ typedef struct H5G_bt_ud1_t {
    /* downward for INSERT */
    H5G_entry_t	entry;		/*entry to insert into table		*/
 
-   /* upward for FIND */
+   /* upward for FIND and INSERT */
+   haddr_t	node_addr;	/*address of node for this entry	*/
+   H5G_node_t	*node_ptr;	/*ptr to the node containing the entry	*/
    H5G_entry_t	*entry_ptr;	/*ptr into cached symbol table node	*/
 
 } H5G_bt_ud1_t;
@@ -123,6 +140,9 @@ typedef struct H5G_ac_ud1_t {
    haddr_t	dir_addr;
 } H5G_ac_ud1_t;
 
+/* The cache subclass */
+extern const H5AC_class_t H5AC_SNODE[1];
+
 /*
  * Functions that understand symbol tables but not directories.  The
  * functions that understand directories are exported to the rest of
@@ -131,8 +151,8 @@ typedef struct H5G_ac_ud1_t {
 haddr_t H5G_stab_new (hdf5_file_t *f, H5G_entry_t *self, size_t init);
 H5G_entry_t *H5G_stab_find (hdf5_file_t *f, haddr_t addr, H5G_entry_t *self,
 			    const char *name);
-herr_t H5G_stab_insert (hdf5_file_t *f, H5G_entry_t *self, const char *name,
-			H5G_entry_t *ent);
+H5G_entry_t *H5G_stab_insert (hdf5_file_t *f, H5G_entry_t *self,
+			      const char *name, H5G_entry_t *ent);
 intn H5G_stab_list (hdf5_file_t *f, H5G_entry_t *self, intn maxentries,
 		    char *names[], H5G_entry_t entries[]);
 
@@ -147,12 +167,17 @@ hbool_t H5G_shadow_p (H5G_entry_t *ent);
 herr_t H5G_shadow_dissociate (H5G_entry_t *ent);
 herr_t H5G_shadow_assoc_node (hdf5_file_t *f, H5G_node_t *sym,
 			      H5G_ac_ud1_t *ac_udata);
-H5G_shadow_t *H5G_shadow_list (haddr_t stab_header_addr);
+H5G_shadow_t *H5G_shadow_list (hdf5_file_t *f, haddr_t stab_header_addr);
+herr_t H5G_shadow_move (hdf5_file_t *f, H5G_shadow_t *shadow,
+			const char *new_name, H5G_entry_t *new_entry,
+			haddr_t dir_addr);
 
 /*
  * Functions that understand symbol table entries.
  */
-herr_t H5G_decode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent, intn n);
-herr_t H5G_encode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent, intn n);
+herr_t H5G_ent_decode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent,
+			   intn n);
+herr_t H5G_ent_encode_vec (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent,
+			   intn n);
 
 #endif
diff --git a/src/H5Gprivate.h b/src/H5Gprivate.h
index dd26902..97355c2 100644
--- a/src/H5Gprivate.h
+++ b/src/H5Gprivate.h
@@ -25,7 +25,8 @@
 
 #define H5G_NODE_MAGIC	"SNOD"	/*symbol table node magic number	*/
 #define H5G_NODE_SIZEOF_MAGIC 4 /*sizeof symbol node magic number	*/
-#define H5G_new_entry() H5MM_xcalloc (1, sizeof(H5G_entry_t))
+#define H5G_NO_CHANGE	(-1)	/*see H5G_ent_modified()		*/
+#define H5G_NSHADOWS	10331	/*default size of shadow hash table	*/
 
 /*
  * The disk size for a symbol table entry...
@@ -75,41 +76,46 @@ typedef union H5G_cache_t {
  * important outside H5G.
  */
 typedef struct H5G_shadow_t H5G_shadow_t;
+typedef struct H5G_entry_t H5G_entry_t;
 
 /*
- * A symbol table entry.  The two important fields are `name_off' and
- * `header'.  The remaining fields are used for caching information that
- * also appears in the object header to which this symbol table entry
- * points.
+ * Library prototypes...  These are the ones that other packages routinely
+ * call.
  */
-typedef struct H5G_entry_t {
-   hbool_t	dirty;		/*entry out-of-date?			*/
-   off_t	name_off;	/*offset of name within name heap	*/
-   haddr_t	header;		/*file address of object header		*/
-   H5G_type_t	type;		/*type of information cached		*/
-   H5G_cache_t	cache;		/*cached data from object header	*/
-   H5G_shadow_t *shadow;	/*optional ptr to the shadow		*/
-} H5G_entry_t;
-
-/*
- * Library prototypes...
- */
-herr_t H5G_new (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
-		const char *name, size_t size_hint, H5G_entry_t *ent);
-H5G_entry_t *H5G_open (hdf5_file_t *f, H5G_entry_t *cwd, const char *name);
+H5G_entry_t *H5G_mkdir (hdf5_file_t *f, const char *name, size_t size_hint);
+herr_t H5G_pushd (hdf5_file_t *f, const char *name);
+herr_t H5G_popd (hdf5_file_t *f);
+H5G_entry_t *H5G_create (hdf5_file_t *f, const char *name, size_t ohdr_hint);
+H5G_entry_t *H5G_open (hdf5_file_t *f, const char *name);
 herr_t H5G_close (hdf5_file_t *f, H5G_entry_t *ent);
 herr_t H5G_find (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
 		 const char *name, H5G_entry_t *ent);
-herr_t H5G_insert (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent,
-		   const char *name, H5G_entry_t *ent);
-herr_t H5G_set_root (hdf5_file_t *f, const char *name, H5G_entry_t *ent);
-herr_t H5G_encode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent);
-herr_t H5G_decode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent);
-herr_t H5G_debug (hdf5_file_t *f, H5G_entry_t *ent, FILE *stream, intn indent,
-		  intn fwidth);
+herr_t H5G_ent_encode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent);
+herr_t H5G_ent_decode (hdf5_file_t *f, uint8 **pp, H5G_entry_t *ent);
+
+/*
+ * These functions operate on symbol table nodes.
+ */
 herr_t H5G_node_debug (hdf5_file_t *f, haddr_t addr, FILE *stream, intn indent,
 		       intn fwidth, haddr_t heap);
 
+/*
+ * These functions operate on shadow entries.
+ */
+herr_t H5G_shadow_flush (hdf5_file_t *f, hbool_t invalidate);
+
+/*
+ * These functions operate on symbol table entries.  They're used primarily
+ * in the H5O package where header messages are cached in symbol table
+ * entries.  The subclasses of H5O probably don't need them though.
+ */
+H5G_entry_t *H5G_ent_calloc (void);
+herr_t H5G_ent_invalidate (H5G_entry_t *ent);
+haddr_t H5G_ent_addr (H5G_entry_t *ent);
+H5G_cache_t *H5G_ent_cache (H5G_entry_t *ent, H5G_type_t *cache_type);
+herr_t H5G_ent_modified (H5G_entry_t *ent, H5G_type_t cache_type);
+herr_t H5G_ent_debug (hdf5_file_t *f, H5G_entry_t *ent, FILE *stream,
+		      intn indent, intn fwidth);
 
 #endif
 
diff --git a/src/H5Gshad.c b/src/H5Gshad.c
index 6dc997f..315abed 100644
--- a/src/H5Gshad.c
+++ b/src/H5Gshad.c
@@ -15,13 +15,11 @@
 #include <H5Oprivate.h>			/*object header messages	*/
 
 #define PABLO_MASK	H5G_shadow_mask
+#undef DEBUG_SHADOWS
 
 /* Is the interface initialized? */
 static hbool_t interface_initialize_g = FALSE;
 
-/* Shadow hash table */
-#define H5G_NSHADOWS	10331
-
 typedef struct H5G_hash_t {
    haddr_t		dir_addr;
    H5G_shadow_t		*head;
@@ -29,8 +27,92 @@ typedef struct H5G_hash_t {
    struct H5G_hash_t	*prev;
 } H5G_hash_t;
 
-static H5G_hash_t *H5G_shadow_g[H5G_NSHADOWS];
-
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_shadow_check
+ *
+ * Purpose:	Checks the shadow data structures for validity.  This is a
+ *		debugging function only--it aborts on failure!
+ *
+ * Return:	void
+ *
+ * Programmer:	Robb Matzke
+ *              Sunday, September 21, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifdef DEBUG_SHADOWS
+void
+H5G_shadow_check (hdf5_file_t *f)
+{
+   H5G_hash_t	*hash=NULL;
+   H5G_shadow_t	*shadow=NULL, *prev_shadow=NULL;
+   uintn	idx;
+   hbool_t	shadow_error=FALSE;
+   uintn	nerrors=0;
+   static int	ncalls=0;
+
+   ncalls++;
+
+   for (idx=0; idx<f->nshadows; idx++) {
+      for (hash=f->shadow[idx]; hash; hash=hash->next) {
+	 for (shadow=hash->head,prev_shadow=NULL;
+	      shadow;
+	      shadow=shadow->next) {
+	    shadow_error = FALSE;
+	    
+	    /* Each shadow has a name and the names are in order */
+	    if (!shadow->name) {
+	       fprintf (stderr, "name=NULL, ");
+	       shadow_error = TRUE;
+	    }
+	    if (prev_shadow && strcmp (prev_shadow->name, shadow->name)>=0) {
+	       fprintf (stderr, "names not sorted, ");
+	       shadow_error = TRUE;
+	    }
+	    
+	    /* Valid directory addresses */
+	    if (shadow->dir_addr<0 || (shadow->dir_addr==0 && idx!=0)) {
+	       fprintf (stderr, "dir_addr=%lu, ",
+			(unsigned long)(shadow->dir_addr));
+	       shadow_error = TRUE;
+	    } else if (shadow->dir_addr!=hash->dir_addr) {
+	       fprintf (stderr, "dir_addr=%lu (not %lu), ",
+			(unsigned long)(shadow->dir_addr),
+			(unsigned long)(hash->dir_addr));
+	    }
+	    
+	    /* Linked to symbol table entry */
+	    if (shadow->main && shadow!=shadow->main->shadow) {
+	       fprintf (stderr, "entry linkage problem, ");
+	       shadow_error = TRUE;
+	    }
+
+	    /* Shadow linked list is consistent */
+	    if (shadow->prev && prev_shadow!=shadow->prev) {
+	       fprintf (stderr, "shadow linked list problem, ");
+	       shadow_error = TRUE;
+	    }
+	    prev_shadow = shadow;
+
+	    /* If an error occurred then print other info */
+	    if (shadow_error) {
+	       fprintf (stderr, "idx=%u, shadow=0x%08lx, dir_addr=%lu\n",
+			idx, (unsigned long)shadow,
+			(unsigned long)(shadow->dir_addr));
+	       nerrors++;
+	    }
+	 }
+      }
+   }
+   if (nerrors) {
+      fprintf (stderr, "Error in H5G_shadow_check, call %d\n",  ncalls);
+      abort ();
+   }
+}
+#endif
 
 
 /*-------------------------------------------------------------------------
@@ -171,14 +253,14 @@ H5G_shadow_sync (H5G_entry_t *ent)
  *-------------------------------------------------------------------------
  */
 H5G_shadow_t *
-H5G_shadow_list (haddr_t dir_addr)
+H5G_shadow_list (hdf5_file_t *f, haddr_t dir_addr)
 {
-   uintn	idx = dir_addr % H5G_NSHADOWS;
+   uintn	idx = dir_addr % f->nshadows;
    H5G_hash_t	*bucket = NULL;
 
    FUNC_ENTER (H5G_shadows, NULL, NULL);
 
-   for (bucket=H5G_shadow_g[idx]; bucket; bucket=bucket->next) {
+   for (bucket=f->shadow[idx]; bucket; bucket=bucket->next) {
       if (bucket->dir_addr==dir_addr) {
 	 HRETURN (bucket->head);
       }
@@ -223,7 +305,11 @@ H5G_shadow_assoc_node (hdf5_file_t *f, H5G_node_t *sym, H5G_ac_ud1_t *ac_udata)
    assert (sym);		/* The symbol table node	*/
    assert (ac_udata);		/* The symbol table header info	*/
 
-   if ((shadow=H5G_shadow_list (ac_udata->dir_addr))) {
+#ifdef DEBUG_SHADOWS
+   H5G_shadow_check (f);
+#endif
+
+   if ((shadow=H5G_shadow_list (f, ac_udata->dir_addr))) {
       heap_addr = ac_udata->heap_addr;
 
       while (i<sym->nsyms && shadow) {
@@ -240,6 +326,8 @@ H5G_shadow_assoc_node (hdf5_file_t *f, H5G_node_t *sym, H5G_ac_ud1_t *ac_udata)
 	 if (i<sym->nsyms && s && shadow && !strcmp (s,  shadow->name)) {
 	    shadow->main = sym->entry + i;
 	    sym->entry[i].shadow = shadow;
+	    i++;
+	    shadow = shadow->next;
 	 }
       }
    }
@@ -247,7 +335,6 @@ H5G_shadow_assoc_node (hdf5_file_t *f, H5G_node_t *sym, H5G_ac_ud1_t *ac_udata)
    FUNC_LEAVE (SUCCEED);
 }
 
-
 
 /*-------------------------------------------------------------------------
  * Function:	H5G_shadow_open
@@ -257,6 +344,8 @@ H5G_shadow_assoc_node (hdf5_file_t *f, H5G_node_t *sym, H5G_ac_ud1_t *ac_udata)
  *		object, open the object (again) and return a handle
  *		to it.
  *
+ * 		DIR can be the null pointer if `ent' is the root entry.
+ *
  * Return:	Success:	Handle to open object
  *
  *		Failure:	NULL
@@ -275,89 +364,109 @@ H5G_shadow_open (hdf5_file_t *f, H5G_entry_t *dir, H5G_entry_t *ent)
    H5O_stab_t 	stab;
    const char 	*s = NULL;
    H5G_hash_t	*hash = NULL;
-   H5G_shadow_t	*hash_ent = NULL;
+   H5G_shadow_t	*hash_ent = NULL, *prev_ent = NULL;
    uintn	idx;
    H5O_name_t	name_mesg = {NULL};
    H5G_entry_t	*ret_value = NULL;
+   haddr_t	dir_addr;
    
    FUNC_ENTER (H5G_shadow_open, NULL, NULL);
 
    /* check args */
    assert (f);
-   assert (dir);
+   assert (ent==f->root_sym || dir);
    assert (ent);
+   dir_addr = dir ? dir->header : 0;
 
-   if (ent->shadow) {
+   if ((shadow = ent->shadow)) {
       /*
        * Object is already open.  Open it again.
        */
-      ent->shadow->nrefs += 1;
-      HRETURN (ent);
-      
-   } else {
-      shadow = H5MM_xcalloc (1, sizeof(H5G_shadow_t));
-
-      if (ent==f->root_sym && dir->header<=0) {
-	 /*
-	  * We're opening the root entry.
-	  */
-	 if (H5O_read (f, NO_ADDR, ent, H5O_NAME, 0, &name_mesg)) {
-	    shadow->name = H5MM_xstrdup (name_mesg.s);
-	    H5O_reset (H5O_NAME, &name_mesg);
-	 } else {
-	    shadow->name = H5MM_xstrdup ("Root Object");
-	 }
+      shadow->nrefs += 1;
+      HRETURN (&(shadow->entry));
+   }
 
-      } else {
-	 /*
-	  * Some entry other than the root.
-	  */
-	 if (NULL==H5O_read (f, NO_ADDR, dir, H5O_STAB, 0, &stab)) {
-	    HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
-	 }
-	 if (NULL==(s=H5H_peek (f, stab.heap_addr, ent->name_off))) {
-	    HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
-	 }
-	 shadow->name = H5MM_xstrdup (s);
-      }
-      
+   
+   shadow = H5MM_xcalloc (1, sizeof(H5G_shadow_t));
+   if (ent==f->root_sym && 0==dir_addr) {
       /*
-       * Build the new shadow.
+       * We're opening the root entry.
        */
-      ent->shadow = shadow;
-      shadow->main = ent;
-      shadow->nrefs = 1;
-      shadow->entry = *ent;
-      shadow->entry.dirty = FALSE;
-      shadow->dir_addr = dir->header;
-      
+      if (H5O_read (f, NO_ADDR, ent, H5O_NAME, 0, &name_mesg)) {
+	 shadow->name = H5MM_xstrdup (name_mesg.s);
+	 H5O_reset (H5O_NAME, &name_mesg);
+      } else {
+	 shadow->name = H5MM_xstrdup ("Root Object");
+      }
+
+   } else {
       /*
-       * Link it into the shadow heap
+       * Some entry other than the root.
        */
-      idx = dir->header % H5G_NSHADOWS;
-      for (hash=H5G_shadow_g[idx]; hash; hash=hash->next) {
-	 if (hash->dir_addr==dir->header) break;
+      if (NULL==H5O_read (f, NO_ADDR, dir, H5O_STAB, 0, &stab)) {
+	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
       }
-      if (!hash) {
-	 hash = H5MM_xcalloc (1, sizeof(H5G_hash_t));
-	 hash->dir_addr = dir->header;
-	 hash->next = H5G_shadow_g[idx];
-	 H5G_shadow_g[idx] = hash;
+      if (NULL==(s=H5H_peek (f, stab.heap_addr, ent->name_off))) {
+	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
       }
-      for (hash_ent=hash->head; hash_ent; hash_ent=hash_ent->next) {
+      shadow->name = H5MM_xstrdup (s);
+   }
+
+   /*
+    * Build the new shadow.
+    */
+   ent->shadow = shadow;
+   shadow->main = ent;
+   shadow->nrefs = 1;
+   shadow->entry = *ent;
+   shadow->entry.dirty = FALSE;
+   shadow->dir_addr = dir_addr;
+
+   /*
+    * Link it into the shadow heap
+    */
+   idx = dir_addr % f->nshadows;
+   for (hash=f->shadow[idx]; hash; hash=hash->next) {
+      if (hash->dir_addr==dir_addr) break;
+   }
+   if (!hash) {
+      hash = H5MM_xcalloc (1, sizeof(H5G_hash_t));
+      hash->dir_addr = dir_addr;
+      hash->next = f->shadow[idx];
+      f->shadow[idx] = hash;
+      if (hash->next) hash->next->prev = hash;
+   }
+   if (hash->head) {
+      for (hash_ent=hash->head,prev_ent=NULL;
+	   hash_ent;
+	   hash_ent=hash_ent->next) {
 	 if (strcmp (shadow->name, hash_ent->name)<0) break;
+	 prev_ent = hash_ent;
       }
       if (hash_ent) {
+	 /* Insert SHADOW before HASH_ENT */
 	 if (hash_ent->prev) hash_ent->prev->next = shadow;
 	 else hash->head = shadow;
 	 shadow->prev = hash_ent->prev;
 	 shadow->next = hash_ent;
 	 hash_ent->prev = shadow;
       } else {
-	 hash->head = shadow;
+	 /* Append SHADOW to list */
+	 assert (prev_ent && NULL==prev_ent->next);
+	 prev_ent->next = shadow;
+	 shadow->prev = prev_ent;
       }
+   } else {
+      /* Insert shadow at head of list */
+      shadow->next = hash->head;
+      if (hash->head) hash->head->prev = shadow;
+      hash->head = shadow;
    }
 
+#ifdef DEBUG_SHADOWS
+   H5G_shadow_check (f);
+#endif
+
    ret_value = &(shadow->entry);
 
  done:
@@ -423,8 +532,8 @@ H5G_shadow_close (hdf5_file_t *f, H5G_entry_t *ent)
       H5G_shadow_dissociate (ent);
 
       /* find symtabs shadow list */
-      idx = shadow->dir_addr % H5G_NSHADOWS;
-      for (hash=H5G_shadow_g[idx]; hash; hash=hash->next) {
+      idx = shadow->dir_addr % f->nshadows;
+      for (hash=f->shadow[idx]; hash; hash=hash->next) {
 	 if (hash->dir_addr==shadow->dir_addr) break;
       }
       assert (hash);
@@ -445,7 +554,7 @@ H5G_shadow_close (hdf5_file_t *f, H5G_entry_t *ent)
       /* remove symtab's shadow list if empty */
       if (!hash->head) {
 	 if (hash->prev) hash->prev->next = hash->next;
-	 else H5G_shadow_g[idx] = hash->next;
+	 else f->shadow[idx] = hash->next;
 	 if (hash->next) hash->next->prev = hash->prev;
 	 H5MM_xfree (hash);
       }
@@ -453,3 +562,153 @@ H5G_shadow_close (hdf5_file_t *f, H5G_entry_t *ent)
 
    FUNC_LEAVE (SUCCEED);
 }
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_shadow_move
+ *
+ * Purpose:	Moves the SHADOW for some entry to correspond to a
+ *		NEW_ENTRY. The DIR_ADDR is the address for the directory
+ *		which contains NEW_ENTRY.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, September 19, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_shadow_move (hdf5_file_t *f, H5G_shadow_t *shadow, const char *new_name,
+		 H5G_entry_t *new_entry, haddr_t dir_addr)
+{
+   H5G_hash_t	*hash;
+   uintn	idx;
+   
+   FUNC_ENTER (H5G_shadow_move, NULL, FAIL);
+
+   assert (shadow);
+   assert (new_entry);
+   assert (dir_addr>0);
+
+   if (0==shadow->dir_addr) {
+      /*
+       * We're moving the shadow for the root object.  This simplifies things
+       * greatly since it implies that this is the only shadow currently
+       * defined for the entire file.
+       */
+      idx = dir_addr % f->nshadows;
+      assert (NULL==f->shadow[idx]); 	/*Nothing at new idx...		*/
+      hash = f->shadow[0];
+      assert (hash);			/*..but root idx has something. */
+      assert (0==hash->dir_addr);	/*..and it's the root something	*/
+      assert (NULL==hash->next);	/*..and just that		*/
+      assert (hash->head==shadow);	/*..and exactly that		*/
+
+      /* Move root entry to new hash bucket */
+      f->shadow[idx] = hash;
+      f->shadow[0] = NULL;
+      hash->dir_addr = dir_addr;
+
+      /* Associate SHADOW with NEW_ENTRY */
+      shadow->dir_addr = dir_addr;
+      shadow->main = new_entry;
+      new_entry->shadow = shadow;
+
+      /* Give the shadow a new name */
+      H5MM_xfree (shadow->name);
+      shadow->name = H5MM_xstrdup (new_name);
+      
+   } else {
+      /*
+       * Other shadows never move.
+       */
+      assert (shadow->dir_addr==dir_addr);
+      shadow->main = new_entry;
+      new_entry->shadow = shadow;
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_shadow_flush
+ *
+ * Purpose:	Flush all open object information to the main cache.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL if INVALIDATE is non-zero and there are
+ *				open objects.
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, September 19, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5G_shadow_flush (hdf5_file_t *f, hbool_t invalidate)
+{
+   uintn	idx;
+   H5G_hash_t	*hash = NULL;
+   H5G_shadow_t	*shadow = NULL;
+   intn		nfound=0;
+
+   FUNC_ENTER (H5G_shadow_flush, NULL, FAIL);
+
+   for (idx=0; idx<f->nshadows; idx++) {
+      for (hash=f->shadow[idx]; hash; hash=hash->next) {
+	 for (shadow=hash->head; shadow; shadow=shadow->next) {
+	    if (!shadow->main &&
+		NULL==H5G_stab_find (f, shadow->dir_addr, NULL,
+				     shadow->name)) {
+	       HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+	    }
+	    assert (shadow->main);
+	    *(shadow->main) = shadow->entry;
+	    shadow->entry.dirty = FALSE;
+	    nfound++;
+	    
+#ifndef NDEBUG
+	    /*
+	     * This is usually a bad thing--an hdf5 programmer forgot to
+	     * close some object before closing the file.  Since this is hard
+	     * to debug, we'll be nice and print the names here.  We don't
+	     * know the full name, but we'll print the file address (relative
+	     * to the boot block) of the object header for the directory that
+	     * contains the open object.
+	     */
+	    if (invalidate) {
+	       fprintf (stderr, "Open object <%lu>/%s",
+			(unsigned long)(shadow->dir_addr),
+			shadow->name);
+	       if (shadow->nrefs>1) {
+		  fprintf (stderr,  " (%d times)", shadow->nrefs);
+	       }
+	       fputc ('\n', stderr);
+	    }
+#endif
+	 }
+      }
+   }
+
+   if (invalidate && nfound) {
+      /*
+       * No clean easy way to do this, just leak the memory.  If we free a
+       * shadow and then something else tries to access it (perhaps to close
+       * it) then they trample on freed memory.
+       */
+      HRETURN_ERROR (H5E_SYM, H5E_UNSUPPORTED, FAIL);
+   }
+
+   FUNC_LEAVE (SUCCEED);
+}
diff --git a/src/H5Gstab.c b/src/H5Gstab.c
new file mode 100644
index 0000000..209cbc4
--- /dev/null
+++ b/src/H5Gstab.c
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 1997 National Center for Supercomputing Applications
+ *                    All rights reserved.
+ *
+ * Programmer: Robb Matzke <matzke@llnl.gov>
+ *             Friday, September 19, 1997
+ *
+ */
+#define H5G_PACKAGE
+
+#include <H5private.h>
+#include <H5ACprivate.h>
+#include <H5Eprivate.h>
+#include <H5Gpkg.h>
+#include <H5Hprivate.h>
+#include <H5MMprivate.h>
+#include <H5Oprivate.h>
+
+#define PABLO_MASK	H5G_stab_mask
+static hbool_t interface_initialize_g = FALSE;
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_stab_new
+ *
+ * Purpose:	Creates a new empty symbol table (object header, name heap,
+ *		and B-tree).  The caller can specify an initial size for the
+ *		name heap.
+ *
+ * 		In order for the B-tree to operate correctly, the first
+ *		item in the heap is the empty string, and must appear at
+ *		heap offset zero.
+ *
+ * Errors:
+ *		INTERNAL  CANTINIT      B-tree's won't work if the first
+ *		                        name isn't at the beginning of the
+ *		                        heap. 
+ *		SYM       CANTINIT      Can't create B-tree. 
+ *		SYM       CANTINIT      Can't create header. 
+ *		SYM       CANTINIT      Can't create heap. 
+ *		SYM       CANTINIT      Can't create message. 
+ *		SYM       CANTINIT      Can't initialize heap. 
+ *
+ * Return:	Success:	Address of new symbol table header.  If
+ *				the caller supplies a symbol table entry
+ *				SELF then it will be initialized to point to
+ *				this symbol table.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Aug  1 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+haddr_t
+H5G_stab_new (hdf5_file_t *f, H5G_entry_t *self, size_t init)
+{
+   off_t	name;				/*offset of "" name	*/
+   haddr_t	addr;				/*object header address	*/
+   H5O_stab_t	stab;				/*symbol table message	*/
+
+   FUNC_ENTER (H5G_stab_new, NULL, FAIL);
+
+   /*
+    * Check arguments.
+    */
+   assert (f);
+   init = MAX(init, H5H_SIZEOF_FREE(f)+2);
+
+   /* Create symbol table private heap */
+   if ((stab.heap_addr = H5H_new (f, H5H_LOCAL, init))<0) {
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create heap*/
+   }
+   if ((name = H5H_insert (f, stab.heap_addr, 1, "")<0)) {
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't initialize heap*/
+   }
+   if (0!=name) {
+      /*
+       * B-tree's won't work if the first name isn't at the beginning
+       * of the heap.
+       */
+      HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL);
+   }
+
+   /* Create the B-tree */
+   if ((stab.btree_addr = H5B_new (f, H5B_SNODE))<0) {
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create B-tree*/
+   }
+
+   /*
+    * Create symbol table object header.  It has a zero link count
+    * since nothing refers to it yet.  The link count will be
+    * incremented if the object is added to the directory hierarchy.
+    */
+   if ((addr = H5O_new (f, 0, 4+2*H5F_SIZEOF_OFFSET(f)))<0) {
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create header*/
+   }
+   
+   /* insert the symbol table message */
+   if (self) {
+      memset (self, 0, sizeof(H5G_entry_t));
+      self->header = addr;
+   }
+   if (H5O_modify(f, addr, self, H5O_STAB, H5O_NEW_MESG, &stab)<0) {
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create message*/
+   }
+
+   FUNC_LEAVE (addr);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_stab_find
+ *
+ * Purpose:	Finds a symbol named NAME in the symbol table whose
+ *		description is stored in SELF in file F and returns a
+ *		pointer to the symbol table entry.  SELF is optional if the
+ *		symbol table address is supplied through ADDR.
+ *
+ * Errors:
+ *		SYM       BADMESG       Can't read message. 
+ *		SYM       NOTFOUND      Not found. 
+ *
+ * Return:	Success:	Pointer to the symbol table entry.
+ *				The pointer is intended for immediate
+ *				read-only access since it points
+ *				directly to an entry in a cached
+ *				symbol table node.  The pointer is
+ *				guaranteed to be valid only until the
+ *				next call to one of the H5AC functions.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Aug  1 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5G_entry_t *
+H5G_stab_find (hdf5_file_t *f, haddr_t addr, H5G_entry_t *self,
+	       const char *name)
+{
+   H5G_bt_ud1_t         udata;		/*data to pass through B-tree	*/
+   H5O_stab_t		stab;		/*symbol table message		*/
+
+   FUNC_ENTER (H5G_stab_find, NULL, NULL);
+
+   /* Check arguments */
+   assert (f);
+   if (addr<=0 && (!self || self->header<=0)) {
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+   }
+   if (!name || !*name) {
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+   }
+   if (addr<=0) addr = self->header;
+
+   /* set up the udata */
+   if (NULL==H5O_read (f, addr, self, H5O_STAB, 0, &stab)) {
+      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL); /*can't read message*/
+   }
+   udata.operation = H5G_OPER_FIND;
+   udata.name = name;
+   udata.heap_addr = stab.heap_addr;
+   udata.dir_addr = addr;
+   udata.node_ptr = NULL;
+
+   /* search the B-tree */
+   if (H5B_find (f, H5B_SNODE, stab.btree_addr, &udata)<0) {
+      if (udata.node_ptr) {
+	 H5AC_unprotect (f, H5AC_SNODE, udata.node_addr, udata.node_ptr);
+      }
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL); /*not found*/
+   }
+
+   /* Unprotect the symbol table node */
+   if (udata.node_ptr) {
+      if (H5AC_unprotect (f, H5AC_SNODE, udata.node_addr, udata.node_ptr)<0) {
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL);
+      }
+   }
+
+   /* return the result */
+   FUNC_LEAVE (udata.entry_ptr);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_stab_insert
+ *
+ * Purpose:	Insert a new symbol into the table described by SELF in
+ *		file F.  The name of the new symbol is NAME and its symbol
+ *		table entry is ENT.
+ *
+ * Errors:
+ *		SYM       BADMESG       Can't read message. 
+ *		SYM       CANTINSERT    Can't insert entry. 
+ *
+ * Return:	Success:	Pointer to the cached symbol table entry.
+ *				This is a pointer directly into a symbol
+ *				table node and will become invalid on the
+ *				next call to the H5AC package.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Aug  1 1997
+ *
+ * Modifications:
+ *
+ * 	Robb Matzke, 18 Sep 1997
+ *	If ENT has a shadow, then the shadow will be associated with the
+ *	entry when it is added to the symbol table.
+ *
+ *-------------------------------------------------------------------------
+ */
+H5G_entry_t *
+H5G_stab_insert (hdf5_file_t *f, H5G_entry_t *self, const char *name,
+		 H5G_entry_t *ent)
+{
+   H5O_stab_t		stab;		/*symbol table message		*/
+   H5G_bt_ud1_t		udata;		/*data to pass through B-tree	*/
+
+   FUNC_ENTER (H5G_stab_insert, NULL, NULL);
+
+   /* check arguments */
+   assert (f);
+   assert (self && self->header>=0);
+   assert (name && *name);
+   assert (ent);
+   
+   /* initialize data to pass through B-tree */
+   if (NULL==H5O_read (f, self->header, self, H5O_STAB, 0, &stab)) {
+      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL); /*can't read message*/
+   }
+
+   udata.operation = H5G_OPER_INSERT;
+   udata.name = name;
+   udata.heap_addr = stab.heap_addr;
+   udata.dir_addr = self->header;
+   udata.entry = *ent;
+   udata.entry.name_off = -1;
+   udata.node_ptr = NULL;
+
+   /* insert */
+   if (H5B_insert (f, H5B_SNODE, stab.btree_addr, &udata)<0) {
+      if (udata.node_ptr) {
+	 H5AC_unprotect (f, H5AC_SNODE, udata.node_addr, udata.node_ptr);
+      }
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINSERT, NULL); /*can't insert entry*/
+   }
+
+   /*
+    * The H5G_node_insert() called H5AC_protect() for the node so that the
+    * udata.entry_ptr field didn't become invalid on the way back out of the
+    * B-tree code.  We unprotect it now, but the pointer will remain valid
+    * until the next call to H5AC.
+    */
+   if (H5AC_unprotect (f, H5AC_SNODE, udata.node_addr, udata.node_ptr)<0) {
+      HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL); /*can't unprotect*/
+   }
+
+   /* update the name offset in the entry */
+   ent->name_off = udata.entry.name_off;
+   FUNC_LEAVE (udata.entry_ptr);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5G_stab_list
+ *
+ * Purpose:	Returns a list of all the symbols in a symbol table.
+ *		The caller allocates an array of pointers which this
+ *		function will fill in with malloc'd names.  The caller
+ *		also allocates an array of symbol table entries which will
+ *		be filled in with data from the symbol table.  Each of these
+ *		arrays should have at least MAXENTRIES elements.
+ *
+ * Errors:
+ *		SYM       BADMESG       Not a symbol table. 
+ *		SYM       CANTLIST      B-tree list failure. 
+ *
+ * Return:	Success:	The total number of symbols in the
+ *				symbol table.  This may exceed MAXENTRIES,
+ *				but at most MAXENTRIES values are copied
+ *				into the NAMES and ENTRIES arrays.
+ *
+ *		Failure:	FAIL, the pointers in NAMES are undefined but
+ *			 	no memory is allocated.  The values in
+ *				ENTRIES are undefined.
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Aug  1 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5G_stab_list (hdf5_file_t *f, H5G_entry_t *self, intn maxentries,
+	       char *names[], H5G_entry_t entries[])
+{
+   H5G_bt_ud2_t		udata;
+   H5O_stab_t		stab;
+   intn			i;
+
+   FUNC_ENTER (H5G_stab_list, NULL, FAIL);
+
+   /* check args */
+   assert (f);
+   assert (self && self->header>=0);
+   assert (maxentries>=0);
+
+   /* initialize data to pass through B-tree */
+   if (NULL==H5O_read (f, self->header, self, H5O_STAB, 0, &stab)) {
+      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL); /*not a symbol table*/
+   }
+   udata.entry = entries;
+   udata.name = names;
+   udata.dir_addr = self->header;
+   udata.heap_addr = stab.heap_addr;
+   udata.maxentries = maxentries;
+   udata.nsyms = 0;
+   if (names) HDmemset (names, 0, maxentries);
+
+   /* list */
+   if (H5B_list (f, H5B_SNODE, stab.btree_addr, &udata)<0) {
+      if (names) {
+	 for (i=0; i<maxentries; i++) H5MM_xfree (names[i]);
+      }
+      HRETURN_ERROR (H5E_SYM, H5E_CANTLIST, FAIL); /*B-tree list failure*/
+   }
+
+   FUNC_LEAVE (udata.nsyms);
+}
+   
diff --git a/src/H5O.c b/src/H5O.c
index 8509e41..96a9063 100644
--- a/src/H5O.c
+++ b/src/H5O.c
@@ -501,16 +501,17 @@ H5O_reset (const H5O_class_t *type, void *native)
  *-------------------------------------------------------------------------
  */
 intn
-H5O_link (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent, intn adjust)
+H5O_link (hdf5_file_t *f, H5G_entry_t *ent, intn adjust)
 {
    H5O_t	*oh = NULL;
+   haddr_t	addr;
    
    FUNC_ENTER (H5O_link, NULL, FAIL);
 
    /* check args */
    assert (f);
-   assert (addr>0 || (ent && ent->header>0));
-   if (addr<=0) addr = ent->header;
+   assert (ent && H5G_ent_addr (ent)>0);
+   addr = H5G_ent_addr (ent);
    
    /* get header */
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL))) {
@@ -529,10 +530,7 @@ H5O_link (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent, intn adjust)
       }
    } else {
       oh->nlink += adjust;
-      if (oh->nlink>1 && ent && H5G_NOTHING_CACHED!=ent->type) {
-	 ent->dirty = TRUE;
-	 ent->type = H5G_NOTHING_CACHED;
-      }
+      if (oh->nlink>1) H5G_ent_invalidate (ent);
    }
 
    oh->dirty = TRUE;
@@ -568,22 +566,29 @@ H5O_read (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent,
    H5O_t	*oh = NULL;
    void		*retval = NULL;
    intn		idx;
+   H5G_cache_t	*cache = NULL;
+   H5G_type_t	cache_type;
    
    FUNC_ENTER (H5O_read, NULL, NULL);
 
    /* check args */
    assert (f);
-   if (addr<=0 && (!ent || ent->header<=0)) {
+   if (addr<=0 && !ent) {
+      HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL);
+   }
+   if (addr<=0 && (addr=H5G_ent_addr (ent))<=0) {
       HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL);
    }
-   if (addr<=0) addr = ent->header;
    assert (sequence>=0);
 
    /* can we get it from the symbol table? */
-   if (ent && H5G_NOTHING_CACHED!=ent->type && type && type->fast) {
-      retval = (type->fast)(ent, mesg);
-      if (retval) HRETURN (retval);
-      H5ECLEAR;
+   if (ent) {
+      cache = H5G_ent_cache (ent, &cache_type);
+      if (type && cache_type==type->cache_type && type->fast) {
+	 retval = (type->fast)(cache, mesg);
+	 if (retval) HRETURN (retval);
+	 H5ECLEAR;
+      }
    }
 
    /* can we get it from the object header? */
@@ -759,10 +764,10 @@ H5O_modify (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent,
 
    /* check args */
    assert (f);
-   assert (addr>0 || (ent && ent->header>0));
+   assert (addr>0 || (ent && H5G_ent_addr (ent)>0));
    assert (type);
    assert (mesg);
-   if (addr<=0) addr = ent->header;
+   if (addr<=0) addr = H5G_ent_addr (ent);
    
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL))) {
       HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL);
@@ -805,8 +810,11 @@ H5O_modify (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent,
 
    /* Copy into the symbol table entry */
    if (oh->nlink<=1 && ent && type->cache) {
-      hbool_t modified = (type->cache)(ent, mesg);
-      if (ent && !ent->dirty) ent->dirty = modified;
+      H5G_type_t cache_type;
+      H5G_cache_t *cache = H5G_ent_cache (ent, &cache_type);
+      hbool_t modified = (type->cache)(&cache_type, cache, mesg);
+      if (modified) H5G_ent_modified (ent, cache_type);
+      
    }
 
    FUNC_LEAVE (sequence);
@@ -854,9 +862,9 @@ H5O_remove (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent,
 
    /* check args */
    assert (f);
-   assert (addr>0 || (ent && ent->header>0));
+   assert (addr>0 || (ent && H5G_ent_addr (ent)>0));
    assert (type);
-   if (addr<=0) addr = ent->header;
+   if (addr<=0) addr = H5G_ent_addr (ent);
 
    /* load the object header */
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL))) {
@@ -866,11 +874,12 @@ H5O_remove (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent,
    for (i=seq=0; i<oh->nmesgs; i++) {
       if (type->id != oh->mesg[i].type->id) continue;
       if (seq++ == sequence || H5O_ALL==sequence) {
+	 H5G_type_t cache_type;
+	 H5G_ent_cache (ent, &cache_type);
 
 	 /* clear symbol table entry cache */
-	 if (ent && type->cache && type->cache_type==ent->type) {
-	    ent->type = H5G_NOTHING_CACHED;
-	    ent->dirty = TRUE;
+	 if (ent && type->cache && type->cache_type==cache_type) {
+	    H5G_ent_invalidate (ent);
 	 }
 
 	 /* change message type to nil and zero it */
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 30b0af1..d5666eb 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -50,8 +50,8 @@ typedef struct H5O_class_t {
    H5G_type_t	cache_type;		/*type field in symbol table	*/
    void		*(*decode)(hdf5_file_t*,size_t,const uint8*);
    herr_t	(*encode)(hdf5_file_t*,size_t,uint8*,const void*);
-   void		*(*fast)(const H5G_entry_t*, void*); /*get from stab ent*/
-   hbool_t	(*cache)(H5G_entry_t*,const void*); /*put into entry	*/
+   void		*(*fast)(const H5G_cache_t*, void*);/*get from of entry	*/
+   hbool_t	(*cache)(H5G_type_t*, H5G_cache_t*,const void*); /*into entry*/
    void		*(*copy)(const void*,void*); /*copy native value	*/
    size_t	(*raw_size)(hdf5_file_t*,const void*); /*sizeof raw val	*/
    herr_t	(*reset)(void*); /*free nested data structures		*/
@@ -158,7 +158,7 @@ typedef struct H5O_stab_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);
+intn H5O_link (hdf5_file_t *f, H5G_entry_t *ent, intn adjust);
 void *H5O_read (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent,
 		const H5O_class_t *type, intn sequence, void *mesg);
 const void *H5O_peek (hdf5_file_t *f, haddr_t addr, const H5O_class_t *type,
diff --git a/src/H5Osdim.c b/src/H5Osdim.c
index 923ceea..312249b 100644
--- a/src/H5Osdim.c
+++ b/src/H5Osdim.c
@@ -41,8 +41,9 @@ static char RcsId[] = "@(#)$Revision$";
 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_fast (const H5G_cache_t *cache, void *_mesg);
+static hbool_t H5O_sim_dim_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 (hdf5_file_t *f, const void *_mesg);
 static herr_t H5O_sim_dim_debug (hdf5_file_t *f, const void *_mesg,
@@ -208,7 +209,7 @@ H5O_sim_dim_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *mesg)
     for simple dimensionality, as they can be cached in the symbol-table entry)
 --------------------------------------------------------------------------*/
 static void *
-H5O_sim_dim_fast (const H5G_entry_t *ent, void *mesg)
+H5O_sim_dim_fast (const H5G_cache_t *cache, void *mesg)
 {
    H5O_sim_dim_t *sdim = (H5O_sim_dim_t *)mesg;
    uintn u;                    /* local counting variable */
@@ -216,19 +217,15 @@ H5O_sim_dim_fast (const H5G_entry_t *ent, void *mesg)
    FUNC_ENTER (H5O_sim_dim_fast, NULL, NULL);
 
    /* check args */
-   assert (ent);
-
-   if (H5G_CACHED_SDATA==ent->type) {
-      if (!sdim) sdim = H5MM_xcalloc (1, sizeof(H5O_sim_dim_t));
-      sdim->rank = ent->cache.sdata.ndim;
-      assert (sdim->rank<=NELMTS (ent->cache.sdata.dim));
-      sdim->dim_flags = 0;
-      sdim->size = H5MM_xmalloc (sizeof(uint32) * sdim->rank);
-      for (u=0; u<sdim->rank; u++) {
-         sdim->size[u] = ent->cache.sdata.dim[u];
-      }
-   } else {
-      sdim = NULL;
+   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));
+   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];
    }
    
    FUNC_LEAVE (sdim);
@@ -246,6 +243,7 @@ H5O_sim_dim_fast (const H5G_entry_t *ent, void *mesg)
         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
     copies a message into the cached portion of a symbol-table entry.  (This
@@ -253,7 +251,8 @@ H5O_sim_dim_fast (const H5G_entry_t *ent, void *mesg)
     the symbol-table entry)
 --------------------------------------------------------------------------*/
 static hbool_t
-H5O_sim_dim_cache (H5G_entry_t *ent, const void *mesg)
+H5O_sim_dim_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 */
@@ -262,41 +261,42 @@ H5O_sim_dim_cache (H5G_entry_t *ent, const void *mesg)
     FUNC_ENTER (H5O_sim_dim_cache, NULL, BFAIL);
 
     /* check args */
-    assert (ent);
+    assert (cache_type);
+    assert (cache);
     assert (sdim);
 
-    if (sdim->rank <= NELMTS (ent->cache.sdata.dim)) {
-       if (H5G_CACHED_SDATA != ent->type) {
+    if (sdim->rank <= NELMTS (cache->sdata.dim)) {
+       if (H5G_CACHED_SDATA != *cache_type) {
 	  modified = BTRUE;
-	  ent->type = H5G_CACHED_SDATA;
-	  ent->cache.sdata.ndim = sdim->rank;
+	  *cache_type = H5G_CACHED_SDATA;
+	  cache->sdata.ndim = sdim->rank;
 	  for (u=0; u<=sdim->rank; u++) {
-	     ent->cache.sdata.dim[u] = sdim->size[u];
+	     cache->sdata.dim[u] = sdim->size[u];
 	  }
        } else {
-	  if(ent->cache.sdata.ndim!= sdim->rank) {
+	  if(cache->sdata.ndim != sdim->rank) {
 	     modified = BTRUE;
-	     ent->cache.sdata.ndim = sdim->rank;
+	     cache->sdata.ndim = sdim->rank;
           }
 
 	  /* Check each dimension */
-	  if (NULL==ent->cache.sdata.dim) {
+	  if (NULL==cache->sdata.dim) {
 	     modified = BTRUE;
 	  } else {
 	     for (u=0; u<sdim->rank; u++) {
-                if (ent->cache.sdata.dim[u] != sdim->size[u]) {
+                if (cache->sdata.dim[u] != sdim->size[u]) {
                    modified = BTRUE;
-                   ent->cache.sdata.dim[u] = sdim->size[u];
+                   cache->sdata.dim[u] = sdim->size[u];
 		}
 	     }
           }
        }
-    } else if (H5G_CACHED_SDATA == ent->type) {
+    } else if (H5G_CACHED_SDATA == *cache_type) {
        /*
         * Number of dimensions is too large to cache.
         */
        modified = TRUE;
-       ent->type = H5G_NOTHING_CACHED;
+       *cache_type = H5G_NOTHING_CACHED;
     }
        
     FUNC_LEAVE (modified);
@@ -330,25 +330,23 @@ H5O_sim_dim_copy (const void *mesg, void *dest)
    if (!dst)
        dst = H5MM_xcalloc (1, sizeof(H5O_sim_dim_t));
 
-   /* copy */
+   /* deep copy -- pointed-to values are copied also */
    HDmemcpy(dst,src,sizeof(H5O_sim_dim_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));
+
    if(src->rank>0)
      {
-       if(dst->size==NULL)
-           dst->size = H5MM_xcalloc (src->rank, sizeof(uint32));
        HDmemcpy(dst->size,src->size,src->rank*sizeof(uint32));
        /* Check for maximum dimensions and copy those */
        if((src->dim_flags&0x01)>0)
          {
-           if(dst->max==NULL)
-               dst->max = H5MM_xcalloc (src->rank, sizeof(uint32));
            HDmemcpy(dst->max,src->max,src->rank*sizeof(uint32));
          } /* end if */
        /* Check for dimension permutation and copy those */
        if((src->dim_flags&0x02)>0)
          {
-           if(dst->max==NULL)
-               dst->perm = H5MM_xcalloc (src->rank, sizeof(uint32));
            HDmemcpy(dst->perm,src->perm,src->rank*sizeof(uint32));
          } /* end if */
      } /* end if */
diff --git a/src/H5Osdtyp.c b/src/H5Osdtyp.c
index 8920625..08fbba4 100644
--- a/src/H5Osdtyp.c
+++ b/src/H5Osdtyp.c
@@ -41,8 +41,9 @@ static char RcsId[] = "@(#)$Revision$";
 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_fast (const H5G_cache_t *cache, void *_mesg);
+static hbool_t H5O_sim_dtype_cache (H5G_type_t *cache_type, H5G_cache_t *cache,
+				    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,
@@ -166,25 +167,21 @@ H5O_sim_dtype_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *mes
     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_fast (const H5G_cache_t *cache, void *mesg)
 {
    H5O_sim_dtype_t *sdtype = (H5O_sim_dtype_t *)mesg;
    
    FUNC_ENTER (H5O_sim_dtype_fast, NULL, NULL);
 
    /* check args */
-   assert (ent);
+   assert (cache);
 
-   if (H5G_CACHED_SDATA==ent->type) {
-      if (!sdtype) sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t));
-      sdtype->len = ent->cache.sdata.nt.length;
-      sdtype->arch = ent->cache.sdata.nt.arch;
+   if (!sdtype) sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t));
+   sdtype->len = cache->sdata.nt.length;
+   sdtype->arch = cache->sdata.nt.arch;
 
-      /* Convert into atomic base type. */
-      sdtype->base = MAKE_ATOM (H5_DATATYPE, ent->cache.sdata.nt.type);
-   } else {
-      sdtype = NULL;
-   }
+   /* Convert into atomic base type. */
+   sdtype->base = MAKE_ATOM (H5_DATATYPE, cache->sdata.nt.type);
 
    FUNC_LEAVE (sdtype);
 } /* end H5O_sim_dtype_fast() */
@@ -201,50 +198,54 @@ H5O_sim_dtype_fast (const H5G_entry_t *ent, void *mesg)
         const void *mesg;       IN: Pointer to the simple datatype 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_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)
+static herr_t
+H5O_sim_dtype_cache (H5G_type_t *cache_type, H5G_cache_t *cache,
+		     const void *mesg)
 {
     const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg;
     hbool_t modified = BFALSE;
-   
+    
     FUNC_ENTER (H5O_sim_dtype_cache, NULL, BFAIL);
 
     /* check args */
-    assert (ent);
+    assert (cache_type);
+    assert (cache);
     assert (sdtype);
 
-    if (H5G_CACHED_SDATA != ent->type) {
+    if (H5G_CACHED_SDATA != *cache_type) {
        /*
         * No sdata cached yet.
         */
        modified = BTRUE;
-       ent->type = H5G_CACHED_SDATA;
-       ent->cache.sdata.nt.length = sdtype->len;
-       ent->cache.sdata.nt.arch = sdtype->arch;
-       ent->cache.sdata.nt.type = sdtype->base;
+       *cache_type = H5G_CACHED_SDATA;
+       cache->sdata.nt.length = sdtype->len;
+       cache->sdata.nt.arch = sdtype->arch;
+       cache->sdata.nt.type = sdtype->base;
+
     } else {
        /*
         * Some sdata already cached.
         */
-       if (ent->cache.sdata.nt.length != sdtype->len) {
+       if (cache->sdata.nt.length != sdtype->len) {
 	  modified = BTRUE;
-	  ent->cache.sdata.nt.length = sdtype->len;
+	  cache->sdata.nt.length = sdtype->len;
        }
 
-       if (ent->cache.sdata.nt.arch != sdtype->arch) {
+       if (cache->sdata.nt.arch != sdtype->arch) {
 	  modified = BTRUE;
-	  ent->cache.sdata.nt.arch = sdtype->arch;
+	  cache->sdata.nt.arch = sdtype->arch;
        }
 
-       if (ent->cache.sdata.nt.type != (uint16)sdtype->base) {
+       if (cache->sdata.nt.type != (uint16)sdtype->base) {
 	  modified = BTRUE;
-	  ent->cache.sdata.nt.type = (uint16)sdtype->base;
+	  cache->sdata.nt.type = (uint16)sdtype->base;
        }
     }
 
diff --git a/src/H5Ostab.c b/src/H5Ostab.c
index 0b67a73..c4bb67c 100644
--- a/src/H5Ostab.c
+++ b/src/H5Ostab.c
@@ -26,8 +26,9 @@
 static void *H5O_stab_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p);
 static herr_t H5O_stab_encode (hdf5_file_t *f, size_t size, uint8 *p,
 			       const void *_mesg);
-static void *H5O_stab_fast (const H5G_entry_t *ent, void *_mesg);
-static hbool_t H5O_stab_cache (H5G_entry_t *ent, const void *_mesg);
+static void *H5O_stab_fast (const H5G_cache_t *cache, void *_mesg);
+static hbool_t H5O_stab_cache (H5G_type_t *cache_type, H5G_cache_t *cache,
+			       const void *_mesg);
 static void *H5O_stab_copy (const void *_mesg, void *_dest);
 static size_t H5O_stab_size (hdf5_file_t *f, const void *_mesg);
 static herr_t H5O_stab_debug (hdf5_file_t *f, const void *_mesg,
@@ -133,8 +134,8 @@ H5O_stab_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *_mesg)
 /*-------------------------------------------------------------------------
  * Function:	H5O_stab_fast
  *
- * Purpose:	Initializes a new message struct with info from a symbol
- *		table entry.
+ * Purpose:	Initializes a new message struct with info from the cache of
+ *		a symbol table entry.
  *
  * Return:	Success:	Ptr to message struct, allocated if none
  *				supplied.
@@ -150,22 +151,18 @@ H5O_stab_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *_mesg)
  *-------------------------------------------------------------------------
  */
 static void *
-H5O_stab_fast (const H5G_entry_t *ent, void *_mesg)
+H5O_stab_fast (const H5G_cache_t *cache, void *_mesg)
 {
    H5O_stab_t	*stab = (H5O_stab_t *)_mesg;
    
    FUNC_ENTER (H5O_stab_fast, NULL, NULL);
 
    /* check args */
-   assert (ent);
+   assert (cache);
 
-   if (H5G_CACHED_STAB==ent->type) {
-      if (!stab) stab = H5MM_xcalloc (1, sizeof(H5O_stab_t));
-      stab->btree_addr = ent->cache.stab.btree_addr;
-      stab->heap_addr = ent->cache.stab.heap_addr;
-   } else {
-      stab = NULL;
-   }
+   if (!stab) stab = H5MM_xcalloc (1, sizeof(H5O_stab_t));
+   stab->btree_addr = cache->stab.btree_addr;
+   stab->heap_addr = cache->stab.heap_addr;
 
    FUNC_LEAVE (stab);
 }
@@ -177,8 +174,9 @@ H5O_stab_fast (const H5G_entry_t *ent, void *_mesg)
  * Purpose:	Copies a message into the cache portion of a symbol table
  *		entry.
  *
- * Return:	Success:	TRUE if modified.
- *				FALSE if not modified.
+ * Return:	Success:	TRUE if modified; FALSE if not modified.
+ *				In either case, the new cache type is
+ *				returned through the CACHE_TYPE argument.
  *
  *		Failure:	FAIL
  *
@@ -191,7 +189,7 @@ H5O_stab_fast (const H5G_entry_t *ent, void *_mesg)
  *-------------------------------------------------------------------------
  */
 static hbool_t
-H5O_stab_cache (H5G_entry_t *ent, const void *_mesg)
+H5O_stab_cache (H5G_type_t *cache_type, H5G_cache_t *cache, const void *_mesg)
 {
    const H5O_stab_t	*stab = (const H5O_stab_t *)_mesg;
    hbool_t		modified = FALSE;
@@ -199,28 +197,24 @@ H5O_stab_cache (H5G_entry_t *ent, const void *_mesg)
    FUNC_ENTER (H5O_stab_cache, NULL, FAIL);
 
    /* check args */
-   assert (ent);
+   assert (cache_type);
+   assert (cache);
    assert (stab);
 
-   /*
-    * We do this in two steps so Purify doesn't complain about
-    * uninitialized memory reads even though they don't bother
-    * anything.
-    */
-   if (H5G_CACHED_STAB != ent->type) {
+   if (H5G_CACHED_STAB != *cache_type) {
       modified = TRUE;
-      ent->type = H5G_CACHED_STAB;
-      ent->cache.stab.btree_addr = stab->btree_addr;
-      ent->cache.stab.heap_addr = stab->heap_addr;
+      *cache_type = H5G_CACHED_STAB;
+      cache->stab.btree_addr = stab->btree_addr;
+      cache->stab.heap_addr = stab->heap_addr;
    } else {
-      if (ent->cache.stab.btree_addr != stab->btree_addr) {
+      if (cache->stab.btree_addr != stab->btree_addr) {
 	 modified = TRUE;
-	 ent->cache.stab.btree_addr = stab->btree_addr;
+	 cache->stab.btree_addr = stab->btree_addr;
       }
 
-      if (ent->cache.stab.heap_addr != stab->heap_addr) {
+      if (cache->stab.heap_addr != stab->heap_addr) {
 	 modified = TRUE;
-	 ent->cache.stab.heap_addr = stab->heap_addr;
+	 cache->stab.heap_addr = stab->heap_addr;
       }
    }
 
diff --git a/src/Makefile.in b/src/Makefile.in
index 9308965..cebf3c1 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -15,9 +15,9 @@ PROGS=debug
 
 # Source and object files for the library (lexicographically)...
 LIB_SRC=H5.c H5A.c H5AC.c H5B.c H5C.c H5D.c H5Dconv.c H5E.c H5F.c H5G.c       \
-        H5Gnode.c H5Gshad.c H5H.c H5M.c H5MF.c H5MM.c H5O.c H5Ocont.c 	      \
-        H5Oname.c H5Onull.c H5Osdtyp.c H5Osdim.c H5Ostab.c H5Ostdst.c H5P.c   \
-        H5T.c
+        H5Gent.c H5Gnode.c H5Gshad.c H5Gstab.c H5H.c H5M.c H5MF.c H5MM.c      \
+        H5O.c H5Ocont.c H5Oname.c H5Onull.c H5Osdtyp.c H5Osdim.c H5Ostab.c    \
+        H5Ostdst.c H5P.c H5T.c
 
 LIB_OBJ=$(LIB_SRC:.c=.o)