diff options
Diffstat (limited to 'src/H5G.c')
| -rw-r--r-- | src/H5G.c | 1143 |
1 files changed, 583 insertions, 560 deletions
@@ -28,15 +28,13 @@ * Robb Matzke, 30 Aug 1997 * Added `Errors:' field to function prologues. * - * Robb Matzke, 18 Sep 1997 - * Added shadow entry support. - * *------------------------------------------------------------------------- */ #define H5G_PACKAGE /*suppress error message about including H5Gpkg.h*/ /* Packages needed by this file... */ #include <H5private.h> +#include <H5Aprivate.h> #include <H5Bprivate.h> #include <H5Eprivate.h> #include <H5Gpkg.h> @@ -45,37 +43,38 @@ #include <H5Oprivate.h> #define H5G_INIT_HEAP 8192 +#define H5G_RESERVED_ATOMS 0 #define PABLO_MASK H5G_mask /* Interface initialization */ static hbool_t interface_initialize_g = FALSE; -#define INTERFACE_INIT NULL +#define INTERFACE_INIT H5G_init_interface +static herr_t H5G_init_interface (void); +static void H5G_term_interface (void); + +static H5G_entry_t *H5G_getcwg (H5F_t *f); /*------------------------------------------------------------------------- - * Function: H5Gnew + * Function: H5Gcreate * * Purpose: Creates a new group in FILE and gives it the specified * NAME. Unless NAME begins with `/' it is relative to the - * current working group. + * current working group. The group is opened for write access + * and it's object ID is returned. * * The optional SIZE_HINT specifies how much file space to * reserve to store the names that will appear in this - * group (an even number of characters, counting the null - * terminator, is allocated for each name). If a non-positive - * value is supplied for the SIZE_HINT then a default size is - * chosen. + * group. If a non-positive value is supplied for the SIZE_HINT + * then a default size is chosen. * * See also: H5Gset(), H5Gpush(), H5Gpop() * * Errors: - * ARGS BADTYPE Not a file atom. - * ARGS BADVALUE No name given. - * ATOM BADATOM Can't unatomize file. - * SYM CANTINIT Can't close handle. - * SYM CANTINIT Can't create group. * - * Return: Success: SUCCEED + * Return: Success: The object ID of a new, empty group open for + * writing. Call H5Gclose() when finished with + * the group. * * Failure: FAIL * @@ -86,47 +85,139 @@ static hbool_t interface_initialize_g = FALSE; * *------------------------------------------------------------------------- */ -herr_t -H5Gnew (hid_t file, const char *name, size_t size_hint) +hid_t +H5Gcreate (hid_t file_id, const char *name, size_t size_hint) { - H5F_t *f=NULL; - H5G_entry_t *grp_handle=NULL; + H5F_t *f = NULL; + H5G_t *grp; + hid_t ret_value = FAIL; - FUNC_ENTER (H5Gnew, FAIL); + FUNC_ENTER (H5Gcreate, FAIL); + H5ECLEAR; - /* Check/fix arguments */ + /* Check arguments */ + if (H5_FILE!=H5Aatom_group (file_id) || + NULL==(f=H5Aatom_object (file_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + } if (!name || !*name) { HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given"); } - if (H5_FILE!=H5Aatom_group (file)) { - HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom"); + + /* Create the group */ + if (NULL==(grp=H5G_create (f, name, size_hint))) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group"); } - if (NULL==(f=H5Aatom_object (file))) { - HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file"); + + if ((ret_value = H5Aregister_atom (H5_GROUP, grp))<0) { + H5G_close (grp); + HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, + "unable to register group"); } + + FUNC_LEAVE (ret_value); +} + + +/*------------------------------------------------------------------------- + * Function: H5Gopen + * + * Purpose: Opens an existing group for modification. When finished, + * call H5Gclose() to close it and release resources. + * + * Errors: + * + * Return: Success: Object ID of the group. + * + * Failure: FAIL + * + * Programmer: Robb Matzke + * Wednesday, December 31, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +hid_t +H5Gopen (hid_t file_id, const char *name) +{ + hid_t ret_value = FAIL; + H5F_t *f = NULL; + H5G_t *grp = NULL; - /* Create the group */ - if (NULL==(grp_handle=H5G_new (f, name, size_hint))) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, - "can't create group"); + FUNC_ENTER (H5Gopen, FAIL); + H5ECLEAR; + + /* Check args */ + if (H5_FILE!=H5Aatom_group (file_id) || + NULL==(f=H5Aatom_object (file_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + } + if (!name || !*name) { + HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name"); } - /* Close the group handle */ - if (H5G_close (f, grp_handle)<0) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't close handle"); + /* Open the group */ + if (NULL==(grp=H5G_open (f, name))) { + HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group"); } - FUNC_LEAVE (SUCCEED); + /* Register an atom for the group */ + if ((ret_value=H5Aregister_atom (H5_GROUP, grp))<0) { + H5G_close (grp); + HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, + "unable to register group"); + } + + FUNC_LEAVE (ret_value); } + +/*------------------------------------------------------------------------- + * Function: H5Gclose + * + * Purpose: Closes the specified group. The group ID will no longer be + * valid for accessing the group. + * + * Return: Success: SUCCEED + * + * Failure: FAIL + * + * Programmer: Robb Matzke + * Wednesday, December 31, 1997 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +herr_t +H5Gclose (hid_t grp_id) +{ + H5G_t *grp = NULL; + + FUNC_ENTER (H5Gclose, FAIL); + H5ECLEAR; + + /* Check args */ + if (H5_GROUP!=H5Aatom_group (grp_id) || + NULL==(grp=H5Aatom_object (grp_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a group"); + } + + /* close it */ + if (H5G_close (grp)<0) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group"); + } + + FUNC_LEAVE (SUCCEED); +} /*------------------------------------------------------------------------- * Function: H5Gset * * Purpose: Sets the working group for file handle FILE to the - * specified NAME. Unless NAME begins with a `/' it is - * interpretted relative to the current working group. + * specified group. * * Each file handle maintains its own notion of the current * working group. That is, if a single file is opened with @@ -137,10 +228,6 @@ H5Gnew (hid_t file, const char *name, size_t size_hint) * See also: H5Gpush(), H5Gpop() * * Errors: - * ARGS BADTYPE Not a file atom. - * ARGS BADVALUE No name given. - * ATOM BADATOM Can't unatomize file. - * SYM CANTINIT Can't change current working group. * * Return: Success: SUCCEED * @@ -154,32 +241,33 @@ H5Gnew (hid_t file, const char *name, size_t size_hint) *------------------------------------------------------------------------- */ herr_t -H5Gset (hid_t file, const char *name) +H5Gset (hid_t file_id, hid_t grp_id) { H5F_t *f=NULL; + H5G_t *grp; FUNC_ENTER (H5Gset, FAIL); + H5ECLEAR; /* Check/fix arguments */ - if (!name || !*name) { - HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given"); - } - if (H5_FILE!=H5Aatom_group (file)) { - HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom"); + if (H5_FILE!=H5Aatom_group (file_id) || + NULL==(f=H5Aatom_object (file_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); } - if (NULL==(f=H5Aatom_object (file))) { - HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file"); + if (H5_GROUP!=H5Aatom_group (grp_id) || + NULL==(grp=H5Aatom_object (grp_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a group"); } - if (H5G_set (f, name)<0) { + /* Set the current working group */ + if (H5G_set (f, grp)<0) { HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, - "can't change current working group"); + "unable to change current working group"); } FUNC_LEAVE (SUCCEED); } - /*------------------------------------------------------------------------- * Function: H5Gpush @@ -196,10 +284,6 @@ H5Gset (hid_t file, const char *name) * See also: H5Gset(), H5Gpop() * * Errors: - * ARGS BADTYPE Not a file atom. - * ARGS BADVALUE No name given. - * ATOM BADATOM Can't unatomize file. - * SYM CANTINIT Can't change current working group. * * Return: Success: SUCCEED * @@ -213,24 +297,26 @@ H5Gset (hid_t file, const char *name) *------------------------------------------------------------------------- */ herr_t -H5Gpush (hid_t file, const char *name) +H5Gpush (hid_t file_id, hid_t grp_id) { H5F_t *f=NULL; + H5G_t *grp; FUNC_ENTER (H5Gpush, FAIL); + H5ECLEAR; - /* Check/fix arguments */ - if (!name || !*name) { - HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given"); + /* Check arguments */ + if (H5_FILE!=H5Aatom_group (file_id) || + NULL==(f=H5Aatom_object (file_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); } - if (H5_FILE!=H5Aatom_group (file)) { - HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom"); + if (H5_GROUP!=H5Aatom_group (grp_id) || + NULL==(grp=H5Aatom_object (grp_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a group"); } - if (NULL==(f=H5Aatom_object (file))) { - HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file"); - } - - if (H5G_push (f, name)<0) { + + /* Push group onto stack */ + if (H5G_push (f, grp)<0) { HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't change current working group"); } @@ -238,7 +324,6 @@ H5Gpush (hid_t file, const char *name) FUNC_LEAVE (SUCCEED); } - /*------------------------------------------------------------------------- * Function: H5Gpop @@ -255,9 +340,6 @@ H5Gpush (hid_t file, const char *name) * See also: H5Gset(), H5Gpush() * * Errors: - * ARGS BADTYPE Not a file atom. - * ATOM BADATOM Can't unatomize file. - * SYM CANTINIT Stack is empty. * * Return: Success: SUCCEED * @@ -273,20 +355,20 @@ H5Gpush (hid_t file, const char *name) *------------------------------------------------------------------------- */ herr_t -H5Gpop (hid_t file) +H5Gpop (hid_t file_id) { H5F_t *f=NULL; FUNC_ENTER (H5Gpop, FAIL); - - /* Check/fix arguments */ - if (H5_FILE!=H5Aatom_group (file)) { - HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom"); - } - if (NULL==(f=H5Aatom_object (file))) { - HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file"); + H5ECLEAR; + + /* Check arguments */ + if (H5_FILE!=H5Aatom_group (file_id) || + NULL==(f=H5Aatom_object (file_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); } + /* pop */ if (H5G_pop (f)<0) { HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "stack is empty"); @@ -307,9 +389,59 @@ H5Gpop (hid_t file) */ + +/*------------------------------------------------------------------------- + * Function: H5G_init_interface + * + * Purpose: Initializes the H5G interface. + * + * Return: Success: SUCCEED + * + * Failure: FAIL + * + * Programmer: Robb Matzke + * Monday, January 5, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +H5G_init_interface (void) +{ + FUNC_ENTER (H5G_init_interface, FAIL); + /* Initialize the atom group for the group IDs */ + if (H5Ainit_group (H5_GROUP, H5A_GROUPID_HASHSIZE, H5G_RESERVED_ATOMS, + (herr_t (*)(void*))H5G_close)<0 || + H5_add_exit (H5G_term_interface)<0) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, + "unable to initialize interface"); + } + + FUNC_LEAVE (SUCCEED); +} - + +/*------------------------------------------------------------------------- + * Function: H5G_term_interface + * + * Purpose: Terminates the H5G interface + * + * Return: void + * + * Programmer: Robb Matzke + * Monday, January 5, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static void +H5G_term_interface (void) +{ + H5Adestroy_group (H5_GROUP); +} /*------------------------------------------------------------------------- @@ -348,57 +480,58 @@ H5G_component (const char *name, size_t *size_p) /*------------------------------------------------------------------------- * Function: H5G_namei * - * Purpose: (Partially) translates a name to a symbol table entry. - * - * Given a name (absolute or relative) return the symbol table - * entry for that name and for the group that contains the - * base name. These entries (GRP_ENT and BASE_ENT) are returned - * through memory passed into the function by the caller. Either - * or both pointers may be null. Absolute names are looked up - * relative to the root group of file F while relative - * names are traversed beginning at the CWG argument. - * - * Consecutive slash characters are treated like single - * slash characters. Trailing slashes are ignored. The - * component `.' is recognized as the current group - * during the traversal (initially CWG), but the component - * `..' is not internally recognized (it is recognized if - * such a name appears in the symbol table). - * - * If the name cannot be fully resolved, then REST will - * point to the part of NAME where the traversal failed - * (REST will always point to a relative name) and this - * function will return null. GRP_ENT will be initialized with - * information about the group (or other object) at which - * the traversal failed. However, if the name can be fully - * resolved, then REST points to the null terminator of NAME. - * - * As a special case, if the NAME is the name `/' (or - * equivalent) then GRP_ENT is initialized to all zero - * and an invalid header address and a pointer to the root - * symbol table entry is returned. - * - * As a special case, if the NAME is the string `/foo' (or - * equivalent) and the root symbol table entry points to a - * non-group object with a name message with the value - * `foo' then GRP_ENT is initialized to all zero (except for an - * invalid header address) and a pointer to the root symbol - * table entry is returned. - * + * Purpose: Translates a name to a symbol table entry. + * + * If the specified name can be fully resolved, then this + * function returns the symbol table entry for the named object + * through the OBJ_ENT argument. The symbol table entry for the + * group containing the named object is returned through the + * GRP_ENT argument if it is non-null. However, if the name + * refers to the root object then the GRP_ENT will be + * initialized with an undefined object header address. The + * REST argument, if present, will point to the null terminator + * of NAME. + * + * If the specified name cannot be fully resolved, then OBJ_ENT + * is initialized with the undefined object header address. The + * REST argument will point into the NAME argument to the start + * of the component that could not be located. The GRP_ENT will + * contain the entry for the symbol table that was being + * searched at the time of the failure and will have an + * undefined object header address if the search failed at the + * root object. For instance, if NAME is `/foo/bar/baz' and the + * root directory exists and contains an entry for `foo', and + * foo is a group that contains an entry for baz, but baz is not + * a group, then the results will be that REST points to `baz', + * GRP_ENT has an undefined object header address, and GRP_ENT + * is the symbol table entry for `bar' in `/foo'. + * + * If a file contains more than one object, then `/' is the name + * of the root object which is a group. Otherwise, a file can + * consist of a single object, not necessarily a group, whose + * name is `/foo' where `foo' is the value of the name messsage + * in the object header. A file can also contain no objects in + * which case the function returns so REST points to the + * beginning of NAME and OBJ_ENT and GRP_ENT contain undefined + * header addresses. + * + * Components of a name are separated from one another by one or + * more slashes (/). Slashes at the end of a name are ignored. + * If the name begins with a slash then the search begins at the + * root object, otherwise it begins at the group CWG, otherwise + * it begins at the current working group of file F. The + * component `.' is a no-op, but `..' is not understood by this + * function (unless it appears as an entry in the symbol table). + * * Errors: - * SYM COMPLEN Component is too long. - * SYM NOTFOUND Component not found. - * SYM NOTFOUND No root group. - * SYM NOTFOUND Root not found. * - * Return: Success: Pointer to a cached symbol table entry if the - * name can be fully resolved. The pointer is - * valid until one of the H5AC (cache) functions - * is called. + * Return: Success: SUCCEED if name can be fully resolved. See + * above for values of REST, GRP_ENT, and + * OBJ_ENT. * - * Failure: Null if the name could not be fully resolved. - * REST and GRP_ENT are initialized (possibly to - * zero if the failure occurred soon enough). + * Failure: FAIL if the name could not be fully resolved. + * See above for values of REST, GRP_ENT, and + * OBJ_ENT. * * Programmer: Robb Matzke * matzke@llnl.gov @@ -408,46 +541,52 @@ H5G_component (const char *name, size_t *size_p) * *------------------------------------------------------------------------- */ -static H5G_entry_t * +static herr_t H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name, - const char **rest/*out*/, H5G_entry_t *grp_ent/*out*/) + const char **rest/*out*/, H5G_entry_t *grp_ent/*out*/, + H5G_entry_t *obj_ent/*out*/) { - H5G_entry_t grp; /*entry for current group */ + H5G_entry_t _grp_ent; /*entry for current group */ + H5G_entry_t _obj_ent; /*entry found */ size_t nchars; /*component name length */ char comp[1024]; /*component name buffer */ hbool_t aside = FALSE; /*did we look at a name message?*/ - H5G_entry_t *ret_value=NULL; /*return value */ /* clear output args before FUNC_ENTER() in case it fails */ if (rest) *rest = name; - if (grp_ent) { - memset (grp_ent, 0, sizeof(H5G_entry_t)); - H5F_addr_undef (&(grp_ent->header)); - } + if (!grp_ent) grp_ent = &_grp_ent; + if (!obj_ent) obj_ent = &_obj_ent; + memset (grp_ent, 0, sizeof(H5G_entry_t)); + H5F_addr_undef (&(grp_ent->header)); + memset (obj_ent, 0, sizeof(H5G_entry_t)); + H5F_addr_undef (&(obj_ent->header)); - FUNC_ENTER (H5G_namei, NULL); + FUNC_ENTER (H5G_namei, FAIL); /* check args */ assert (f); - assert (f->shared->root_sym); assert (name && *name); - assert (cwg || '/'==*name); + /* If the file contains no objects then return failure */ + if (!f->shared->root_ent) { + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no root group"); + } + /* starting point */ if ('/'==*name) { - if (!H5F_addr_defined (&(f->shared->root_sym->header))) { - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, - "no root group"); - } - ret_value = f->shared->root_sym; - grp = *(f->shared->root_sym); + *obj_ent = *(f->shared->root_ent); + } else if (cwg) { + *obj_ent = *cwg; + } else if ((cwg=H5G_getcwg (f))) { + *obj_ent = *cwg; } else { - ret_value = cwg; - grp = *cwg; + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no current working group"); } + assert (H5F_addr_defined (&(obj_ent->header))); /* traverse the name */ while ((name=H5G_component (name, &nchars)) && *name) { + if (rest) *rest = name; /* * The special name `.' is a no-op. @@ -457,67 +596,51 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name, /* * Advance to the next component of the name. */ - grp = *ret_value; - ret_value = NULL; - if (rest) *rest = name; + *grp_ent = *obj_ent; + HDmemset (obj_ent, 0, sizeof(H5G_entry_t)); + H5F_addr_undef (&(obj_ent->header)); /* * Copy the component name into a null-terminated buffer so * we can pass it down to the other symbol table functions. */ if (nchars+1 > sizeof(comp)) { - if (grp_ent) *grp_ent = grp; - HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, "component is too long"); + HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, FAIL, "component is too long"); } HDmemcpy (comp, name, nchars); comp[nchars] = '\0'; - if (NULL==(ret_value=H5G_stab_find (f, NO_ADDR, &grp, comp))) { + if (H5G_stab_find (f, grp_ent, comp, obj_ent/*out*/)<0) { /* * Component was not found in the current symbol table, possibly - * because GRP isn't a symbol table. If it is the root symbol then - * see if it has the appropriate name field. The ASIDE variable - * prevents us from saying `/foo/foo' where the root object has - * the name `foo'. + * because GRP_ENT isn't a symbol table. If it is the root symbol + * then see if it has the appropriate name field. The ASIDE + * variable prevents us from saying `/foo/foo' where the root object + * has the name `foo'. */ H5O_name_t mesg={0}; if (!aside && - H5F_addr_defined (&(grp.header)) && - H5F_addr_defined (&(f->shared->root_sym->header)) && - H5F_addr_eq (&(grp.header), &(f->shared->root_sym->header)) && - H5O_read (f, &(grp.header), &grp, H5O_NAME, 0, &mesg) && + H5F_addr_eq (&(grp_ent->header), + &(f->shared->root_ent->header)) && + H5O_read (f, grp_ent, H5O_NAME, 0, &mesg) && !HDstrcmp (mesg.s, comp)) { H5O_reset (H5O_NAME, &mesg); - ret_value = f->shared->root_sym; + *obj_ent = *grp_ent; + HDmemset (grp_ent, 0, sizeof(H5G_entry_t)); + H5F_addr_undef (&(grp_ent->header)); aside = TRUE; } else { H5O_reset (H5O_NAME, &mesg); - if (grp_ent) *grp_ent = grp; - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "component not found"); + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "component not found"); } } /* next component */ name += nchars; } - - /* output parameters */ if (rest) *rest = name; /*final null*/ - if (grp_ent) { - if (H5F_addr_eq (&(ret_value->header), &(f->shared->root_sym->header))) { - HDmemset (grp_ent, 0, sizeof(H5G_entry_t)); /*root has no parent*/ - H5F_addr_undef (&(grp_ent->header)); - } else { - *grp_ent = grp; - } - } - /* Perhaps the root object doesn't even exist! */ - if (!H5F_addr_defined (&(ret_value->header))) { - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "root not found"); - } - - FUNC_LEAVE (ret_value); + FUNC_LEAVE (SUCCEED); } @@ -532,16 +655,8 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, 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: - * SYM CANTINIT Can't open root object. - * SYM CANTINIT Can't reinsert old root object. - * SYM CANTINIT Cant create root. - * SYM EXISTS Root group already exists. - * SYM LINK Bad link count on old root object. - * SYM LINK Cant create root. - * + * * Return: Success: SUCCEED * * Failure: FAIL. This function returns -2 if the @@ -559,71 +674,50 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name, static herr_t H5G_mkroot (H5F_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 */ - H5G_entry_t *ent_ptr=NULL; /*pointer to a symbol table entry*/ + H5G_entry_t new_root; /*new root object */ const char *obj_name=NULL; /*name of old root object */ FUNC_ENTER (H5G_mkroot, FAIL); + /* check args */ + assert (f); + /* - * Make sure that the file descriptor has the latest info -- someone might - * have the root object open. - */ - H5G_shadow_sync (f->shared->root_sym); - - /* - * If we already have a root object, then open it and get it's name. The - * root object had better not already be a group. 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 group directed graph. We might leak file - * memory, but at least we don't loose the original root object. + * If we already have a root object, then get it's name. */ - if (H5F_addr_defined (&(f->shared->root_sym->header))) { - if (H5O_read (f, NO_ADDR, f->shared->root_sym, H5O_STAB, 0, &stab)) { - HGOTO_ERROR (H5E_SYM, H5E_EXISTS, -2, - "root group already exists"); - } else if (NULL==(handle=H5G_shadow_open (f, NULL, - f->shared->root_sym))) { - HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, - "can't open root object"); - } else if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &name)) { + if (f->shared->root_ent) { + if (H5O_read (f, f->shared->root_ent, H5O_STAB, 0, &stab)) { + HGOTO_ERROR (H5E_SYM, H5E_EXISTS, -2, "root group already exists"); + } else if (NULL==H5O_read (f, f->shared->root_ent, H5O_NAME, 0, &name)) { obj_name = "Root Object"; } else { obj_name = name.s; /*don't reset message until the end!*/ } - handle->dirty = TRUE; } /* - * Create the new root group 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. + * Create the new root group. Set the link count to 1. */ - if (H5G_stab_create (f, f->shared->root_sym, size_hint)<0) { + if (H5G_stab_create (f, size_hint, &new_root/*out*/)<0) { HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "cant create root"); } - if (1!=H5O_link (f, f->shared->root_sym, 1)) { + if (1!=H5O_link (f, &new_root, 1)) { HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL, "internal error (wrong link count)"); } /* * 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. + * symbol table with the specified name. Then make the root object the + * new symbol table. */ - if (obj_name) { - if (1!=H5O_link (f, handle, 0)) { - HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL, - "bad link count on old root object"); - } - if (NULL==(ent_ptr=H5G_stab_insert (f, f->shared->root_sym, obj_name, - handle))) { + if (f->shared->root_ent) { + assert (1==H5O_link (f, f->shared->root_ent, 0)); + + if (H5G_stab_insert (f, &new_root, obj_name, f->shared->root_ent)<0) { HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't reinsert old root object"); } @@ -633,33 +727,31 @@ H5G_mkroot (H5F_t *f, size_t size_hint) * 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); + H5O_remove (f, f->shared->root_ent, H5O_NAME, H5O_ALL); H5ECLEAR; /*who really cares?*/ + + *(f->shared->root_ent) = new_root; + + } else { + f->shared->root_ent = H5MM_xmalloc (sizeof(H5G_entry_t)); + *(f->shared->root_ent) = new_root; } - + + H5O_close (f, &new_root); ret_value = SUCCEED; done: - /* - * If the handle is closed before the H5G_stab_insert() call that - * reinserts the root object into the group directed graph, then - * H5G_close() will reset f->root_sym to point to the old root symbol and - * the new root group (if it was created) will be unlinked from the - * group directed graph (and memory leaked). - */ - if (handle) H5G_close (f, handle); H5O_reset (H5O_NAME, &name); - FUNC_LEAVE (ret_value); } /*------------------------------------------------------------------------- - * Function: H5G_new + * Function: H5G_create * - * Purpose: Creates a new empty group with the specified name, - * opening it as an object. The name is either an absolute name - * or is relative to the current working group. + * Purpose: Creates a new empty group with the specified name. The name + * is either an absolute name or is relative to the current + * working group. * * A root group is created implicitly by this function * when necessary. Calling this function with the name "/" @@ -667,16 +759,10 @@ H5G_mkroot (H5F_t *f, size_t size_hint) * failure. * * Errors: - * SYM CANTINIT Can't create grp. - * SYM CANTINIT Can't create root group. - * SYM CANTINIT Can't insert. - * SYM CANTINIT Can't open. - * SYM COMPLEN Component is too long. - * SYM EXISTS Already exists. - * SYM NOTFOUND Missing component. * - * Return: Success: A handle to the open group. Please call - * H5G_close() when you're done with it. + * Return: Success: A handle for the group. The group is opened + * and should eventually be close by calling + * H5G_close(). * * Failure: NULL * @@ -688,57 +774,46 @@ H5G_mkroot (H5F_t *f, size_t size_hint) * *------------------------------------------------------------------------- */ -H5G_entry_t * -H5G_new (H5F_t *f, const char *name, size_t size_hint) +H5G_t * +H5G_create (H5F_t *f, const char *name, size_t size_hint) { const char *rest=NULL; /*the base name */ - H5G_entry_t *cwg=NULL; /*current working group */ H5G_entry_t grp_ent; /*group containing new group */ - H5G_entry_t ent; /*new group entry */ - H5G_entry_t *ent_ptr=NULL; /*ptr to new group 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 */ + H5G_t *grp = NULL; /*new group */ - FUNC_ENTER (H5G_new, NULL); + FUNC_ENTER (H5G_create, NULL); /* check args */ assert (f); assert (name && *name); -#ifndef LATER - /* Get current working group */ - H5G_shadow_sync (f->shared->root_sym); - cwg = f->shared->root_sym; -#endif - assert (cwg || '/'==*name); /* * Try to create the root group. Ignore the error if this function * fails because the root group already exists. */ if ((status=H5G_mkroot (f, H5G_SIZE_HINT))<0 && -2!=status) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, - "can't create root group"); + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't create root group"); } H5ECLEAR; /* lookup name */ - if (H5G_namei (f, cwg, name, &rest, &grp_ent)) { + if (0==H5G_namei (f, NULL, name, &rest, &grp_ent, NULL)) { HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "already exists"); } H5ECLEAR; /*it's OK that we didn't find it*/ + assert (H5F_addr_defined (&(grp_ent.header))); /* should be one null-terminated component left */ rest = H5G_component (rest, &nchars); assert (rest && *rest); if (rest[nchars]) { if (H5G_component (rest+nchars, NULL)) { - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, - "missing component"); + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "missing component"); } else if (nchars+1 > sizeof _comp) { - HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, - "component is too long"); + HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, "component is too long"); } else { /* null terminate */ HDmemcpy (_comp, rest, nchars); @@ -747,35 +822,154 @@ H5G_new (H5F_t *f, const char *name, size_t size_hint) } } - /* create group */ - if (H5G_stab_create (f, &ent, size_hint)<0) { + /* create and open group */ + grp = H5MM_xcalloc (1, sizeof(H5G_t)); + grp->file = f; + if (H5G_stab_create (f, size_hint, &(grp->ent)/*out*/)<0) { + grp = H5MM_xfree (grp); HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't create grp"); } /* insert child name into parent */ - if (NULL==(ent_ptr=H5G_stab_insert (f, &grp_ent, rest, &ent))) { + if (H5G_stab_insert (f, &grp_ent, rest, &(grp->ent))<0) { + H5O_close (f, &(grp->ent)); + grp = H5MM_xfree (grp); HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't insert"); } - /* open the group */ - if (NULL==(ret_value=H5G_shadow_open (f, &grp_ent, ent_ptr))) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't open"); + grp->nref = 1; + FUNC_LEAVE (grp); +} + + +/*------------------------------------------------------------------------- + * Function: H5G_open + * + * Purpose: Opens an existing group. The group should eventually be + * closed by calling H5G_close(). + * + * Return: Success: Ptr to a new group. + * + * Failure: NULL + * + * Programmer: Robb Matzke + * Monday, January 5, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +H5G_t * +H5G_open (H5F_t *f, const char *name) +{ + H5G_t *grp = NULL; + H5G_t *ret_value = NULL; + + FUNC_ENTER (H5G_open, NULL); + + /* Check args */ + assert (f); + assert (name && *name); + + /* Open the group */ + grp = H5MM_xcalloc (1, sizeof(H5G_t)); + if (H5G_find (f, name, NULL, &(grp->ent))<0) { + HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "group not found"); + } + if (H5O_open (f, &(grp->ent))<0) { + HGOTO_ERROR (H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to open group"); + } + grp->file = f; + grp->nref = 1; + ret_value = grp; + + done: + if (!ret_value && grp) { + H5MM_xfree (grp); } FUNC_LEAVE (ret_value); } + +/*------------------------------------------------------------------------- + * Function: H5G_reopen + * + * Purpose: Reopens a group by incrementing the open count. + * + * Return: Success: The GRP argument. + * + * Failure: NULL + * + * Programmer: Robb Matzke + * Monday, January 5, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +H5G_t * +H5G_reopen (H5G_t *grp) +{ + FUNC_ENTER (H5G_reopen, NULL); + + assert (grp); + assert (grp->nref>0); + + grp->nref++; + + FUNC_LEAVE (grp); +} + + +/*------------------------------------------------------------------------- + * Function: H5G_close + * + * Purpose: Closes the specified group. + * + * Return: Success: SUCCEED + * + * Failure: FAIL + * + * Programmer: Robb Matzke + * Monday, January 5, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +herr_t +H5G_close (H5G_t *grp) +{ + FUNC_ENTER (H5G_close, FAIL); + + /* Check args */ + assert (grp); + assert (grp->nref>0); + + if (1==grp->nref) { + if (H5O_close (grp->file, &(grp->ent))<0) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close"); + } + } + --grp->nref; + + FUNC_LEAVE (SUCCEED); +} /*------------------------------------------------------------------------- * Function: H5G_set * - * Purpose: Sets the current working group to be the specified name. + * Purpose: Sets the current working group to be the specified group. * This affects only the top item on the group stack for the * specified file as accessed through this file handle. If the * file is opened multiple times, then the current working group * for this file handle is the only one that is changed. * + * Note: The group is re-opened and held open until it is removed from + * the current working group stack. + * * Errors: * SYM CWG Can't open group. * SYM CWG Couldn't close previous c.w.g. @@ -793,19 +987,20 @@ H5G_new (H5F_t *f, const char *name, size_t size_hint) *------------------------------------------------------------------------- */ herr_t -H5G_set (H5F_t *f, const char *name) +H5G_set (H5F_t *f, H5G_t *grp) { - H5G_entry_t *handle=NULL; - H5O_stab_t stab_mesg; - herr_t ret_value=FAIL; - FUNC_ENTER (H5G_set, FAIL); - if (NULL==(handle=H5G_open (f, name))) { - HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "can't open group"); - } - if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &stab_mesg)) { - HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "not a group"); + /* check args */ + assert (f); + assert (grp); + + /* + * Are the group and file compatible? + */ + if (grp->file->shared!=f->shared) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, + "group is not compatible with file"); } /* @@ -814,36 +1009,27 @@ H5G_set (H5F_t *f, const char *name) */ if (!f->cwg_stack) { f->cwg_stack = H5MM_xcalloc (1, sizeof(H5G_cwgstk_t)); - f->cwg_stack->handle = handle; - } else { - if (H5G_close (f, f->cwg_stack->handle)<0) { - HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, - "couldn't close previous c.w.g."); - } - f->cwg_stack->handle = handle; + } else if (H5G_close (f->cwg_stack->grp)<0) { + HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "couldn't close previous c.w.g."); } - ret_value = SUCCEED; + f->cwg_stack->grp = H5G_reopen (grp); - done: - if (ret_value<0 && handle) { - H5G_close (f, handle); - } - - FUNC_LEAVE (ret_value); + FUNC_LEAVE (SUCCEED); } - /*------------------------------------------------------------------------- * Function: H5G_getcwg * - * Purpose: Returns a handle for the current working group. If there - * is no current working group then a pointer to the root - * symbol is returned but that object is not opened (and it - * might not even be a group). + * Purpose: Returns a ptr to the symbol table entry for the current + * working group. If there is no current working group then a + * pointer to the root symbol is returned. If there is no root + * symbol then the null pointer is returned. * - * Return: Success: Ptr to open group handle with exceptions - * noted above. + * Return: Success: Ptr to the current working group or root + * object. The pointer is valid only until the + * root object changes or the current working + * group changes. * * Failure: NULL * @@ -857,26 +1043,29 @@ H5G_set (H5F_t *f, const char *name) static H5G_entry_t * H5G_getcwg (H5F_t *f) { - H5G_entry_t *handle=NULL; + H5G_entry_t *ret_value=NULL; FUNC_ENTER (H5G_getcwg, NULL); + + /* check args */ + assert (f); - if (f->cwg_stack && f->cwg_stack->handle) { - handle = f->cwg_stack->handle; + /* return a pointer directly into the stack */ + if (f->cwg_stack && f->cwg_stack->grp) { + ret_value = &(f->cwg_stack->grp->ent); } else { - H5G_shadow_sync (f->shared->root_sym); - handle = f->shared->root_sym; + ret_value = f->shared->root_ent; } - FUNC_LEAVE (handle); + FUNC_LEAVE (ret_value); } - /*------------------------------------------------------------------------- * Function: H5G_push * - * Purpose: Pushes a new current working group onto the stack. + * Purpose: Pushes a new current working group onto the stack. The GRP + * is reopened and held open until it is removed from the stack. * * Errors: * SYM CWG Can't open group. @@ -894,35 +1083,31 @@ H5G_getcwg (H5F_t *f) *------------------------------------------------------------------------- */ herr_t -H5G_push (H5F_t *f, const char *name) +H5G_push (H5F_t *f, H5G_t *grp) { - H5G_entry_t *handle=NULL; H5G_cwgstk_t *stack=NULL; - H5O_stab_t stab_mesg; - herr_t ret_value = FAIL; FUNC_ENTER (H5G_push, FAIL); - if (NULL==(handle=H5G_open (f, name))) { - HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "can't open group"); - } - if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &stab_mesg)) { - HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "not a group"); - } + /* check args */ + assert (f); + assert (grp); /* + * Are the group and file compatible? + */ + if (grp->file->shared!=f->shared) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, + "group is not compatible with file"); + } + + /* * Push a new entry onto the stack. */ stack = H5MM_xcalloc (1, sizeof(H5G_cwgstk_t)); - stack->handle = handle; + stack->grp = H5G_reopen (grp); stack->next = f->cwg_stack; f->cwg_stack = stack; - ret_value = SUCCEED; - - done: - if (ret_value<0 && handle) { - H5G_close (f, handle); - } FUNC_LEAVE (SUCCEED); } @@ -955,13 +1140,16 @@ H5G_pop (H5F_t *f) FUNC_ENTER (H5G_pop, FAIL); + /* check args */ + assert (f); + if ((stack=f->cwg_stack)) { - if (H5G_close (f, stack->handle)<0) { + if (H5G_close (stack->grp)<0) { HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "can't close current working group"); } f->cwg_stack = stack->next; - stack->handle = NULL; + stack->grp = NULL; H5MM_xfree (stack); } else { HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "stack is empty"); @@ -972,30 +1160,13 @@ H5G_pop (H5F_t *f) /*------------------------------------------------------------------------- - * Function: H5G_create + * Function: H5G_insert * - * 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. + * Purpose: Inserts a symbol table entry into the group graph. * * Errors: - * SYM CANTINIT Bad link count. - * SYM CANTINIT Can't create header. - * SYM CANTINIT Can't create root group. - * SYM CANTINIT Can't insert. - * SYM CANTINIT Can't open object. - * SYM CANTINIT Cannot add/change name message. - * SYM CANTINIT Create the object header. - * SYM COMPLEN Component is too long. - * SYM EXISTS Already exists. - * SYM EXISTS Root exists. - * SYM LINK Bad link count. - * SYM LINK Link inc failure. - * SYM NOTFOUND Component not found. - * - * Return: Success: A handle for the object. Be sure to - * eventually close it. + * + * Return: Success: SUCCEED * * Failure: FAIL * @@ -1006,35 +1177,28 @@ H5G_pop (H5F_t *f) * *------------------------------------------------------------------------- */ -H5G_entry_t * -H5G_create (H5F_t *f, const char *name, size_t ohdr_hint) +herr_t +H5G_insert (H5F_t *f, const char *name, H5G_entry_t *ent) { - H5G_entry_t ent; /*entry data for the new object */ - H5G_entry_t *ent_ptr; /*ptr into symbol node for entry*/ - H5G_entry_t *cwg=NULL; /*ptr to c.w.g. handle */ const char *rest = NULL; /*part of name not existing yet */ H5G_entry_t grp; /*entry for group 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 */ + hbool_t update_grp; + herr_t status; - FUNC_ENTER (H5G_create, NULL); + FUNC_ENTER (H5G_insert, FAIL); /* Check args. */ assert (f); assert (name && *name); - HDmemset (&ent, 0, sizeof(H5G_entry_t)); - - /* - * Get the current working group. - */ - cwg = H5G_getcwg (f); + assert (ent); /* * Look up the name -- it shouldn't exist yet. */ - if (H5G_namei (f, cwg, name, &rest, &grp)) { - HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "already exists"); + if (H5G_namei (f, NULL, name, &rest, &grp, NULL)>=0) { + HRETURN_ERROR (H5E_SYM, H5E_EXISTS, FAIL, "already exists"); } H5ECLEAR; /*it's OK that we didn't find it*/ rest = H5G_component (rest, &nchars); @@ -1045,22 +1209,16 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint) * doesn't have a name or we shouldn't interfere with the name * it already has as a message. */ - if (H5F_addr_defined (&(f->shared->root_sym->header))) { - HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "root exists"); + if (f->shared->root_ent) { + HRETURN_ERROR (H5E_SYM, H5E_EXISTS, FAIL, "root exists"); } - if (H5O_create (f, 0, ohdr_hint, &(ent.header)/*out*/)<0) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, - "can't create header"); + if (1!=H5O_link (f, ent, 1)) { + HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "bad link count"); } - if (1!=H5O_link (f, &ent, 1)) { - HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "bad link count"); - } - *(f->shared->root_sym) = ent; - if (NULL==(ret_value=H5G_shadow_open (f, NULL, f->shared->root_sym))) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, - "can't open root object"); - } - HRETURN (ret_value); + f->shared->root_ent = H5MM_xmalloc (sizeof(H5G_entry_t)); + ent->name_off = 0; + *(f->shared->root_ent) = *ent; + HRETURN (SUCCEED); } /* @@ -1069,11 +1227,9 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint) */ if (rest[nchars]) { if (H5G_component (rest+nchars, NULL)) { - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, - "component not found"); + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "component not found"); } else if (nchars+1 > sizeof _comp) { - HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, - "component is too long"); + HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, FAIL, "component is too long"); } else { /* null terminate */ HDmemcpy (_comp, rest, nchars); @@ -1082,166 +1238,50 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint) } } - /* - * Create the object header. - */ - if (H5O_create (f, 0, ohdr_hint, &(ent.header)/*out*/)<0) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, - "can't create object header"); - } - - - if (!H5F_addr_defined (&(f->shared->root_sym->header))) { + if (!f->shared->root_ent) { /* * 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. + * the first one we find). */ H5O_name_t name_mesg; name_mesg.s = rest; - if (H5O_modify (f, NO_ADDR, &ent, H5O_NAME, 0, &name_mesg)<0) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, + if (H5O_modify (f, ent, H5O_NAME, 0, &name_mesg)<0) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "cannot add/change name message"); } - if (1!=H5O_link (f, &ent, 1)) { - HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "bad link count"); - } - *(f->shared->root_sym) = ent; - if (NULL==(ret_value=H5G_shadow_open (f, &grp, f->shared->root_sym))) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, - "can't open root object"); + if (1!=H5O_link (f, ent, 1)) { + HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "bad link count"); } - HRETURN (ret_value); - } else { - /* - * Make sure the root group exists. Ignore the failure if it's - * because the group already exists. - */ - hbool_t update_grp = H5F_addr_eq (&(grp.header), - &(f->shared->root_sym->header)); - herr_t status = H5G_mkroot (f, H5G_SIZE_HINT); - if (status<0 && -2!=status) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, - "can't create root group"); - } - H5ECLEAR; - if (update_grp) grp = *(f->shared->root_sym); + f->shared->root_ent = H5MM_xmalloc (sizeof(H5G_entry_t)); + *(f->shared->root_ent) = *ent; + HRETURN (SUCCEED); } - + /* - * This is the normal case. The object is just being inserted as a normal - * entry into a symbol table. + * Make sure the root group exists. Ignore the failure if it's + * because the group already exists. */ - if (H5O_link (f, &ent, 1)<0) { - HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "link inc failure"); - } - if (NULL==(ent_ptr=H5G_stab_insert (f, &grp, rest, &ent))) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't insert"); - } - if (NULL==(ret_value=H5G_shadow_open (f, &grp, ent_ptr))) { - HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't open object"); + update_grp = H5F_addr_eq (&(grp.header), + &(f->shared->root_ent->header)); + if ((status=H5G_mkroot (f, H5G_SIZE_HINT))<0 && -2!=status) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create root group"); } - FUNC_LEAVE (ret_value); -} + H5ECLEAR; + if (update_grp) grp = *(f->shared->root_ent); - -/*------------------------------------------------------------------------- - * 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(). - * - * Errors: - * SYM BADVALUE Check args. - * SYM CANTOPENOBJ Can't open obj. - * SYM NOTFOUND Object not found. - * - * Return: Success: Ptr to a handle for the object. - * - * Failure: NULL - * - * Programmer: Robb Matzke - * Wednesday, September 17, 1997 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -H5G_entry_t * -H5G_open (H5F_t *f, const char *name) -{ - H5G_entry_t *ent=NULL; - H5G_entry_t *ret_value=NULL; - H5G_entry_t grp; - H5G_entry_t *cwg=NULL; - FUNC_ENTER (H5G_open, NULL); - - /* check args */ - assert (f); - if (!name || !*name) { - HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, NULL, "no name"); - } - - /* Get CWG */ - cwg = H5G_getcwg (f); - assert (cwg || '/'==*name); - - if (!H5F_addr_defined (&(f->shared->root_sym->header))) { - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "object not found"); - } - if (NULL==(ent=H5G_namei (f, cwg, name, NULL, &grp))) { - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "object not found"); + /* + * This is the normal case. The object is just being inserted as a normal + * entry into a symbol table. + */ + if (H5O_link (f, ent, 1)<0) { + HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "link inc failure"); } - if (NULL==(ret_value=H5G_shadow_open (f, &grp, ent))) { - HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, NULL, "can't open obj"); + if (H5G_stab_insert (f, &grp, rest, ent)<0) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't insert"); } - FUNC_LEAVE (ret_value); -} - - - -/*------------------------------------------------------------------------- - * Function: H5G_close - * - * Purpose: Closes an object that was open for modification. - * - * Errors: - * SYM CANTFLUSH Can't close object. - * - * Return: Success: SUCCEED - * - * Failure: FAIL - * - * Programmer: Robb Matzke - * Thursday, September 18, 1997 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -herr_t -H5G_close (H5F_t *f, H5G_entry_t *ent) -{ - FUNC_ENTER (H5G_close, FAIL); - - assert (f); - - if (ent && H5G_shadow_close (f, ent)<0) { - HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL, - "can't close object"); - } - FUNC_LEAVE (SUCCEED); } @@ -1254,25 +1294,19 @@ H5G_close (H5F_t *f, H5G_entry_t *ent) * to the current working group. On successful return, * GRP_ENT (if non-null) will be initialized with the symbol * table information for the group 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). + * appears (it will have an undefined object header address if + * the object is the root object) and OBJ_ENT will be + * initialized with the symbol table entry for the object + * (OBJ_ENT is optional when the caller is interested only in + * the existence of the object). * - * This function will fail if the root object is - * requested and there is none. + * This function will fail if the root object is requested and + * there is none. * * Errors: - * SYM NOTFOUND Object not found. * - * Return: Success: SUCCEED with GRP_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, see above for values of GRP_ENT and + * OBJ_ENT. * * Failure: FAIL * @@ -1286,28 +1320,17 @@ H5G_close (H5F_t *f, H5G_entry_t *ent) */ herr_t H5G_find (H5F_t *f, const char *name, - H5G_entry_t *grp_ent/*out*/, H5G_entry_t *ent/*out*/) + H5G_entry_t *grp_ent/*out*/, H5G_entry_t *obj_ent/*out*/) { - H5G_entry_t *ent_p = NULL; - H5G_entry_t *cwg = NULL; - FUNC_ENTER (H5G_find, FAIL); /* check args */ assert (f); assert (name && *name); - cwg = H5G_getcwg (f); - assert (cwg || '/'==*name); - if (!H5F_addr_defined (&(f->shared->root_sym->header))) { + if (H5G_namei (f, NULL, name, NULL, grp_ent, obj_ent)<0) { HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "object not found"); } - if (NULL==(ent_p=H5G_namei (f, cwg, name, NULL, grp_ent))) { - HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "object not found"); - } - - if (ent) *ent = *ent_p; FUNC_LEAVE (SUCCEED); } - |