diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/H5D.c | 87 | ||||
| -rw-r--r-- | src/H5Dprivate.h | 4 | ||||
| -rw-r--r-- | src/H5F.c | 34 | ||||
| -rw-r--r-- | src/H5Fprivate.h | 2 | ||||
| -rw-r--r-- | src/H5G.c | 721 | ||||
| -rw-r--r-- | src/H5Gprivate.h | 17 | ||||
| -rw-r--r-- | src/H5O.c | 10 | ||||
| -rw-r--r-- | src/H5Oprivate.h | 2 | ||||
| -rw-r--r-- | src/H5detect.c | 2 | ||||
| -rw-r--r-- | src/Makefile.in | 7 | ||||
| -rw-r--r-- | src/h5ls.c | 102 |
11 files changed, 567 insertions, 421 deletions
@@ -130,7 +130,7 @@ H5D_term_interface(void) /*------------------------------------------------------------------------- * Function: H5Dcreate * - * Purpose: Creates a new dataset named NAME in file FILE_ID, opens the + * Purpose: Creates a new dataset named NAME at LOC_ID, opens the * dataset for access, and associates with that dataset constant * and initial persistent properties including the type of each * datapoint as stored in the file (TYPE_ID), the size of the @@ -168,10 +168,10 @@ H5D_term_interface(void) *------------------------------------------------------------------------- */ hid_t -H5Dcreate(hid_t file_id, const char *name, hid_t type_id, hid_t space_id, +H5Dcreate(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_parms_id) { - H5F_t *f = NULL; + H5G_t *loc = NULL; H5T_t *type = NULL; H5S_t *space = NULL; H5D_t *new_dset = NULL; @@ -181,9 +181,8 @@ H5Dcreate(hid_t file_id, const char *name, hid_t type_id, hid_t space_id, FUNC_ENTER(H5Dcreate, FAIL); /* Check arguments */ - if (H5_FILE != H5I_group(file_id) || - NULL == (f = H5I_object(file_id))) { - HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL == (loc = H5G_loc(loc_id))) { + HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } if (!name || !*name) { HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name"); @@ -207,7 +206,8 @@ H5Dcreate(hid_t file_id, const char *name, hid_t type_id, hid_t space_id, } /* build and open the new dataset */ - if (NULL == (new_dset = H5D_create(f, name, type, space, create_parms))) { + if (NULL == (new_dset = H5D_create(loc, name, type, space, + create_parms))) { HRETURN_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to create dataset"); } @@ -219,23 +219,20 @@ H5Dcreate(hid_t file_id, const char *name, hid_t type_id, hid_t space_id, } FUNC_LEAVE(ret_value); } + /*------------------------------------------------------------------------- * Function: H5Dopen * - * Purpose: Finds a dataset named NAME in file FILE_ID, opens it, and - * returns its ID. The dataset should be close when the caller - * is no longer interested in it. + * Purpose: Finds a dataset named NAME at LOC_ID, opens it, and returns + * its ID. The dataset should be close when the caller is no + * longer interested in it. * * Return: Success: A new dataset ID * * Failure: FAIL * * Errors: - * ARGS BADTYPE Not a file. - * ARGS BADVALUE No name. - * DATASET CANTREGISTER Can't register dataset. - * DATASET NOTFOUND Dataset not found. * * Programmer: Robb Matzke * Thursday, December 4, 1997 @@ -245,25 +242,24 @@ H5Dcreate(hid_t file_id, const char *name, hid_t type_id, hid_t space_id, *------------------------------------------------------------------------- */ hid_t -H5Dopen(hid_t file_id, const char *name) +H5Dopen(hid_t loc_id, const char *name) { - H5F_t *file = NULL; /*file holding the dataset */ + H5G_t *loc = NULL; /*location holding the dataset */ H5D_t *dataset = NULL; /*the dataset */ hid_t ret_value = FAIL; FUNC_ENTER(H5Dopen, FAIL); /* Check args */ - if (H5_FILE != H5I_group(file_id) || - NULL == (file = H5I_object(file_id))) { - HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL == (loc = H5G_loc(loc_id))) { + HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } if (!name || !*name) { HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name"); } /* Find the dataset */ - if (NULL == (dataset = H5D_open(file, name))) { + if (NULL == (dataset = H5D_open(loc, name))) { HRETURN_ERROR(H5E_DATASET, H5E_NOTFOUND, FAIL, "dataset not found"); } @@ -722,7 +718,7 @@ H5Dextend (hid_t dataset_id, const size_t *size) *------------------------------------------------------------------------- */ H5D_t * -H5D_create(H5F_t *f, const char *name, const H5T_t *type, const H5S_t *space, +H5D_create(H5G_t *loc, const char *name, const H5T_t *type, const H5S_t *space, const H5D_create_t *create_parms) { H5D_t *new_dset = NULL; @@ -730,15 +726,17 @@ H5D_create(H5F_t *f, const char *name, const H5T_t *type, const H5S_t *space, intn i, ndims; size_t max_dim[H5O_LAYOUT_NDIMS]; H5O_efl_t *efl = NULL; + H5F_t *f = H5G_fileof (loc); FUNC_ENTER(H5D_create, NULL); /* check args */ - assert(f); - assert(name && *name); - assert(type); - assert(space); - assert(create_parms); + assert (f); + assert (loc); + assert (name && *name); + assert (type); + assert (space); + assert (create_parms); /* Initialize the dataset object */ new_dset = H5MM_xcalloc(1, sizeof(H5D_t)); @@ -869,7 +867,7 @@ H5D_create(H5F_t *f, const char *name, const H5T_t *type, const H5S_t *space, } /* Give the dataset a name */ - if (H5G_insert(name, &(new_dset->ent)) < 0) { + if (H5G_insert(loc, name, &(new_dset->ent)) < 0) { HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, NULL, "unable to name dataset"); } @@ -913,27 +911,29 @@ H5D_create(H5F_t *f, const char *name, const H5T_t *type, const H5S_t *space, *------------------------------------------------------------------------- */ H5D_t * -H5D_open(H5F_t *f, const char *name) +H5D_open(H5G_t *loc, const char *name) { H5D_t *dataset = NULL; /*the dataset which was found */ H5D_t *ret_value = NULL; /*return value */ intn i; - + H5F_t *f = NULL; + FUNC_ENTER(H5D_open, NULL); /* check args */ - assert(f); - assert(name && *name); - + assert (loc); + assert (name && *name); + + f = H5G_fileof (loc); dataset = H5MM_xcalloc(1, sizeof(H5D_t)); dataset->create_parms = H5P_copy (H5P_DATASET_CREATE, &H5D_create_dflt); H5F_addr_undef(&(dataset->ent.header)); /* Open the dataset object */ - if (H5G_find(f, name, NULL, &(dataset->ent)) < 0) { + if (H5G_find(loc, name, NULL, &(dataset->ent)) < 0) { HGOTO_ERROR(H5E_DATASET, H5E_NOTFOUND, NULL, "not found"); } - if (H5O_open(f, &(dataset->ent)) < 0) { + if (H5O_open(&(dataset->ent)) < 0) { HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, NULL, "unable to open"); } @@ -1127,6 +1127,11 @@ H5D_read(H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space, * enough value in xfer_parms since turning off data type conversion also * turns off background preservation. */ + if (nelmts!=H5S_get_npoints (file_space)) { + HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, + "src and dest data spaces have different sizes"); + } + if (0==nelmts) HRETURN (SUCCEED); if (NULL == (tconv_func = H5T_find(dataset->type, mem_type, xfer_parms->need_bkg, &cdata))) { HGOTO_ERROR(H5E_DATASET, H5E_UNSUPPORTED, FAIL, @@ -1142,10 +1147,7 @@ H5D_read(H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space, HGOTO_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL, "unable to convert from file to memory data space"); } - if (nelmts!=H5S_get_npoints (file_space)) { - HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, - "src and dest data spaces have different sizes"); - } + /* * If there is no type conversion then try reading directly into the @@ -1352,6 +1354,11 @@ H5D_write(H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space, * enough value in xfer_parms since turning off data type conversion also * turns off background preservation. */ + if (nelmts!=H5S_get_npoints (file_space)) { + HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, + "src and dest data spaces have different sizes"); + } + if (0==nelmts) HRETURN (SUCCEED); if (NULL == (tconv_func = H5T_find(mem_type, dataset->type, xfer_parms->need_bkg, &cdata))) { HGOTO_ERROR(H5E_DATASET, H5E_UNSUPPORTED, FAIL, @@ -1367,10 +1374,6 @@ H5D_write(H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space, HGOTO_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL, "unable to convert from memory to file data space"); } - if (nelmts!=H5S_get_npoints (file_space)) { - HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, - "src and dest data spaces have different sizes"); - } /* * If there is no type conversion then try writing directly from diff --git a/src/H5Dprivate.h b/src/H5Dprivate.h index 681928f..6068f00 100644 --- a/src/H5Dprivate.h +++ b/src/H5Dprivate.h @@ -61,9 +61,9 @@ extern const H5D_create_t H5D_create_dflt; extern const H5D_xfer_t H5D_xfer_dflt; /* Functions defined in H5D.c */ -H5D_t *H5D_create (H5F_t *f, const char *name, const H5T_t *type, +H5D_t *H5D_create (H5G_t *loc, const char *name, const H5T_t *type, const H5S_t *space, const H5D_create_t *create_parms); -H5D_t *H5D_open (H5F_t *f, const char *name); +H5D_t *H5D_open (H5G_t *loc, const char *name); herr_t H5D_close (H5D_t *dataset); herr_t H5D_read (H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space, const H5S_t *file_space, @@ -538,8 +538,8 @@ H5F_dest(H5F_t *f) if (f) { if (0 == --(f->shared->nrefs)) { + /* Do not close the root group since we didn't count it */ H5AC_dest(f); - f->shared->root_ent = H5MM_xfree(f->shared->root_ent); f->shared = H5MM_xfree(f->shared); } f->name = H5MM_xfree(f->name); @@ -834,7 +834,7 @@ H5F_open(const char *name, uintn flags, HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "can't write file boot block"); } - + } else if (1 == f->shared->nrefs) { /* For existing files we must read the boot block. */ if (H5F_locate_signature(f->shared->lf, @@ -940,11 +940,11 @@ H5F_open(const char *name, uintn flags, HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't read root symbol entry"); } - if (H5F_addr_defined(&(root_ent.header))) { - f->shared->root_ent = H5MM_xmalloc(sizeof(H5G_entry_t)); - *(f->shared->root_ent) = root_ent; + if (H5G_mkroot (f, &root_ent)<0) { + HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL, + "unable to read root group"); } - + /* * The userdefined data is the area of the file before the base * address. @@ -984,6 +984,12 @@ H5F_open(const char *name, uintn flags, #endif H5F_low_seteof(f->shared->lf, &addr2); } + + /* Create and/or open the root group if we haven't already done so */ + if (H5G_mkroot (f, NULL)<0) { + HGOTO_ERROR (H5E_FILE, H5E_CANTINIT, NULL, + "unable to create/open root group"); + } /* Success! */ ret_value = f; @@ -1268,7 +1274,7 @@ H5F_flush(H5F_t *f, hbool_t invalidate) H5F_addr_encode(f, &p, &(f->shared->smallobj_addr)); H5F_addr_encode(f, &p, &(f->shared->freespace_addr)); H5F_addr_encode(f, &p, &(f->shared->hdf5_eof)); - H5G_ent_encode(f, &p, f->shared->root_ent); + H5G_ent_encode(f, &p, H5G_entof(f->shared->root_grp)); /* update file length if necessary */ if (!H5F_addr_defined(&(f->shared->hdf5_eof))) { @@ -1312,8 +1318,8 @@ H5F_close(H5F_t *f) FUNC_ENTER(H5F_close, FAIL); /* Close all current working groups */ - while (H5G_pop(f) >= 0) /*void*/; - + while (H5G_pop(f)>=0) /*void*/; + /* Flush the boot block and caches */ if (H5F_flush(f, TRUE) < 0) { HRETURN_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't flush cache"); @@ -1324,7 +1330,7 @@ H5F_close(H5F_t *f) * they have all been closed. The file is in a consistent state now, so * forgetting to close everything is not a major problem. */ - if (f->nopen > 0) { + if (f->nopen>0) { #ifndef NDEBUG fprintf(stderr, "HDF5-DIAG: H5F_close: %u object header%s still " "open (file close will complete when %s closed)\n", @@ -1610,10 +1616,10 @@ H5F_debug(H5F_t *f, const haddr_t *addr, FILE * stream, intn indent, (unsigned) (f->shared->create_parms.sharedheader_ver)); fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth, - "Root symbol table entry:", - f->shared->root_ent ? "" : "(none)"); - if (f->shared->root_ent) { - H5G_ent_debug(f, f->shared->root_ent, stream, + "Root group symbol table entry:", + f->shared->root_grp ? "" : "(none)"); + if (f->shared->root_grp) { + H5G_ent_debug(f, H5G_entof (f->shared->root_grp), stream, indent + 3, MAX(0, fwidth - 3)); } FUNC_LEAVE(SUCCEED); diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h index 77a299f..9b7192a 100644 --- a/src/H5Fprivate.h +++ b/src/H5Fprivate.h @@ -404,7 +404,7 @@ typedef struct H5F_file_t { struct H5AC_t *cache; /* The object cache */ H5F_create_t create_parms; /* File-creation property list */ H5F_access_t access_parms; /* File-access property list */ - struct H5G_entry_t *root_ent; /* Root symbol table entry */ + struct H5G_t *root_grp; /* Open root group */ } H5F_file_t; /* @@ -4,21 +4,62 @@ * *------------------------------------------------------------------------- * - * Created: H5G.c - * Jul 18 1997 - * Robb Matzke <matzke@llnl.gov> + * Created: H5G.c + * Jul 18 1997 + * Robb Matzke <matzke@llnl.gov> + * + * Purpose: Symbol table functions. The functions that begin with + * `H5G_stab_' don't understand the naming system; they operate + * on a single symbol table at a time. + * + * The functions that begin with `H5G_node_' operate on the leaf + * nodes of a symbol table B-tree. They should be defined in + * the H5Gnode.c file. + * + * The remaining functions know how to traverse the group + * directed graph. + * + * Names: Object names are a slash-separated list of components. If + * the name begins with a slash then it's absolute, otherwise + * it's relative ("/foo/bar" is absolute while "foo/bar" is + * relative). Multiple consecutive slashes are treated as + * single slashes and trailing slashes are ignored. The special + * case `/' is the root group. Every file has a root group. + * + * API functions that look up names take a location ID and a + * name. The location ID can be a file ID or a group ID and the + * name can be relative or absolute. + * + * +--------------+----------- +--------------------------------+ + * | Location ID | Name | Meaning | + * +--------------+------------+--------------------------------+ + * | File ID | "/foo/bar" | Find `foo' within `bar' within | + * | | | the root group of the specified| + * | | | file. | + * +--------------+------------+--------------------------------+ + * | File ID | "foo/bar" | Find `foo' within `bar' within | + * | | | the current working group of | + * | | | the specified file. | + * +--------------+------------+--------------------------------+ + * | File ID | "/" | The root group of the specified| + * | | | file. | + * +--------------+------------+--------------------------------+ + * | File ID | "." | The current working group of | + * | | | the specified file. | + * +--------------+------------+--------------------------------+ + * | Group ID | "/foo/bar" | Find `foo' within `bar' within | + * | | | the root group of the file | + * | | | containing the specified group.| + * +--------------+------------+--------------------------------+ + * | Group ID | "foo/bar" | File `foo' within `bar' within | + * | | | the specified group. | + * +--------------+------------+--------------------------------+ + * | Group ID | "/" | The root group of the file | + * | | | containing the specified group.| + * +--------------+------------+--------------------------------+ + * | Group ID | "." | The specified group. | + * +--------------+------------+--------------------------------+ * - * Purpose: Symbol table functions. The functions that - * begin with `H5G_stab_' don't understand the - * naming system; they operate on a single - * symbol table at a time. - * - * The functions that begin with `H5G_node_' operate - * on the leaf nodes of a symbol table B-tree. They - * should be defined in the H5Gnode.c file. - * - * The remaining functions know how to traverse the - * group directed graph * * Modifications: * @@ -30,7 +71,7 @@ * *------------------------------------------------------------------------- */ -#define H5G_PACKAGE /*suppress error message about including H5Gpkg.h */ +#define H5G_PACKAGE /*suppress error message about including H5Gpkg.h */ /* Packages needed by this file... */ #include <H5private.h> @@ -47,19 +88,17 @@ #define PABLO_MASK H5G_mask /* Interface initialization */ -static hbool_t interface_initialize_g = FALSE; +static hbool_t interface_initialize_g = FALSE; #define INTERFACE_INIT H5G_init_interface -static herr_t H5G_init_interface(void); -static void H5G_term_interface(void); +static herr_t H5G_init_interface(void); +static void H5G_term_interface(void); -static H5G_entry_t *H5G_getcwg(H5F_t *f); /*------------------------------------------------------------------------- * 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. The group is opened for write access + * Purpose: Creates a new group relative to LOC_ID and gives it the + * specified NAME. The group is opened for write access * and it's object ID is returned. * * The optional SIZE_HINT specifies how much file space to @@ -85,24 +124,24 @@ static H5G_entry_t *H5G_getcwg(H5F_t *f); *------------------------------------------------------------------------- */ hid_t -H5Gcreate(hid_t file_id, const char *name, size_t size_hint) +H5Gcreate(hid_t loc_id, const char *name, size_t size_hint) { - H5F_t *f = NULL; - H5G_t *grp; + H5G_t *loc = NULL; + H5G_t *grp = NULL; hid_t ret_value = FAIL; FUNC_ENTER(H5Gcreate, FAIL); /* Check arguments */ - if (H5_FILE != H5I_group(file_id) || - NULL == (f = H5I_object(file_id))) { - HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL==(loc=H5G_loc (loc_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } if (!name || !*name) { HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name given"); } + /* Create the group */ - if (NULL == (grp = H5G_create(f, name, size_hint))) { + if (NULL == (grp = H5G_create(loc, name, size_hint))) { HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group"); } if ((ret_value = H5I_register(H5_GROUP, grp)) < 0) { @@ -112,6 +151,7 @@ H5Gcreate(hid_t file_id, const char *name, size_t size_hint) } FUNC_LEAVE(ret_value); } + /*------------------------------------------------------------------------- * Function: H5Gopen @@ -133,24 +173,24 @@ H5Gcreate(hid_t file_id, const char *name, size_t size_hint) *------------------------------------------------------------------------- */ hid_t -H5Gopen(hid_t file_id, const char *name) +H5Gopen(hid_t loc_id, const char *name) { - hid_t ret_value = FAIL; - H5F_t *f = NULL; - H5G_t *grp = NULL; + hid_t ret_value = FAIL; + H5G_t *grp = NULL; + H5G_t *loc = NULL; FUNC_ENTER(H5Gopen, FAIL); /* Check args */ - if (H5_FILE != H5I_group(file_id) || - NULL == (f = H5I_object(file_id))) { - HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL==(loc=H5G_loc(loc_id))) { + HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } if (!name || !*name) { HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name"); } + /* Open the group */ - if (NULL == (grp = H5G_open(f, name))) { + if (NULL == (grp = H5G_open(loc, name))) { HRETURN_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group"); } /* Register an atom for the group */ @@ -161,6 +201,7 @@ H5Gopen(hid_t file_id, const char *name) } FUNC_LEAVE(ret_value); } + /*------------------------------------------------------------------------- * Function: H5Gclose @@ -198,6 +239,7 @@ H5Gclose(hid_t grp_id) } FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5Gset @@ -211,6 +253,8 @@ H5Gclose(hid_t grp_id) * handles, then each handle's current working group can be * set independently of the other file handles for that file. * + * The initial current working group is the root group. + * * See also: H5Gpush(), H5Gpop() * * Errors: @@ -227,35 +271,37 @@ H5Gclose(hid_t grp_id) *------------------------------------------------------------------------- */ herr_t -H5Gset(hid_t file_id, const char *name) +H5Gset(hid_t loc_id, const char *name) { - H5F_t *f = NULL; - H5G_t *grp; + H5G_t *grp = NULL; + H5G_t *loc = NULL; FUNC_ENTER(H5Gset, FAIL); /* Check/fix arguments */ - if (H5_FILE != H5I_group(file_id) || - NULL == (f = H5I_object(file_id))) { - HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL==(loc=H5G_loc(loc_id))) { + HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } if (!name || !*name) { HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name"); } - if (NULL == (grp = H5G_open(f, name))) { + + /* Set the current working group */ + if (NULL == (grp = H5G_open(loc, name))) { HRETURN_ERROR(H5E_ARGS, H5E_NOTFOUND, FAIL, "no such group"); } - /* Set the current working group */ - if (H5G_set(f, grp) < 0) { + if (H5G_set(grp) < 0) { HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to change current working group"); } + /* Close the handle */ - if (H5G_close(grp) < 0) { + if (H5G_close(grp)<0) { HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group"); } FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5Gpush @@ -285,26 +331,26 @@ H5Gset(hid_t file_id, const char *name) *------------------------------------------------------------------------- */ herr_t -H5Gpush(hid_t file_id, const char *name) +H5Gpush(hid_t loc_id, const char *name) { - H5F_t *f = NULL; - H5G_t *grp; + H5G_t *grp = NULL; + H5G_t *loc = NULL; FUNC_ENTER(H5Gpush, FAIL); /* Check arguments */ - if (H5_FILE != H5I_group(file_id) || - NULL == (f = H5I_object(file_id))) { - HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL == (loc = H5G_loc(loc_id))) { + HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } if (!name || !*name) { HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name"); } - if (NULL == (grp = H5G_open(f, name))) { + + /* Push group onto stack */ + if (NULL == (grp = H5G_open(loc, name))) { HRETURN_ERROR(H5E_ARGS, H5E_NOTFOUND, FAIL, "no such group"); } - /* Push group onto stack */ - if (H5G_push(f, grp) < 0) { + if (H5G_push(grp) < 0) { HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't change current working group"); } @@ -314,6 +360,7 @@ H5Gpush(hid_t file_id, const char *name) } FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5Gpop @@ -327,6 +374,9 @@ H5Gpush(hid_t file_id, const char *name) * handles, then each handle's current working group can be * set independently of the other file handles for that file. * + * If LOC_ID is a group ID then it's used only to determine the + * file from which to pop. + * * See also: H5Gset(), H5Gpush() * * Errors: @@ -345,21 +395,20 @@ H5Gpush(hid_t file_id, const char *name) *------------------------------------------------------------------------- */ herr_t -H5Gpop(hid_t file_id) +H5Gpop(hid_t loc_id) { - H5F_t *f = NULL; + H5G_t *loc = NULL; FUNC_ENTER(H5Gpop, FAIL); /* Check arguments */ - if (H5_FILE != H5I_group(file_id) || - NULL == (f = H5I_object(file_id))) { - HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL == (loc = H5G_loc(loc_id))) { + HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } + /* pop */ - if (H5G_pop(f) < 0) { - HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, - "stack is empty"); + if (H5G_pop(H5G_fileof (loc))<0) { + HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "stack is empty"); } FUNC_LEAVE(SUCCEED); } @@ -368,8 +417,8 @@ H5Gpop(hid_t file_id) /*------------------------------------------------------------------------- * Function: H5Giterate * - * Purpose: Iterates over the entries of a group. The FILE_ID and NAME - * identify the group over which to iterate and INDEX indicates + * Purpose: Iterates over the entries of a group. The LOC_ID and NAME + * identify the group over which to iterate and IDX indicates * where to start iterating (zero means at the beginning). The * OPERATOR is called for each member and the iteration * continues until the operator returns non-zero or all members @@ -393,25 +442,24 @@ H5Gpop(hid_t file_id) *------------------------------------------------------------------------- */ herr_t -H5Giterate (hid_t file_id, const char *name, int *index, +H5Giterate (hid_t loc_id, const char *name, int *idx, H5G_iterate_t op, void *op_data) { - H5F_t *f = NULL; - int _index = 0; + int _idx = 0; H5G_bt_ud2_t udata; herr_t ret_value = FAIL; + H5G_t *loc = NULL; FUNC_ENTER (H5Giterate, FAIL); /* Check args */ - if (H5_FILE!=H5I_group (file_id) || - NULL==(f=H5I_object (file_id))) { - HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file"); + if (NULL==(loc=H5G_loc (loc_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a location"); } if (!name || !*name) { HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name specified"); } - if (!index) index = &_index; + if (!idx) idx = &_idx; if (!op) { HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no operator specified"); } @@ -420,7 +468,7 @@ H5Giterate (hid_t file_id, const char *name, int *index, * Open the group on which to operate. We also create a group ID which * we can pass to the application-defined operator. */ - if (NULL==(udata.group = H5G_open (f, name))) { + if (NULL==(udata.group = H5G_open (loc, name))) { HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to open group"); } if ((udata.group_id=H5I_register (H5_GROUP, udata.group))<0) { @@ -430,12 +478,12 @@ H5Giterate (hid_t file_id, const char *name, int *index, } /* Build udata to pass through H5B_iterate() to H5G_node_iterate() */ - udata.skip = *index; + udata.skip = *idx; udata.op = op; udata.op_data = op_data; /* Iterate over the group members */ - if ((ret_value = H5B_iterate (f, H5B_SNODE, + if ((ret_value = H5B_iterate (H5G_fileof(udata.group), H5B_SNODE, &(udata.group->ent.cache.stab.btree_addr), &udata))<0) { HERROR (H5E_SYM, H5E_CANTINIT, "iteration operator failed"); @@ -482,6 +530,7 @@ H5G_init_interface(void) } FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5G_term_interface @@ -502,6 +551,7 @@ H5G_term_interface(void) { H5I_destroy_group(H5_GROUP); } + /*------------------------------------------------------------------------- * Function: H5G_component @@ -525,17 +575,16 @@ H5G_term_interface(void) * *------------------------------------------------------------------------- */ -static const char * +static const char * H5G_component(const char *name, size_t *size_p) { assert(name); - while ('/' == *name) - name++; - if (size_p) - *size_p = HDstrcspn(name, "/"); + while ('/' == *name) name++; + if (size_p) *size_p = HDstrcspn(name, "/"); return name; } + /*------------------------------------------------------------------------- * Function: H5G_namei @@ -566,22 +615,14 @@ H5G_component(const char *name, size_t *size_p) * 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). + * Every file has a root group whose name is `/'. 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 group + * of the file containing LOC_ENT. Otherwise it begins at + * LOC_ENT. The component `.' is a no-op, but `..' is not + * understood by this function (unless it appears as an entry in + * the symbol table). * * Errors: * @@ -602,15 +643,13 @@ H5G_component(const char *name, size_t *size_p) *------------------------------------------------------------------------- */ 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*/, - H5G_entry_t *obj_ent/*out*/) +H5G_namei(H5G_entry_t *loc_ent, const char *name, const char **rest/*out*/, + H5G_entry_t *grp_ent/*out*/, H5G_entry_t *obj_ent/*out*/) { 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?*/ /* clear output args before FUNC_ENTER() in case it fails */ if (rest) *rest = name; @@ -623,36 +662,43 @@ H5G_namei(H5F_t *f, H5G_entry_t *cwg, const char *name, FUNC_ENTER(H5G_namei, FAIL); - /* check args */ - assert(f); - assert(name && *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) { - *obj_ent = *(f->shared->root_ent); - } else if (cwg) { - *obj_ent = *cwg; - } else if ((cwg = H5G_getcwg(f))) { - *obj_ent = *cwg; + /* + * Where does the searching start? For absolute names it starts at the + * root of the file; for relative names it starts at CWG. + */ + if (!name || !*name) { + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no name given"); + } else if (!loc_ent) { + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, + "no current working group"); + } else if ('/' == *name) { + *obj_ent = loc_ent->file->shared->root_grp->ent; } else { - HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "no current working group"); + *obj_ent = *loc_ent; } - assert(H5F_addr_defined(&(obj_ent->header))); /* traverse the name */ while ((name = H5G_component(name, &nchars)) && *name) { - if (rest) - *rest = name; + if (rest) *rest = name; + + /* + * 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)) { + HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, FAIL, + "component is too long"); + } + HDmemcpy(comp, name, nchars); + comp[nchars] = '\0'; /* * The special name `.' is a no-op. */ - if ('.' == name[0] && !name[1]) + if ('.' == comp[0] && !comp[1]) { + name += nchars; continue; + } /* * Advance to the next component of the name. @@ -661,68 +707,35 @@ H5G_namei(H5F_t *f, H5G_entry_t *cwg, const char *name, 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)) { - HRETURN_ERROR(H5E_SYM, H5E_COMPLEN, FAIL, "component is too long"); - } - HDmemcpy(comp, name, nchars); - comp[nchars] = '\0'; - - if (H5G_stab_find(grp_ent, comp, obj_ent /*out */ ) < 0) { + if (H5G_stab_find(grp_ent, comp, obj_ent/*out*/)<0) { /* * Component was not found in the current symbol table, possibly - * 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'. + * because GRP_ENT isn't a symbol table. */ - H5O_name_t mesg = - {0}; - if (!aside && - H5F_addr_eq(&(grp_ent->header), - &(f->shared->root_ent->header)) && - H5O_read(grp_ent, H5O_NAME, 0, &mesg) && - !HDstrcmp(mesg.s, comp)) { - H5O_reset(H5O_NAME, &mesg); - *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); - HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "component not found"); - } + HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "component not found"); } /* next component */ name += nchars; } - if (rest) - *rest = name; /*final null */ + if (rest) *rest = name; /*final null */ FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5G_mkroot * - * Purpose: Creates the root group if it doesn't exist; otherwise - * nothing happens. If the root symbol table entry previously - * pointed to something other than a group, then that object - * is made a member of the root group and is given a name - * corresponding to the object's name message (the name message - * is removed). If the root object doesn't have a name message - * then the name `Root Object' is used. + * Purpose: Creates a root group in an empty file and opens it. If a + * root group is already open then this function immediately + * returnes. If ENT is non-null then it's the symbol table + * entry for an existing group which will be opened as the root + * group. Otherwise a new root group is created and then + * opened. * - * Errors: - * * Return: Success: SUCCEED * - * Failure: FAIL. This function returns -2 if the - * failure is because a root group already - * exists. + * Failure: FAIL * * Programmer: Robb Matzke * matzke@llnl.gov @@ -732,88 +745,68 @@ H5G_namei(H5F_t *f, H5G_entry_t *cwg, const char *name, * *------------------------------------------------------------------------- */ -static herr_t -H5G_mkroot(H5F_t *f, size_t size_hint) +herr_t +H5G_mkroot (H5F_t *f, H5G_entry_t *ent) { - herr_t ret_value = FAIL; /*return value */ - H5O_name_t name = - {NULL}; /*object name */ - H5O_stab_t stab; /*symbol table message */ - H5G_entry_t new_root; /*new root object */ - const char *obj_name = NULL; /*name of old root object */ + H5G_entry_t new_root; /*new root object */ + H5O_stab_t stab; /*symbol table message */ FUNC_ENTER(H5G_mkroot, FAIL); /* check args */ assert(f); + if (f->shared->root_grp) return SUCCEED; /* - * If we already have a root object, then get it's name. + * If there is no root object then create one. The root group always has + * a hard link count of one since it's pointed to by the boot block. */ - if (f->shared->root_ent) { - if (H5O_read(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->shared->root_ent, H5O_NAME, 0, &name)) { - obj_name = "Root Object"; - } else { - obj_name = name.s; /*don't reset message until the end! */ + if (!ent) { + ent = &new_root; + if (H5G_stab_create (f, 16, ent/*out*/)<0) { + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, + "unable to create root group"); } - } - /* - * Create the new root group. Set the link count to 1. - */ - 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(&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. Then make the root object the - * new symbol table. - */ - if (f->shared->root_ent) { - assert(1 == H5O_link(f->shared->root_ent, 0)); - - if (H5G_stab_insert(&new_root, obj_name, f->shared->root_ent) < 0) { - HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, - "can't reinsert old root object"); + if (1 != H5O_link (ent, 1)) { + HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, + "internal error (wrong link count)"); } + } else { /* - * 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. + * Open the root object as a group. */ - H5O_remove(f->shared->root_ent, H5O_NAME, H5O_ALL); - H5E_clear(); /*who really cares? */ - - *(f->shared->root_ent) = new_root; - - } else { - f->shared->root_ent = H5G_ent_calloc(&new_root); + if (H5O_open (ent)<0) { + HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, FAIL, + "unable to open root group"); + } + if (NULL==H5O_read (ent, H5O_STAB, 0, &stab)) { + H5O_close (ent); + HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, + "root object is not a group"); + } + H5O_reset (H5O_STAB, &stab); } - H5O_close(&new_root); - ret_value = SUCCEED; + /* + * Create the group pointer. Also decrement the open object count so we + * don't count the root group as an open object. The root group will + * never be closed. + */ + f->shared->root_grp = H5MM_xcalloc (1, sizeof(H5G_t)); + f->shared->root_grp->ent = *ent; + f->shared->root_grp->nref = 1; + assert (1==f->nopen); + f->nopen = 0; - done: - H5O_reset(H5O_NAME, &name); - FUNC_LEAVE(ret_value); + FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5G_create * * 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 "/" - * (or any equivalent name) will result in an H5E_EXISTS - * failure. + * is either an absolute name or is relative to LOC. * * Errors: * @@ -832,32 +825,22 @@ H5G_mkroot(H5F_t *f, size_t size_hint) *------------------------------------------------------------------------- */ H5G_t * -H5G_create(H5F_t *f, const char *name, size_t size_hint) +H5G_create(H5G_t *loc, const char *name, size_t size_hint) { const char *rest = NULL; /*the base name */ H5G_entry_t grp_ent; /*group containing new group */ 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_create, NULL); /* check args */ - assert(f); + assert(loc); assert(name && *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"); - } - H5E_clear(); - /* lookup name */ - if (0 == H5G_namei(f, NULL, name, &rest, &grp_ent, NULL)) { + if (0 == H5G_namei(H5G_entof(loc), name, &rest, &grp_ent, NULL)) { HRETURN_ERROR(H5E_SYM, H5E_EXISTS, NULL, "already exists"); } H5E_clear(); /*it's OK that we didn't find it */ @@ -881,7 +864,7 @@ H5G_create(H5F_t *f, const char *name, size_t size_hint) /* create an open group */ grp = H5MM_xcalloc(1, sizeof(H5G_t)); - if (H5G_stab_create(f, size_hint, &(grp->ent)/*out*/) < 0) { + if (H5G_stab_create(grp_ent.file, size_hint, &(grp->ent)/*out*/) < 0) { grp = H5MM_xfree(grp); HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "can't create grp"); } @@ -914,7 +897,7 @@ H5G_create(H5F_t *f, const char *name, size_t size_hint) *------------------------------------------------------------------------- */ H5G_t * -H5G_open(H5F_t *f, const char *name) +H5G_open(H5G_t *loc, const char *name) { H5G_t *grp = NULL; H5G_t *ret_value = NULL; @@ -923,15 +906,15 @@ H5G_open(H5F_t *f, const char *name) FUNC_ENTER(H5G_open, NULL); /* Check args */ - assert(f); + assert(loc); assert(name && *name); /* Open the object, making sure it's a group */ grp = H5MM_xcalloc(1, sizeof(H5G_t)); - if (H5G_find(f, name, NULL, &(grp->ent)) < 0) { + if (H5G_find(loc, name, NULL, &(grp->ent)/*out*/) < 0) { HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "group not found"); } - if (H5O_open(f, &(grp->ent)) < 0) { + if (H5O_open(&(grp->ent)) < 0) { HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to open group"); } if (NULL==H5O_read (&(grp->ent), H5O_STAB, 0, &mesg)) { @@ -947,6 +930,7 @@ H5G_open(H5F_t *f, const char *name) } FUNC_LEAVE(ret_value); } + /*------------------------------------------------------------------------- * Function: H5G_reopen @@ -964,7 +948,7 @@ H5G_open(H5F_t *f, const char *name) * *------------------------------------------------------------------------- */ -H5G_t * +H5G_t * H5G_reopen(H5G_t *grp) { FUNC_ENTER(H5G_reopen, NULL); @@ -976,6 +960,7 @@ H5G_reopen(H5G_t *grp) FUNC_LEAVE(grp); } + /*------------------------------------------------------------------------- * Function: H5G_close @@ -1003,6 +988,7 @@ H5G_close(H5G_t *grp) assert(grp->nref > 0); if (1 == grp->nref) { + assert (grp!=H5G_fileof(grp)->shared->root_grp); if (H5O_close(&(grp->ent)) < 0) { HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close"); } @@ -1011,6 +997,7 @@ H5G_close(H5G_t *grp) FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5G_set @@ -1041,13 +1028,15 @@ H5G_close(H5G_t *grp) *------------------------------------------------------------------------- */ herr_t -H5G_set(H5F_t *f, H5G_t *grp) +H5G_set (H5G_t *grp) { + H5F_t *f; + FUNC_ENTER(H5G_set, FAIL); /* check args */ - assert(f); assert(grp); + f = H5G_fileof (grp); /* * If there is no stack then create one, otherwise close the current @@ -1056,25 +1045,23 @@ H5G_set(H5F_t *f, H5G_t *grp) if (!f->cwg_stack) { f->cwg_stack = H5MM_xcalloc(1, sizeof(H5G_cwgstk_t)); } else if (H5G_close(f->cwg_stack->grp) < 0) { - HRETURN_ERROR(H5E_SYM, H5E_CWG, FAIL, "couldn't close previous c.w.g."); + HRETURN_ERROR(H5E_SYM, H5E_CWG, FAIL, + "couldn't close previous current working group"); } - f->cwg_stack->grp = H5G_reopen(grp); + f->cwg_stack->grp = H5G_reopen (grp); FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5G_getcwg * - * 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 the current working group or root - * object. The pointer is valid only until the - * root object changes or the current working - * group changes. + * Purpose: Returns the current working group. + * + * Return: Success: The current working group. This group should + * not* be closed with H5G_close() when the + * caller is done with it. * * Failure: NULL * @@ -1085,25 +1072,25 @@ H5G_set(H5F_t *f, H5G_t *grp) * *------------------------------------------------------------------------- */ -static H5G_entry_t * +H5G_t * H5G_getcwg(H5F_t *f) { - H5G_entry_t *ret_value = NULL; + H5G_t *ret_value = NULL; FUNC_ENTER(H5G_getcwg, NULL); /* check args */ assert(f); - /* return a pointer directly into the stack */ - if (f->cwg_stack && f->cwg_stack->grp) { - ret_value = &(f->cwg_stack->grp->ent); + if (f->cwg_stack) { + ret_value = f->cwg_stack->grp; } else { - ret_value = f->shared->root_ent; + ret_value = f->shared->root_grp; } - + FUNC_LEAVE(ret_value); } + /*------------------------------------------------------------------------- * Function: H5G_push @@ -1112,8 +1099,6 @@ H5G_getcwg(H5F_t *f) * is reopened and held open until it is removed from the stack. * * Errors: - * SYM CWG Can't open group. - * SYM CWG Not a group. * * Return: Success: SUCCEED * @@ -1127,14 +1112,13 @@ H5G_getcwg(H5F_t *f) *------------------------------------------------------------------------- */ herr_t -H5G_push(H5F_t *f, H5G_t *grp) +H5G_push (H5G_t *grp) { - H5G_cwgstk_t *stack = NULL; + H5G_cwgstk_t *stack = NULL; FUNC_ENTER(H5G_push, FAIL); /* check args */ - assert(f); assert(grp); /* @@ -1142,20 +1126,21 @@ H5G_push(H5F_t *f, H5G_t *grp) */ stack = H5MM_xcalloc(1, sizeof(H5G_cwgstk_t)); stack->grp = H5G_reopen(grp); - stack->next = f->cwg_stack; - f->cwg_stack = stack; + stack->next = H5G_fileof(grp)->cwg_stack; + H5G_fileof(grp)->cwg_stack = stack; FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5G_pop * - * Purpose: Pops the top current working group off the stack. + * Purpose: Pops the top current working group off the stack. If the + * stack becomes empty then the current working group is + * implicitly the root group. * * Errors: - * SYM CWG Can't close current working group. - * SYM CWG Stack is empty. * * Return: Success: SUCCEED * @@ -1169,7 +1154,7 @@ H5G_push(H5F_t *f, H5G_t *grp) *------------------------------------------------------------------------- */ herr_t -H5G_pop(H5F_t *f) +H5G_pop (H5F_t *f) { H5G_cwgstk_t *stack = NULL; @@ -1192,12 +1177,12 @@ H5G_pop(H5F_t *f) FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5G_insert * - * Purpose: Inserts a symbol table entry into the group graph. The file - * that is used is contained in the ENT argument. + * Purpose: Inserts a symbol table entry into the group graph. * * Errors: * @@ -1213,46 +1198,29 @@ H5G_pop(H5F_t *f) *------------------------------------------------------------------------- */ herr_t -H5G_insert(const char *name, H5G_entry_t *ent) +H5G_insert(H5G_t *loc, const char *name, H5G_entry_t *ent) { const char *rest = NULL; /*part of name not existing yet */ H5G_entry_t grp; /*entry for group to contain obj */ size_t nchars; /*number of characters in name */ char _comp[1024]; /*name component */ - hbool_t update_grp; - herr_t status; FUNC_ENTER(H5G_insert, FAIL); /* Check args. */ - assert(name && *name); - assert(ent); + assert (loc); + assert (name && *name); + assert (ent); /* * Look up the name -- it shouldn't exist yet. */ - if (H5G_namei(ent->file, NULL, name, &rest, &grp, NULL) >= 0) { + if (H5G_namei(H5G_entof(loc), name, &rest, &grp, NULL) >= 0) { HRETURN_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "already exists"); } H5E_clear(); /*it's OK that we didn't find it */ 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 (ent->file->shared->root_ent) { - HRETURN_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "root exists"); - } - if (1 != H5O_link(ent, 1)) { - HRETURN_ERROR(H5E_SYM, H5E_LINK, FAIL, "bad link count"); - } - ent->name_off = 0; - ent->file->shared->root_ent = H5G_ent_calloc(ent); - HRETURN(SUCCEED); - } /* * There should be one component left. Make sure it's null * terminated. @@ -1269,40 +1237,9 @@ H5G_insert(const char *name, H5G_entry_t *ent) rest = _comp; } } - if (!ent->file->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). - */ - H5O_name_t name_mesg; - name_mesg.s = rest; - if (H5O_modify(ent, H5O_NAME, 0, 0, &name_mesg) < 0) { - HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, - "cannot add/change name message"); - } - if (1 != H5O_link(ent, 1)) { - HRETURN_ERROR(H5E_SYM, H5E_LINK, FAIL, "bad link count"); - } - ent->file->shared->root_ent = H5G_ent_calloc(ent); - HRETURN(SUCCEED); - } - /* - * Make sure the root group exists. Ignore the failure if it's - * because the group already exists. - */ - update_grp = (hbool_t)H5F_addr_eq(&(grp.header), - &(ent->file->shared->root_ent->header)); - if ((status = H5G_mkroot(ent->file, H5G_SIZE_HINT)) < 0 && -2 != status) { - HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't create root group"); - } - H5E_clear(); - if (update_grp==TRUE) - grp = *(ent->file->shared->root_ent); /* - * This is the normal case. The object is just being inserted as a normal - * entry into a symbol table. + * The object into a symbol table. */ if (H5O_link(ent, 1) < 0) { HRETURN_ERROR(H5E_SYM, H5E_LINK, FAIL, "link inc failure"); @@ -1312,23 +1249,19 @@ H5G_insert(const char *name, H5G_entry_t *ent) } 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 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 (it will have an undefined object header address if - * the object is the root object) and OBJ_ENT will be + * Purpose: Finds an object with the specified NAME at location LOC. On + * successful return, GRP_ENT (if non-null) will be initialized + * with the symbol table information for the group in which 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. + * the existence of the object). * * Errors: * @@ -1346,17 +1279,109 @@ H5G_insert(const char *name, H5G_entry_t *ent) *------------------------------------------------------------------------- */ herr_t -H5G_find(H5F_t *f, const char *name, - H5G_entry_t *grp_ent /*out */ , H5G_entry_t *obj_ent /*out */ ) +H5G_find(H5G_t *loc, const char *name, + H5G_entry_t *grp_ent/*out*/, H5G_entry_t *obj_ent/*out*/) { FUNC_ENTER(H5G_find, FAIL); /* check args */ - assert(f); - assert(name && *name); + assert (loc); + assert (name && *name); - if (H5G_namei(f, NULL, name, NULL, grp_ent, obj_ent) < 0) { + if (H5G_namei(H5G_entof(loc), name, NULL, grp_ent, obj_ent) < 0) { HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "object not found"); } FUNC_LEAVE(SUCCEED); } + + +/*------------------------------------------------------------------------- + * Function: H5G_entof + * + * Purpose: Returns a pointer to the entry for a group. + * + * Return: Success: Ptr to group entry + * + * Failure: NULL + * + * Programmer: Robb Matzke + * Tuesday, March 24, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +H5G_entry_t * +H5G_entof (H5G_t *grp) +{ + return grp ? &(grp->ent) : NULL; +} + + +/*------------------------------------------------------------------------- + * Function: H5G_fileof + * + * Purpose: Returns the file to which the specified group belongs. + * + * Return: Success: File pointer. + * + * Failure: NULL + * + * Programmer: Robb Matzke + * Tuesday, March 24, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +H5F_t * +H5G_fileof (H5G_t *grp) +{ + assert (grp); + return grp->ent.file; +} + + +/*------------------------------------------------------------------------- + * Function: H5G_loc + * + * Purpose: Given a location ID return a group. The group should not be + * closed. + * + * Return: Success: Group pointer. + * + * Failure: NULL + * + * Programmer: Robb Matzke + * Tuesday, March 24, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +H5G_t * +H5G_loc (hid_t loc_id) +{ + H5F_t *f; + H5G_t *ret_value = NULL; + + FUNC_ENTER (H5G_loc, NULL); + + if (H5_FILE==H5I_group (loc_id)) { + if (NULL==(f=H5I_object (loc_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, NULL, "invalid file ID"); + } + if (NULL==(ret_value=H5G_getcwg (f))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, NULL, + "unable to get current working directory"); + } + } else if (H5_GROUP==H5I_group (loc_id)) { + if (NULL==(ret_value=H5I_object (loc_id))) { + HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, NULL, "invalid group ID"); + } + } else { + HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, NULL, "not a location"); + } + + FUNC_LEAVE (ret_value); +} diff --git a/src/H5Gprivate.h b/src/H5Gprivate.h index 425d8a5..b79d1e2 100644 --- a/src/H5Gprivate.h +++ b/src/H5Gprivate.h @@ -91,15 +91,20 @@ typedef struct H5G_t H5G_t; * Library prototypes... These are the ones that other packages routinely * call. */ -H5G_t *H5G_create (H5F_t *f, const char *name, size_t size_hint); -H5G_t *H5G_open (H5F_t *f, const char *name); +H5G_t *H5G_loc (hid_t loc_id); +herr_t H5G_mkroot (H5F_t *f, H5G_entry_t *root_entry); +H5G_entry_t *H5G_entof (H5G_t *grp); +H5F_t *H5G_fileof (H5G_t *grp); +H5G_t *H5G_create (H5G_t *loc, const char *name, size_t size_hint); +H5G_t *H5G_open (H5G_t *loc, const char *name); H5G_t *H5G_reopen (H5G_t *grp); herr_t H5G_close (H5G_t *grp); -herr_t H5G_set (H5F_t *f, H5G_t *grp); -herr_t H5G_push (H5F_t *f, H5G_t *grp); +herr_t H5G_set (H5G_t *grp); +herr_t H5G_push (H5G_t *grp); herr_t H5G_pop (H5F_t *f); -herr_t H5G_insert (const char *name, H5G_entry_t *ent); -herr_t H5G_find (H5F_t *f, const char *name, H5G_entry_t *grp_ent/*out*/, +H5G_t *H5G_getcwg(H5F_t *f); +herr_t H5G_insert (H5G_t *cwg, const char *name, H5G_entry_t *ent); +herr_t H5G_find (H5G_t *cwg, const char *name, H5G_entry_t *grp_ent/*out*/, H5G_entry_t *ent/*out*/); herr_t H5G_ent_encode (H5F_t *f, uint8 **pp, H5G_entry_t *ent); herr_t H5G_ent_decode (H5F_t *f, const uint8 **pp, H5G_entry_t *ent/*out*/); @@ -147,6 +147,7 @@ H5O_create(H5F_t *f, size_t size_hint, H5G_entry_t *ent/*out*/) /* allocate disk space for header and first chunk */ size = H5O_SIZEOF_HDR(f) + size_hint; + ent->file = f; if (H5MF_alloc(f, H5MF_META, size, &(ent->header)/*out*/) < 0) { HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate file space for object header hdr"); @@ -190,12 +191,13 @@ H5O_create(H5F_t *f, size_t size_hint, H5G_entry_t *ent/*out*/) } /* open it */ - if (H5O_open(f, ent) < 0) { + if (H5O_open(ent) < 0) { HRETURN_ERROR(H5E_OHDR, H5E_CANTOPENOBJ, FAIL, "unable to open object header"); } FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5O_open @@ -215,13 +217,13 @@ H5O_create(H5F_t *f, size_t size_hint, H5G_entry_t *ent/*out*/) *------------------------------------------------------------------------- */ herr_t -H5O_open(H5F_t *f, H5G_entry_t *obj_ent) +H5O_open(H5G_entry_t *obj_ent) { FUNC_ENTER(H5O_open, FAIL); /* Check args */ - assert(f); assert(obj_ent); + assert(obj_ent->file); #ifdef H5O_DEBUG fprintf(stderr, ">"); @@ -230,10 +232,10 @@ H5O_open(H5F_t *f, H5G_entry_t *obj_ent) #endif /* Increment open-lock counters */ - obj_ent->file = f; obj_ent->file->nopen++; FUNC_LEAVE(SUCCEED); } + /*------------------------------------------------------------------------- * Function: H5O_close diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h index 079ba24..b20e6ed 100644 --- a/src/H5Oprivate.h +++ b/src/H5Oprivate.h @@ -202,7 +202,7 @@ typedef struct H5O_stab_t { /* General message operators */ herr_t H5O_create (H5F_t *f, size_t size_hint, H5G_entry_t *ent/*out*/); -herr_t H5O_open (H5F_t *f, H5G_entry_t *ent); +herr_t H5O_open (H5G_entry_t *ent); herr_t H5O_close (H5G_entry_t *ent); intn H5O_link (H5G_entry_t *ent, intn adjust); void *H5O_read (H5G_entry_t *ent, const H5O_class_t *type, intn sequence, diff --git a/src/H5detect.c b/src/H5detect.c index 3d56c39..93343fd 100644 --- a/src/H5detect.c +++ b/src/H5detect.c @@ -1,4 +1,4 @@ -/**/ +/*keep this here -RPM*/ static const char *FileHeader = "\n\ /*-------------------------------------------------------------------------\n\ * Copyright (C) 1997 National Center for Supercomputing Applications. \n\ diff --git a/src/Makefile.in b/src/Makefile.in index aff0d60..66a3949 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -11,7 +11,7 @@ CPPFLAGS=-I. @CPPFLAGS@ # These are our main targets: LIB=libhdf5.a -PROGS=debug +PROGS=debug h5ls # Source and object files for the library (lexicographically)... PARALLEL_SRC=H5Fmpio.c @@ -29,7 +29,7 @@ LIB_OBJ=$(LIB_SRC:.c=.o) MOSTLYCLEAN=H5detect.o H5detect H5Tinit.o H5Tinit.c # Source and object files for programs... -PROG_SRC=debug.c +PROG_SRC=debug.c h5ls.c PROG_OBJ=$(PROG_SRC:.c=.o) # Public header files (to be installed)... @@ -56,4 +56,7 @@ H5detect: H5detect.o debug: debug.o $(LIB) $(CC) $(CFLAGS) -o $@ debug.o $(LIB) $(LIBS) +h5ls: h5ls.o $(LIB) + $(CC) $(CFLAGS) -o $@ h5ls.o $(LIB) $(LIBS) + @CONCLUDE@ diff --git a/src/h5ls.c b/src/h5ls.c new file mode 100644 index 0000000..e8ac70c --- /dev/null +++ b/src/h5ls.c @@ -0,0 +1,102 @@ +/* + * Copyright (C) 1998 NCSA + * All rights reserved. + * + * Programmer: Robb Matzke <matzke@llnl.gov> + * Monday, March 23, 1998 + */ +#include <assert.h> +#include <hdf5.h> +#include <stdio.h> +#include <stdlib.h> + + + +/*------------------------------------------------------------------------- + * Function: list + * + * Purpose: Prints the group member name. + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Robb Matzke + * Monday, March 23, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +list (hid_t group, const char *name, void *op_data) +{ + hid_t obj; + hid_t (*func)(void*); + void *edata; + int i; + + /* Disable error reporting */ + H5Eget_auto (&func, &edata); + H5Eset_auto (NULL, NULL); + + /* Print info about each name */ + printf ("%-30s", name); + if ((obj=H5Dopen (group, name))>=0) { + size_t size[64]; + hid_t space = H5Dget_space (obj); + int ndims = H5Sget_dims (space, size); + printf (" Dataset {"); + for (i=0; i<ndims; i++) { + printf ("%s%lu", i?", ":"", (unsigned long)size[i]); + } + printf ("}\n"); + H5Dclose (space); + H5Dclose (obj); + } else if ((obj=H5Gopen (group, name))>=0) { + printf (" Group\n"); + H5Gclose (obj); + } else { + printf (" Unknown Type\n"); + } + + /* Restore error reporting */ + H5Eset_auto (func, edata); + return 0; +} + + + +/*------------------------------------------------------------------------- + * Function: main + * + * Purpose: Opens a file and lists the specified group + * + * Return: Success: 0 + * + * Failure: 1 + * + * Programmer: Robb Matzke + * Monday, March 23, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +int +main (int argc, char *argv[]) +{ + hid_t file; + herr_t status; + + assert (3==argc); + + file = H5Fopen (argv[1], H5F_ACC_RDONLY, H5P_DEFAULT); + assert (file>=0); + + status = H5Giterate (file, argv[2], NULL, list, NULL); + assert (status>=0); + + H5Fclose (file); + return 0; +} |