diff options
| -rw-r--r-- | src/H5Apublic.h | 1 | ||||
| -rw-r--r-- | src/H5D.c | 65 | ||||
| -rw-r--r-- | src/H5G.c | 47 | ||||
| -rw-r--r-- | src/H5Gpublic.h | 3 | ||||
| -rw-r--r-- | src/H5Oprivate.h | 27 | ||||
| -rw-r--r-- | src/H5Osdim.c | 400 | ||||
| -rw-r--r-- | src/H5Osdtyp.c | 364 |
7 files changed, 896 insertions, 11 deletions
diff --git a/src/H5Apublic.h b/src/H5Apublic.h index a987a62..3823b28 100644 --- a/src/H5Apublic.h +++ b/src/H5Apublic.h @@ -31,6 +31,7 @@ typedef enum { H5_DATATYPE, /* Group ID for Datatype objects */ H5_DATASPACE, /* Group ID for Dataspace objects */ H5_DATASET, /* Group ID for Dataset objects */ + H5_DIRECTORY, /* Group ID for Directory objects */ MAXGROUP /* Highest group in group_t (Invalid as true group) */ } group_t; @@ -142,7 +142,7 @@ done: --------------------------------------------------------------------------*/ herr_t H5Dset_info(hatom_t oid, hatom_t tid, hatom_t did) { - H5D_dataset_t *dataset; /* dataset object to release */ + H5D_dataset_t *dataset; /* dataset object to modify */ herr_t ret_value = SUCCEED; FUNC_ENTER(H5Dset_info, H5D_init_interface, FAIL); @@ -236,7 +236,7 @@ done: /* Normal function cleanup */ FUNC_LEAVE(ret_value); -} /* end H5Dset_info() */ +} /* end H5Dwrite() */ /*-------------------------------------------------------------------------- NAME @@ -256,9 +256,6 @@ done: herr_t H5D_flush(hatom_t oid) { H5D_dataset_t *dataset; /* dataset object to release */ -#ifdef QUINCEY - H5F_ -#endif herr_t ret_value = SUCCEED; FUNC_ENTER(H5D_flush, H5D_init_interface, FAIL); @@ -275,20 +272,66 @@ herr_t H5D_flush(hatom_t oid) /* Check if we need to create the dataset header and insert the dataset in the file's hierarchy */ if(dataset->header==0) { + H5G_entry_t d_sym; H5F_root_symtype_t root_type=H5F_root_type(dataset->file); + hdf5_file_t *file; + group_t dset_parent=H5Aatom_group(dataset->parent); + + /* Get the dataset's file... (I'm not fond of this. -QAK) */ + if((file=H5Aatom_object(dataset->file))==NULL) + HGOTO_ERROR(H5E_INTERNAL, H5E_BADATOM, FAIL); /* Flush object header, etc. to the file... */ if(root_type==H5F_ROOT_ERROR) HGOTO_ERROR(H5E_SYM, H5E_BADVALUE, FAIL); - if(root_type==H5F_ROOT_DATASET || H5F_ROOT_UNKNOWN) + + /* construct dataset symbol-table entry */ + d_sym.name_off=0; + /* allocate the dataset's object header */ + if((d_sym.header=H5O_new(file, 1, 0))<0) + HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); + d_sym.type=H5G_NOTHING_CACHED; + dataset->header=d_sym.header; + + /* Insert dataset into parent directory, if there is one */ + if(dset_parent!=H5_FILE || + (dset_parent==H5_FILE && root_type==H5F_ROOT_DIRECTORY)) { + uintn namelen; /* length of parent directory's name */ + char *name; /* pointer to parent directory's name */ + + /* Get the name of the parent directory */ + if((namelen=H5Mname_len(dataset->parent))==UFAIL) + HGOTO_ERROR(H5E_DIRECTORY, H5E_BADVALUE, FAIL); + if((name=HDmalloc(namelen+1))==NULL); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL); + if(H5Mget_name(dataset->parent,name)==FAIL) + HGOTO_ERROR(H5E_DIRECTORY, H5E_NOTFOUND, FAIL); + + /* Insert the dataset into the parent directory */ + if(H5G_insert (file, NULL, name, dataset->name, &d_sym)==FAIL) + HGOTO_ERROR(H5E_DIRECTORY, H5E_CANTINSERT, FAIL); + HDfree(name); } /* end if */ - else + else /* insert dataset as root-object, or into root-directory */ { -#ifdef QUINCEY - if(root_type -#endif - } /* end if */ + if(root_type==H5F_ROOT_DATASET || H5F_ROOT_UNKNOWN) + { + /* Make the root directory and stuff the dataset into it */ + if(H5G_mkroot (file, H5G_DEFAULT_ROOT_SIZE)==FAIL) + HGOTO_ERROR(H5E_DIRECTORY, H5E_CANTCREATE, FAIL); + if(H5G_insert (file, NULL, NULL, dataset->name, &d_sym)==FAIL) + HGOTO_ERROR(H5E_DIRECTORY, H5E_CANTINSERT, FAIL); + } /* end if */ + else + { + /* Set the root of the file to point to the dataset */ + if(root_type==H5F_ROOT_NONE) + H5G_set_root(file, dataset->name, &d_sym); + } /* end else */ + } /* end else */ + + /* Add the appropriate messages for the dataset */ } /* end if */ } /* end if */ @@ -557,6 +557,53 @@ H5G_insert (hdf5_file_t *f, H5G_entry_t *cwd, H5G_entry_t *dir_ent, FUNC_LEAVE (SUCCEED); } +/*-------------------------------------------------------------------------- + NAME + H5G_set_root + PURPOSE + Inserts symbol table ENT as the file's root object giving it the specified + NAME. NAME is not allowed to be relative. + USAGE + herr_t H5G_set_root(f, name, ent) + hatom_t f; IN: File to set root entry + const char *name; IN: Root object's name + H5G_entry_t *ent; IN: Root object's symbol-table entry + RETURNS + SUCCEED/FAIL + DESCRIPTION + This function sets the root object of a file to be the symbol-table + table passed as an argument. The primary function of this routine is to + make a dataset the root object of a file. (The dataset may be replaced + with a "real" root directory, but at this point, the dataset is the only + object in the file) +--------------------------------------------------------------------------*/ +herr_t +H5G_set_root (hdf5_file_t *f, const char *name, H5G_entry_t *ent) +{ + herr_t status; + const char *rest=NULL; + H5G_entry_t _parent; + size_t nchars; + char _comp[1024]; + + FUNC_ENTER (H5G_set_root, NULL, FAIL); + + /* check args */ + assert (f); + assert (name && *name); + assert (ent); + + /* lookup base-name */ + if(HDstrlen(rest = H5G_basename (name, NULL))<=0) + HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, FAIL); /* invalid base name */ + H5ECLEAR; + + /* insert entry as root object */ + HDmemcpy(file->root_sym,ent,sizeof(H5G_entry_t)); + + FUNC_LEAVE (SUCCEED); +} + /*------------------------------------------------------------------------- * Function: H5G_modify diff --git a/src/H5Gpublic.h b/src/H5Gpublic.h index 797b16a..049c823 100644 --- a/src/H5Gpublic.h +++ b/src/H5Gpublic.h @@ -21,6 +21,9 @@ /* Public headers needed by this file */ #include <H5public.h> +/* Default root directory size */ +#define H5G_DEFAULT_ROOT SIZE 256 + #ifdef __cplusplus extern "C" { #endif diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h index 65d76db..34acff9 100644 --- a/src/H5Oprivate.h +++ b/src/H5Oprivate.h @@ -124,6 +124,33 @@ typedef struct H5O_stab_t { haddr_t heap; /*address of name heap */ } H5O_stab_t; +/* + * Simple Datatype message. + */ +#define H5O_SIM_DTYPE_ID 0x0003 +extern const H5O_class_t H5O_SIM_DTYPE[1]; + +typedef struct { + uint8 length; /* Number of bytes */ + uint8 arch; /* Architecture format of the data */ + hatom_t type; /* Type of the data */ +} H5O_sim_dtype_t; + +/* + * Simple Dimensionality message. + */ +#define H5O_SIM_DIM_ID 0x0001 +extern const H5O_class_t H5O_SIM_DIM[1]; + +typedef struct { + uint32 rank; /* Number of dimensions */ + uint32 dim_flags; /* Dimension flags */ + uint32 *size; /* Dimension sizes */ + uint32 *max; /* Maximum dimension sizes */ + uint32 *perm; /* Dimension permutations */ +} H5O_sim_dim_t; + + haddr_t H5O_new (hdf5_file_t *f, intn nlink, size_t size_hint); intn H5O_link (hdf5_file_t *f, haddr_t addr, H5G_entry_t *ent, intn adjust); diff --git a/src/H5Osdim.c b/src/H5Osdim.c new file mode 100644 index 0000000..a5f3e29 --- /dev/null +++ b/src/H5Osdim.c @@ -0,0 +1,400 @@ +/**************************************************************************** +* NCSA HDF * +* Software Development Group * +* National Center for Supercomputing Applications * +* University of Illinois at Urbana-Champaign * +* 605 E. Springfield, Champaign IL 61820 * +* * +* For conditions of distribution and use, see the accompanying * +* hdf/COPYING file. * +* * +****************************************************************************/ + +#ifdef RCSID +static char RcsId[] = "@(#)$Revision$"; +#endif + +/* $Id$ */ + +/*LINTLIBRARY */ +/*+ + FILE + H5Osdim.c + HDF5 Simple Dimensionality Object Header Message routines + + EXPORTED ROUTINES + + LIBRARY-SCOPED ROUTINES + + LOCAL ROUTINES + + */ + +#include <H5private.h> +#include <H5Eprivate.h> +#include <H5Gprivate.h> +#include <H5MMprivate.h> +#include <H5Oprivate.h> + +#define PABLO_MASK H5O_sim_dim_mask + +/* PRIVATE PROTOTYPES */ +static void *H5O_sim_dim_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p); +static herr_t H5O_sim_dim_encode (hdf5_file_t *f, size_t size, uint8 *p, + const void *_mesg); +static void *H5O_sim_dim_fast (const H5G_entry_t *ent, void *_mesg); +static hbool_t H5O_sim_dim_cache (H5G_entry_t *ent, const void *_mesg); +static void *H5O_sim_dim_copy (const void *_mesg, void *_dest); +static size_t H5O_sim_dim_size (hdf5_file_t *f, const void *_mesg); +static herr_t H5O_sim_dim_debug (hdf5_file_t *f, const void *_mesg, + FILE *stream, intn indent, intn fwidth); + +/* This message derives from H5O */ +const H5O_class_t H5O_SIM_DIM[1] = {{ + H5O_SIM_DIM_ID, /* message id number */ + "sim_dim", /* message name for debugging */ + sizeof (H5O_sim_dim_t), /* native message size */ + H5O_sim_dim_decode, /* decode message */ + H5O_sim_dim_encode, /* encode message */ + H5O_sim_dim_fast, /* get message from stab entry */ + H5O_sim_dim_cache, /* put message into stab entry */ + H5O_sim_dim_copy, /* copy the native value */ + H5O_sim_dim_size, /* size of symbol table entry */ + NULL, /* default reset method */ + H5O_sim_dim_debug, /* debug the message */ +}}; + +/* Is the interface initialized? */ +static hbool_t interface_initialize_g = FALSE; + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dim_decode + PURPOSE + Decode a simple dimensionality message and return a pointer to a memory + struct with the decoded information + USAGE + void *H5O_sim_dim_decode(f, raw_size, p) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + size_t raw_size; IN: size of the raw information buffer + const uint8 *p; IN: the raw information buffer + RETURNS + Pointer to the new message in native order on success, NULL on failure + DESCRIPTION + This function decodes the "raw" disk form of a simple dimensionality + message into a struct in memory native format. The struct is allocated + within this function using malloc() and is returned to the caller. +--------------------------------------------------------------------------*/ +static void * +H5O_sim_dim_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p) +{ + H5O_sim_dim_t *sdim=NULL; /* New simple dimensionality structure */ + uintn u; /* local counting variable */ + + FUNC_ENTER (H5O_sim_dim_decode, NULL, NULL); + + /* check args */ + assert (f); + assert (raw_size >= 8); /* at least the rank and flags must be present */ + assert (p); + + /* decode */ + if((sdim = H5MM_xcalloc (1, sizeof(H5O_sim_dim_t)))!=NULL) + { + UINT32DECODE(p,sdim->rank); + UINT32DECODE(p,sdim->dim_flags); + if(sdim->rank>0) + { + sdim->size=H5MM_xmalloc(sizeof(uint32)*sdim->rank); + for(u=0; u<sdim->size; u++) + UINT32DECODE(p,sdim->size[u]); + if(sdim->dim_flags&0x01) + { + sdim->max=H5MM_xmalloc(sizeof(uint32)*sdim->rank); + for(u=0; u<sdim->size; u++) + UINT32DECODE(p,sdim->max[u]); + } /* end if */ + if(sdim->dim_flags&0x02) + { + sdim->perm=H5MM_xmalloc(sizeof(uint32)*sdim->rank); + for(u=0; u<sdim->size; u++) + UINT32DECODE(p,sdim->perm[u]); + } /* end if */ + } /* end if */ + } /* end if */ + +done: + if(sdim == NULL) + { /* Error condition cleanup */ + + } /* end if */ + + /* Normal function cleanup */ + + FUNC_LEAVE (sdim); +} /* end H5O_sim_dim_decode() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dim_encode + PURPOSE + Encode a simple dimensionality message + USAGE + herr_t H5O_sim_dim_encode(f, raw_size, p, mesg) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + size_t raw_size; IN: size of the raw information buffer + const uint8 *p; IN: the raw information buffer + const void *mesg; IN: Pointer to the simple dimensionality struct + RETURNS + SUCCEED/FAIL + DESCRIPTION + This function encodes the native memory form of the simple + dimensionality message in the "raw" disk form. +--------------------------------------------------------------------------*/ +static herr_t +H5O_sim_dim_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *mesg) +{ + const H5O_sim_dim_t *sdim = (const H5O_sim_dim_t *)mesg; + uintn u; /* Local counting variable */ + + FUNC_ENTER (H5O_sim_dim_encode, NULL, FAIL); + + /* check args */ + assert (f); + assert (raw_size >= 8); /* at least the rank & flags must be present */ + assert (p); + assert (sdtype); + + /* encode */ + UINT32ENCODE(p,sdim->rank); + UINT32ENCODE(p,sdim->dim_flags); + if(sdim->rank>0) + { + for(u=0; u<=sdim->rank; u++); + UINT32ENCODE(p,sdim->size[u]); + if(sdim->dim_flags&0x01) + { + for(u=0; u<=sdim->rank; u++); + UINT32ENCODE(p,sdim->max[u]); + } /* end if */ + } /* end if */ + + FUNC_LEAVE (SUCCEED); +} /* end H5O_sim_dtype_encode() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_fast + PURPOSE + Initializes a new simple datatype struct with info from a symbol table + entry. + USAGE + void *H5O_sim_dtype_fast(ent, mesg) + const H5G_entry_t *ent; IN: pointer to the symbol table entry + const void *mesg; IN: Pointer to the simple datatype struct + RETURNS + Pointer to the message structure (allocated if none is supplied) on success, + NULL on failure + DESCRIPTION + This function fills the native memory form of the simple datatype + message from a symbol-table entry cache fields. (This method is required + for simple datatypes, as they can be cached in the symbol-table entry) +--------------------------------------------------------------------------*/ +static void * +H5O_sim_dtype_fast (const H5G_entry_t *ent, void *mesg) +{ + H5O_sim_dtype_t *sdtype = (H5O_sim_dtype_t *)mesg; + const uint8 *p; + + FUNC_ENTER (H5O_sim_dtype_fast, NULL, NULL); + + /* check args */ + assert (ent); + + if (H5G_CACHED_SDATA==ent->type) + { + if (!sdtype) + if((sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)))!=NULL) + { + p=&(uint8 *)ent->cache.sdata.nt; + sdtype->length=*p++; + sdtype->arch=*p++; + UINT16DECODE(p,sdtype->type); + } /* end if */ + } /* end if */ + else + sdtype = NULL; + + FUNC_LEAVE (sdtype); +} /* end H5O_sim_dtype_fast() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_cache + PURPOSE + Copies a simple datatype message into the cache portion of a symbol table + entry. + USAGE + hbool_t H5O_sim_dtype_cache(ent, mesg) + const H5G_entry_t *ent; IN: Pointer to the symbol table entry + const void *mesg; IN: Pointer to the simple datatype struct + RETURNS + BTRUE if symbol-table modified, BFALSE if not modified, BFAIL on failure. + DESCRIPTION + This function is the opposite of the H5O_sim_dtype_fast method, it + copies a message into the cached portion of a symbol-table entry. (This + method is required for simple datatypes, as they can be cached in the + symbol-table entry) +--------------------------------------------------------------------------*/ +static hbool_t +H5O_sim_dtype_cache (H5G_entry_t *ent, const void *mesg) +{ + const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg; + const uint8 *p; + hbool_t modified = BFALSE; + + FUNC_ENTER (H5O_sim_dtype_cache, NULL, BFAIL); + + /* check args */ + assert (ent); + assert (sdtype); + + /* + * We do this in two steps so Purify doesn't complain about + * uninitialized memory reads even though they don't bother + * anything. + */ + p=(uint8 *)&(ent->cache.sdata); + if (H5G_CACHED_SDATA != ent->type) + { + modified = BTRUE; + ent->type = H5G_CACHED_SDATA; + *p++=sdtype->length; + *p++=sdtype->arch; + UINT16ENCODE(p,sdtype->type); + } /* end if */ + else + { + if(ent->cache.sdata.length= sdtype->length) + { + modified = BTRUE; + ent->cache.sdata.length = sdtype->length; + } /* end if */ + + if (ent->cache.sdata.arch != sdtype->arch) + { + modified = BTRUE; + ent->cache.sdata.arch = sdtype->arch; + } /* end if */ + + if (ent->cache.sdata.type != sdtype->type) + { + modified = BTRUE; + ent->cache.sdata.type = sdtype->type; + } /* end if */ + } /* end else */ + + FUNC_LEAVE (modified); +} /* end H5O_sim_dtype_cache() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_copy + PURPOSE + Copies a message from MESG to DEST, allocating DEST if necessary. + USAGE + void *H5O_sim_dtype_copy(mesg, dest) + const void *mesg; IN: Pointer to the source simple datatype struct + const void *dest; IN: Pointer to the destination simple datatype struct + RETURNS + Pointer to DEST on success, NULL on failure + DESCRIPTION + This function copies a native (memory) simple datatype message, + allocating the destination structure if necessary. +--------------------------------------------------------------------------*/ +static void * +H5O_sim_dtype_copy (const void *mesg, void *dest) +{ + const H5O_sim_dtype_t *src = (const H5O_sim_dtype_t *)mesg; + H5O_sim_dtype_t *dst = (H5O_sim_dtype_t *)dest; + + FUNC_ENTER (H5O_sim_dtype_copy, NULL, NULL); + + /* check args */ + assert (src); + if (!dst) dst = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)); + + /* copy */ + HDmempcy(dst,src,sizeof(H5O_sim_dtype_t)); + + FUNC_LEAVE ((void*)dst); +} /* end H5O_sim_dtype_copy() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_size + PURPOSE + Return the raw message size in bytes + USAGE + void *H5O_sim_dtype_copy(f, mesg) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + const void *mesg; IN: Pointer to the source simple datatype struct + RETURNS + Size of message on success, FAIL on failure + DESCRIPTION + This function returns the size of the raw simple datatype message on + success. (Not counting the message type or size fields, only the data + portion of the message). It doesn't take into account alignment. +--------------------------------------------------------------------------*/ +static size_t +H5O_sim_dtype_size (hdf5_file_t *f, const void *mesg) +{ + FUNC_ENTER (H5O_sim_dtype_size, NULL, FAIL); + FUNC_LEAVE (4); +} /* end H5O_sim_dtype_size() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_debug + PURPOSE + Prints debugging information for a simple datatype message + USAGE + void *H5O_sim_dtype_debug(f, mesg, stream, indent, fwidth) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + const void *mesg; IN: Pointer to the source simple datatype struct + FILE *stream; IN: Pointer to the stream for output data + intn indent; IN: Amount to indent information by + intn fwidth; IN: Field width (?) + RETURNS + SUCCEED/FAIL + DESCRIPTION + This function prints debugging output to the stream passed as a + parameter. +--------------------------------------------------------------------------*/ +static herr_t +H5O_sim_dtype_debug (hdf5_file_t *f, const void *mesg, FILE *stream, + intn indent, intn fwidth) +{ + const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg; + + FUNC_ENTER (H5O_sim_dtype_debug, NULL, FAIL); + + /* check args */ + assert (f); + assert (sdtype); + assert (stream); + assert (indent>=0); + assert (fwidth>=0); + + fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth, + "Length:", + (unsigned long)(sdtype->length)); + fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth, + "Architecture:", + (unsigned long)(sdtype->arch)); + fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth, + "Data-Type:", + (unsigned long)(sdtype->type)); + + FUNC_LEAVE (SUCCEED); +} /* end H5O_sim_dtype_debug() */ + diff --git a/src/H5Osdtyp.c b/src/H5Osdtyp.c new file mode 100644 index 0000000..3c881a1 --- /dev/null +++ b/src/H5Osdtyp.c @@ -0,0 +1,364 @@ +/**************************************************************************** +* NCSA HDF * +* Software Development Group * +* National Center for Supercomputing Applications * +* University of Illinois at Urbana-Champaign * +* 605 E. Springfield, Champaign IL 61820 * +* * +* For conditions of distribution and use, see the accompanying * +* hdf/COPYING file. * +* * +****************************************************************************/ + +#ifdef RCSID +static char RcsId[] = "@(#)$Revision$"; +#endif + +/* $Id$ */ + +/*LINTLIBRARY */ +/*+ + FILE + H5Osdtyp.c + HDF5 Simple Datatype Object Header Message routines + + EXPORTED ROUTINES + + LIBRARY-SCOPED ROUTINES + + LOCAL ROUTINES + + */ + +#include <H5private.h> +#include <H5Eprivate.h> +#include <H5Gprivate.h> +#include <H5MMprivate.h> +#include <H5Oprivate.h> + +#define PABLO_MASK H5O_sim_dtype_mask + +/* PRIVATE PROTOTYPES */ +static void *H5O_sim_dtype_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p); +static herr_t H5O_sim_dtype_encode (hdf5_file_t *f, size_t size, uint8 *p, + const void *_mesg); +static void *H5O_sim_dtype_fast (const H5G_entry_t *ent, void *_mesg); +static hbool_t H5O_sim_dtype_cache (H5G_entry_t *ent, const void *_mesg); +static void *H5O_sim_dtype_copy (const void *_mesg, void *_dest); +static size_t H5O_sim_dtype_size (hdf5_file_t *f, const void *_mesg); +static herr_t H5O_sim_dtype_debug (hdf5_file_t *f, const void *_mesg, + FILE *stream, intn indent, intn fwidth); + +/* This message derives from H5O */ +const H5O_class_t H5O_SIM_DTYPE[1] = {{ + H5O_SIM_DTYPE_ID, /* message id number */ + "sim_dtype", /* message name for debugging */ + sizeof (H5O_sim_dtype_t), /* native message size */ + H5O_sim_dtype_decode, /* decode message */ + H5O_sim_dtype_encode, /* encode message */ + H5O_sim_dtype_fast, /* get message from stab entry */ + H5O_sim_dtype_cache, /* put message into stab entry */ + H5O_sim_dtype_copy, /* copy the native value */ + H5O_sim_dtype_size, /* size of symbol table entry */ + NULL, /* default reset method */ + H5O_sim_dtype_debug, /* debug the message */ +}}; + +/* Is the interface initialized? */ +static hbool_t interface_initialize_g = FALSE; + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_decode + PURPOSE + Decode a simple datatype message and return a pointer to a memory struct + with the decoded information + USAGE + void *H5O_sim_dtype_decode(f, raw_size, p) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + size_t raw_size; IN: size of the raw information buffer + const uint8 *p; IN: the raw information buffer + RETURNS + Pointer to the new message in native order on success, NULL on failure + DESCRIPTION + This function decodes the "raw" disk form of a simple datatype message + into a struct in memory native format. The struct is allocated within this + function using malloc() and is returned to the caller. +--------------------------------------------------------------------------*/ +static void * +H5O_sim_dtype_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p) +{ + H5O_sim_dtype_t *sdtype; + + FUNC_ENTER (H5O_sim_dtype_decode, NULL, NULL); + + /* check args */ + assert (f); + assert (raw_size == 4); + assert (p); + + /* decode */ + if((sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)))!=NULL) + { + sdtype->length=*p++; + sdtype->arch=*p++; + UINT16DECODE(p,sdtype->type); + } /* end if */ + + FUNC_LEAVE (sdtype); +} /* end H5O_sim_dtype_decode() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_encode + PURPOSE + Encode a simple datatype message + USAGE + herr_t H5O_sim_dtype_encode(f, raw_size, p, mesg) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + size_t raw_size; IN: size of the raw information buffer + const uint8 *p; IN: the raw information buffer + const void *mesg; IN: Pointer to the simple datatype struct + RETURNS + SUCCEED/FAIL + DESCRIPTION + This function encodes the native memory form of the simple datatype + message in the "raw" disk form. +--------------------------------------------------------------------------*/ +static herr_t +H5O_sim_dtype_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *mesg) +{ + const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg; + + FUNC_ENTER (H5O_sim_dtype_encode, NULL, FAIL); + + /* check args */ + assert (f); + assert (raw_size == 4); + assert (p); + assert (sdtype); + + /* encode */ + *p++=sdtype->length; + *p++=sdtype->arch; + UINT16ENCODE(p,sdtype->type); + + FUNC_LEAVE (SUCCEED); +} /* end H5O_sim_dtype_encode() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_fast + PURPOSE + Initializes a new simple datatype struct with info from a symbol table + entry. + USAGE + void *H5O_sim_dtype_fast(ent, mesg) + const H5G_entry_t *ent; IN: pointer to the symbol table entry + const void *mesg; IN: Pointer to the simple datatype struct + RETURNS + Pointer to the message structure (allocated if none is supplied) on success, + NULL on failure + DESCRIPTION + This function fills the native memory form of the simple datatype + message from a symbol-table entry cache fields. (This method is required + for simple datatypes, as they can be cached in the symbol-table entry) +--------------------------------------------------------------------------*/ +static void * +H5O_sim_dtype_fast (const H5G_entry_t *ent, void *mesg) +{ + H5O_sim_dtype_t *sdtype = (H5O_sim_dtype_t *)mesg; + const uint8 *p; + + FUNC_ENTER (H5O_sim_dtype_fast, NULL, NULL); + + /* check args */ + assert (ent); + + if (H5G_CACHED_SDATA==ent->type) + { + if (!sdtype) + if((sdtype = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)))!=NULL) + { + p=&(uint8 *)ent->cache.sdata.nt; + sdtype->length=*p++; + sdtype->arch=*p++; + UINT16DECODE(p,sdtype->type); + } /* end if */ + } /* end if */ + else + sdtype = NULL; + + FUNC_LEAVE (sdtype); +} /* end H5O_sim_dtype_fast() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_cache + PURPOSE + Copies a simple datatype message into the cache portion of a symbol table + entry. + USAGE + hbool_t H5O_sim_dtype_cache(ent, mesg) + const H5G_entry_t *ent; IN: Pointer to the symbol table entry + const void *mesg; IN: Pointer to the simple datatype struct + RETURNS + BTRUE if symbol-table modified, BFALSE if not modified, BFAIL on failure. + DESCRIPTION + This function is the opposite of the H5O_sim_dtype_fast method, it + copies a message into the cached portion of a symbol-table entry. (This + method is required for simple datatypes, as they can be cached in the + symbol-table entry) +--------------------------------------------------------------------------*/ +static hbool_t +H5O_sim_dtype_cache (H5G_entry_t *ent, const void *mesg) +{ + const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg; + const uint8 *p; + hbool_t modified = BFALSE; + + FUNC_ENTER (H5O_sim_dtype_cache, NULL, BFAIL); + + /* check args */ + assert (ent); + assert (sdtype); + + /* + * We do this in two steps so Purify doesn't complain about + * uninitialized memory reads even though they don't bother + * anything. + */ + p=(uint8 *)&(ent->cache.sdata); + if (H5G_CACHED_SDATA != ent->type) + { + modified = BTRUE; + ent->type = H5G_CACHED_SDATA; + *p++=sdtype->length; + *p++=sdtype->arch; + UINT16ENCODE(p,sdtype->type); + } /* end if */ + else + { + if(ent->cache.sdata.length= sdtype->length) + { + modified = BTRUE; + ent->cache.sdata.length = sdtype->length; + } /* end if */ + + if (ent->cache.sdata.arch != sdtype->arch) + { + modified = BTRUE; + ent->cache.sdata.arch = sdtype->arch; + } /* end if */ + + if (ent->cache.sdata.type != sdtype->type) + { + modified = BTRUE; + ent->cache.sdata.type = sdtype->type; + } /* end if */ + } /* end else */ + + FUNC_LEAVE (modified); +} /* end H5O_sim_dtype_cache() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_copy + PURPOSE + Copies a message from MESG to DEST, allocating DEST if necessary. + USAGE + void *H5O_sim_dtype_copy(mesg, dest) + const void *mesg; IN: Pointer to the source simple datatype struct + const void *dest; IN: Pointer to the destination simple datatype struct + RETURNS + Pointer to DEST on success, NULL on failure + DESCRIPTION + This function copies a native (memory) simple datatype message, + allocating the destination structure if necessary. +--------------------------------------------------------------------------*/ +static void * +H5O_sim_dtype_copy (const void *mesg, void *dest) +{ + const H5O_sim_dtype_t *src = (const H5O_sim_dtype_t *)mesg; + H5O_sim_dtype_t *dst = (H5O_sim_dtype_t *)dest; + + FUNC_ENTER (H5O_sim_dtype_copy, NULL, NULL); + + /* check args */ + assert (src); + if (!dst) dst = H5MM_xcalloc (1, sizeof(H5O_sim_dtype_t)); + + /* copy */ + HDmempcy(dst,src,sizeof(H5O_sim_dtype_t)); + + FUNC_LEAVE ((void*)dst); +} /* end H5O_sim_dtype_copy() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_size + PURPOSE + Return the raw message size in bytes + USAGE + void *H5O_sim_dtype_copy(f, mesg) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + const void *mesg; IN: Pointer to the source simple datatype struct + RETURNS + Size of message on success, FAIL on failure + DESCRIPTION + This function returns the size of the raw simple datatype message on + success. (Not counting the message type or size fields, only the data + portion of the message). It doesn't take into account alignment. +--------------------------------------------------------------------------*/ +static size_t +H5O_sim_dtype_size (hdf5_file_t *f, const void *mesg) +{ + FUNC_ENTER (H5O_sim_dtype_size, NULL, FAIL); + FUNC_LEAVE (4); +} /* end H5O_sim_dtype_size() */ + +/*-------------------------------------------------------------------------- + NAME + H5O_sim_dtype_debug + PURPOSE + Prints debugging information for a simple datatype message + USAGE + void *H5O_sim_dtype_debug(f, mesg, stream, indent, fwidth) + hdf5_file_t *f; IN: pointer to the HDF5 file struct + const void *mesg; IN: Pointer to the source simple datatype struct + FILE *stream; IN: Pointer to the stream for output data + intn indent; IN: Amount to indent information by + intn fwidth; IN: Field width (?) + RETURNS + SUCCEED/FAIL + DESCRIPTION + This function prints debugging output to the stream passed as a + parameter. +--------------------------------------------------------------------------*/ +static herr_t +H5O_sim_dtype_debug (hdf5_file_t *f, const void *mesg, FILE *stream, + intn indent, intn fwidth) +{ + const H5O_sim_dtype_t *sdtype = (const H5O_sim_dtype_t *)mesg; + + FUNC_ENTER (H5O_sim_dtype_debug, NULL, FAIL); + + /* check args */ + assert (f); + assert (sdtype); + assert (stream); + assert (indent>=0); + assert (fwidth>=0); + + fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth, + "Length:", + (unsigned long)(sdtype->length)); + fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth, + "Architecture:", + (unsigned long)(sdtype->arch)); + fprintf (stream, "%*s%-*s %lu\n", indent, "", fwidth, + "Data-Type:", + (unsigned long)(sdtype->type)); + + FUNC_LEAVE (SUCCEED); +} /* end H5O_sim_dtype_debug() */ + |