summaryrefslogtreecommitdiffstats
path: root/src/H5Osdtyp.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/H5Osdtyp.c')
-rw-r--r--src/H5Osdtyp.c364
1 files changed, 364 insertions, 0 deletions
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() */
+