mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-31 17:10:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r146] ./src/H5.c

Browse Source 
Changes to error handling.

./src/H5B.c
	Increased size of internal static buffers.

./src/H5C.c
	Fixed syntax error when NDEBUG is defined.

./src/H5E.c
./src/H5Eprivate.h
./src/H5Epublic.h
	Errors can now be printed with H5Eprint().  Other minor
	changes to names and arg types.

./src/H5F.c
	The base address is now stored in the boot block.  The user
	block size and the base address are synonyms.

./src/H5Fstdio.c
	Fixed a bug with a return value from fseek().

./src/H5H.c
	Added alignment constraints to get rid of unaligned access
	errors on the DEC alpha having to do with the heap free list.

./src/H5P.c
./src/H5Ppublic.h
	Changed some size arguments from int to size_t and fixed
	memory allocation calls.

./src/H5T.c
./src/H5Tpublic.h
	Changed the order of functions so all the public ones are at
	the top of the file.  Other minor changes.

./src/H5detect.c
	Added a newline to a string constant.
This commit is contained in:
Robb Matzke 1997-12-16 16:08:26 -05:00
parent faca6fbaa8
commit e615fc7a98
15 changed files with 866 additions and 712 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/H5.c
View File

@ -189,7 +189,7 @@ herr_t H5_init_thread(void)
FUNC_ENTER_INIT (H5_init_thread, NULL, FAIL);
/* Create/initialize this thread's error stack */
if((thrderrid=H5Enew_err_stack(16))==FAIL)
if((H5E_thrdid_g=H5Ecreate(16))==FAIL)
HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL,
"unable to create thread error stack");
@ -222,7 +222,7 @@ herr_t H5_init_thread(void)
void
H5_term_thread (void)
{
H5Edelete_err_stack(thrderrid);
H5Eclose (H5E_thrdid_g);
} /* end H5_term_thread() */
/*--------------------------------------------------------------------------

2
src/H5B.c
View File

@ -762,7 +762,7 @@ herr_t
H5B_insert (H5F_t *f, const H5B_class_t *type, const haddr_t *addr,
void *udata)
{
uint8 lt_key[512], md_key[512], rt_key[512];
uint8 lt_key[1024], md_key[1024], rt_key[1024];
hbool_t lt_key_changed=FALSE, rt_key_changed=FALSE;
haddr_t child, old_root;
intn level;

5
src/H5C.c
View File

@ -269,7 +269,10 @@ H5Cget_class (hid_t template)
FUNC_ENTER (H5Cget_class, H5C_NO_CLASS);
if ((group = H5Aatom_group (template))<0 ||
group<H5_TEMPLATE_0 || group>=H5_TEMPLATE_MAX) {
#ifndef NDEBUG
group>=H5_TEMPLATE_MAX ||
#endif
group<H5_TEMPLATE_0) {
HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, H5C_NO_CLASS, "not a template");
}

2
src/H5Cpublic.h
View File

@ -60,7 +60,7 @@ typedef enum H5C_prop_t {
H5D_CHUNK_SIZE, /* Chunk size vector */
H5D_COMPRESS, /* Raw data compression */
H5D_PRE_OFFSET, /* Precompression offset */
H5D_PRE_SCALE, /* Precompression scale */
H5D_PRE_SCALE /* Precompression scale */
/* Dataset Transfer Properties */
/* None defined yet */

748
src/H5E.c
View File

@ -1,13 +1,22 @@
/****************************************************************************
* 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. *
* *
* 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. *
*
* Notes: It is safe to call HRETURN_ERROR(), HGOTO_ERROR(), HERROR(), and
* H5ECLEAR within any of these functions except H5E_push() (see
* comments in H5E_push()). However, some of the H5E API functions
* don't call H5ECLEAR the the error stack on which they're operating
* is the thread's global error stack. If the thread's global error
* stack isn't defined yet, then HRETURN_ERROR(), HGOTO_ERROR(), and
* HERROR() don't push an error message and H5ECLEAR just returns
* without doing anything.
* *
****************************************************************************/
#ifdef RCSID
@ -16,82 +25,65 @@ static char RcsId[] = "@(#)$Revision$";
/* $Id$ */
/*LINTLIBRARY */
/*+
FILE
hdf5err.c
HDF error reporting routines
EXPORTED ROUTINES
H5Enew_err_stack -- Create a new error stack to push values on
H5Epush -- Push an error value on an error stack
LIBRARY-SCOPED ROUTINES
LOCAL ROUTINES
H5E_init_interface -- initialize the H5E interface
+ */
#include <H5private.h> /* Generic Functions */
#include <H5Aprivate.h> /* Atoms */
#include <H5Eprivate.h> /* Private error routines */
#include <H5private.h> /* Generic Functions */
#include <H5Aprivate.h> /* Atoms */
#include <H5Eprivate.h> /* Private error routines */
#include <H5MMprivate.h> /* Memory management */
#define PABLO_MASK H5E_mask
/*-------------------- Locally scoped variables -----------------------------*/
static const hdf_maj_error_messages_t hdf_maj_error_messages[] =
{
{H5E_NONE_MAJOR, "No error"},
{H5E_ARGS, "Invalid arguments to routine"},
{H5E_RESOURCE, "Resource unavailable"},
{H5E_INTERNAL, "Internal HDF5 error (too specific to document in detail)"},
{H5E_FILE, "File Accessability"},
{H5E_IO, "Low-level I/O"},
{H5E_FUNC, "Function Entry/Exit"},
{H5E_ATOM, "Object Atom"},
static const H5E_major_mesg_t H5E_major_mesg_g[] = {
{H5E_NONE_MAJOR, "No error"},
{H5E_ARGS, "Invalid arguments to routine"},
{H5E_RESOURCE, "Resource unavailable"},
{H5E_INTERNAL, "Internal HDF5 error"},
{H5E_FILE, "File Accessability"},
{H5E_IO, "Low-level I/O"},
{H5E_FUNC, "Function Entry/Exit"},
{H5E_ATOM, "Object Atom"},
{H5E_CACHE, "Object Cache"},
{H5E_BTREE, "B-Tree Node"},
{H5E_SYM, "Symbol Table"},
{H5E_HEAP, "Heap"},
{H5E_OHDR, "Object Header"},
{H5E_DATATYPE, "Datatype"},
{H5E_DATATYPE, "Datatype"},
{H5E_DATASPACE, "Dataspace"},
{H5E_DATASET, "Dataset"},
{H5E_STORAGE, "Data Storage"},
{H5E_TEMPLATE, "Template"},
{H5E_DATASET, "Dataset"},
{H5E_STORAGE, "Data Storage"},
{H5E_TEMPLATE, "Template"},
};
static const hdf_min_error_messages_t hdf_min_error_messages[] =
{
{H5E_NONE_MINOR, "No error"},
static const H5E_minor_mesg_t H5E_minor_mesg_g[] = {
{H5E_NONE_MINOR, "No error"},
{H5E_UNINITIALIZED, "Information is uninitialized"},
{H5E_UNSUPPORTED, "Feature is unsupported"},
{H5E_BADTYPE, "Incorrect type found"},
{H5E_BADRANGE, "Argument out of range"},
{H5E_BADVALUE, "Bad value for argument"},
{H5E_NOSPACE, "No space available for allocation"},
{H5E_FILEEXISTS, "File already exists"},
{H5E_FILEOPEN, "File already open"},
{H5E_CANTCREATE, "Can't create file"},
{H5E_CANTOPENFILE, "Can't open file"},
{H5E_CANTOPENOBJ, "Can't open object"},
{H5E_NOTHDF5, "Not an HDF5 format file"},
{H5E_BADFILE, "Bad file ID accessed"},
{H5E_UNSUPPORTED, "Feature is unsupported"},
{H5E_BADTYPE, "Incorrect type found"},
{H5E_BADRANGE, "Argument out of range"},
{H5E_BADVALUE, "Bad value for argument"},
{H5E_NOSPACE, "No space available for allocation"},
{H5E_FILEEXISTS, "File already exists"},
{H5E_FILEOPEN, "File already open"},
{H5E_CANTCREATE, "Can't create file"},
{H5E_CANTOPENFILE, "Can't open file"},
{H5E_CANTOPENOBJ, "Can't open object"},
{H5E_NOTHDF5, "Not an HDF5 format file"},
{H5E_BADFILE, "Bad file ID accessed"},
{H5E_TRUNCATED, "File has been truncated"},
{H5E_SEEKERROR, "Seek failed"},
{H5E_READERROR, "Read failed"},
{H5E_WRITEERROR, "Write failed"},
{H5E_CLOSEERROR, "Close failed"},
{H5E_CANTINIT, "Can't initialize interface"},
{H5E_ALREADYINIT, "Object already initialized"},
{H5E_BADATOM, "Can't find atom information"},
{H5E_CANTREGISTER, "Can't register new atom"},
{H5E_SEEKERROR, "Seek failed"},
{H5E_READERROR, "Read failed"},
{H5E_WRITEERROR, "Write failed"},
{H5E_CLOSEERROR, "Close failed"},
{H5E_CANTINIT, "Can't initialize interface"},
{H5E_ALREADYINIT, "Object already initialized"},
{H5E_BADATOM, "Can't find atom information"},
{H5E_CANTREGISTER, "Can't register new atom"},
{H5E_CANTFLUSH, "Can't flush object from cache"},
{H5E_CANTLOAD, "Can't load object into cache"},
{H5E_PROTECT, "Protected object error"},
{H5E_NOTCACHED, "Object not currently cached"},
{H5E_NOTCACHED, "Object not currently cached"},
{H5E_NOTFOUND, "Object not found"},
{H5E_EXISTS, "Object already exists"},
{H5E_CANTENCODE, "Can't encode value"},
@ -104,7 +96,7 @@ static const hdf_min_error_messages_t hdf_min_error_messages[] =
{H5E_ALIGNMENT, "Alignment error"},
{H5E_BADMESG, "Unrecognized message"},
{H5E_COMPLEN, "Name component is too long"},
{H5E_CWG, "Problem with current working group"},
{H5E_CWG, "Problem with current working group"},
{H5E_LINK, "Link count failure"},
};
@ -112,9 +104,9 @@ static const hdf_min_error_messages_t hdf_min_error_messages[] =
static intn interface_initialize_g = FALSE;
#define INTERFACE_INIT H5E_init_interface
static herr_t H5E_init_interface(void);
static void H5E_term_interface (void);
int32 thrderrid; /* Thread-specific "global" error-handler ID */
hid_t H5E_thrdid_g = FAIL; /* Thread-specific "global" error-handler ID */
/*--------------------------------------------------------------------------
@ -133,17 +125,21 @@ Modifications:
Changed the pablo mask from H5_mask to H5E_mask
--------------------------------------------------------------------------*/
static herr_t H5E_init_interface(void)
static herr_t
H5E_init_interface (void)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER (H5E_init_interface, FAIL);
herr_t ret_value = SUCCEED;
FUNC_ENTER (H5E_init_interface, FAIL);
/* Initialize the atom group for the error stacks */
if((ret_value=H5Ainit_group(H5_ERR,H5A_ERRSTACK_HASHSIZE,0,NULL))!=FAIL)
ret_value=H5_add_exit(&H5E_term_interface);
/* Initialize the atom group for the error stacks */
if ((ret_value=H5Ainit_group (H5_ERR, H5A_ERRSTACK_HASHSIZE, 0,
(herr_t (*)(void*))H5E_close))!=FAIL) {
ret_value = H5_add_exit (H5E_term_interface);
}
FUNC_LEAVE(ret_value);
} /* H5E_init_interface */
FUNC_LEAVE (ret_value);
}
/*--------------------------------------------------------------------------
NAME
@ -162,17 +158,18 @@ static herr_t H5E_init_interface(void)
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
void H5E_term_interface (void)
static void
H5E_term_interface (void)
{
H5Adestroy_group(H5_ERR);
} /* end H5E_term_interface() */
H5Adestroy_group(H5_ERR);
}
/*--------------------------------------------------------------------------
NAME
H5Enew_err_stack -- Create a new error stack
H5Ecreate -- Create a new error stack
USAGE
int32 H5Enew_err_stack(initial_stack_size);
uintn initial_stack_size; IN: Starting size of the error stack
hid_t H5Ecreate (initial_stack_size);
uintn initial_stack_size; IN: Starting size of the error stack
RETURNS
The ID of the error stack created on success, FAIL on failure.
@ -181,47 +178,42 @@ DESCRIPTION
Dynamically creates a new error stack to push error values onto.
--------------------------------------------------------------------------*/
int32 H5Enew_err_stack(uintn initial_stack_size)
hid_t
H5Ecreate (uintn initial_stack_nelmts)
{
H5E_errstack_t *new_stack=NULL; /* Pointer to the new error stack */
int32 ret_value = FAIL;
H5E_t *new_stack=NULL; /* Pointer to the new error stack */
hid_t ret_value = FAIL;
FUNC_ENTER(H5Enew_err_stack, FAIL);
FUNC_ENTER (H5Ecreate, FAIL);
H5ECLEAR;
/* Allocate the stack header */
if((new_stack=HDmalloc(sizeof(H5E_errstack_t)))==NULL)
HGOTO_DONE(FAIL);
/* check args */
initial_stack_nelmts = MAX (10, MIN (initial_stack_nelmts, 1000));
/* Initialize the stack header */
new_stack->stack_size=initial_stack_size;
new_stack->stack_top=0;
if((new_stack->err_stack=HDcalloc(initial_stack_size,sizeof(H5E_error_t)))==NULL)
{
HDfree(new_stack);
HGOTO_DONE(FAIL);
} /* end if */
new_stack->push=H5E_store; /* Set the default error handler */
/* Allocate the stack header */
new_stack = H5MM_xmalloc (sizeof(H5E_t));
/* Get an atom for the error stack */
ret_value=H5Aregister_atom(H5_ERR, new_stack);
/* Initialize the stack header */
new_stack->nelmts = initial_stack_nelmts;
new_stack->top = 0;
new_stack->stack = H5MM_xcalloc (initial_stack_nelmts, sizeof(H5E_error_t));
new_stack->push = H5E_push; /* Set the default error handler */
done:
if(ret_value == FAIL)
{ /* Error condition cleanup */
/* Get an atom for the error stack */
if ((ret_value = H5Aregister_atom (H5_ERR, new_stack))<0) {
HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
"unable to register error stack");
}
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(ret_value);
} /* H5Enew_err_stack */
FUNC_LEAVE (ret_value);
}
/*--------------------------------------------------------------------------
NAME
H5Edelete_err_stack -- Destroy an error stack
H5Eclose -- Destroy an error stack
USAGE
intn H5Edelete_err_stack(err_stack);
int32 err_stack; IN: Error stack to delete
herr_t H5Eclose (err_stack);
hid_t err_stack; IN: Error stack to delete
RETURNS
SUCCEED/FAIL
@ -230,51 +222,108 @@ DESCRIPTION
Destroys an error stack, releasing memory allocated, etc.
--------------------------------------------------------------------------*/
intn H5Edelete_err_stack(int32 err_stack)
herr_t
H5Eclose (hid_t estack_id)
{
H5E_errstack_t *old_stack=NULL; /* Pointer to the new error stack */
intn ret_value = SUCCEED;
FUNC_ENTER (H5Eclose, FAIL);
H5ECLEAR;
FUNC_ENTER(H5Edelete_err_stack, FAIL);
/* check args */
if (H5_ERR!=H5Aatom_group (estack_id)) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an error stack");
}
/* Clear errors and check args and all the boring stuff. */
if (H5Aatom_group(err_stack)!=H5_ERR)
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an error stack");
/*
* Decrement the reference count. When it reaches zero the error stack
* will be freed.
*/
H5A_dec_ref (estack_id);
/* Get the error stack to put the error on */
if((old_stack=H5Aremove_atom(err_stack))==NULL)
HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't remove atom");
FUNC_LEAVE (SUCCEED);
}
/* Clear the error descriptions and reset the stack top */
for(; old_stack->stack_top>0; old_stack->stack_top--)
{
if (old_stack->err_stack[old_stack->stack_top-1].desc)
{
HDfree(old_stack->err_stack[old_stack->stack_top-1].desc);
old_stack->err_stack[old_stack->stack_top-1].desc=NULL;
} /* end if */
} /* end if */
/*-------------------------------------------------------------------------
* Function: H5Epush
*
* Purpose: Pushes a new error record onto error stack ESTACK_ID. The
* error has major and minor numbers MAJ_NUM and MIN_NUM, the
* name of a function where the error was detected, the name of
* the file where the error was detected, and the line within
* that file. An error description string is also passed to
* this function.
*
* The FUNCTION_NAME is copied (and possibly truncated) into a
* fixed length character buffer; the FILE_NAME is pointed to
* without copying it (we assume it's statically allocated from
* __FILE__); and the DESC argument is strdup'd.
*
* It is safe to call this function before the thread global
* error stack is initialized.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, December 12, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5Epush (hid_t estack_id, H5E_major_t maj_num, H5E_minor_t min_num,
const char *function_name, const char *file_name, intn line,
const char *desc)
{
H5E_t *estack = NULL; /* Ptr to the stack to put value on */
HDfree(old_stack->err_stack);
HDfree(old_stack);
/*
* WARNING WARNING WARNING: We cannot call HERROR() from within this
* function if ESTACK_ID is the thread global error stack or else we may
* enter infinite recursion. Furthermore, we also cannot call any other
* HDF5 macro or function which might call HERROR(). HERROR() is called
* by HRETURN_ERROR() which could be called by FUNC_ENTER().
*/
/*
* Clear the thread global error stack only if it isn't the error stack on
* which we're pushing the new error.
*/
if (estack_id!=H5E_thrdid_g) H5ECLEAR;
done:
if(ret_value == FAIL)
{ /* Error condition cleanup */
/*
* check args, but don't call error functions if ESTACK_ID is the thread
* global error handler.
*/
if (H5_ERR!=H5Aatom_group (estack_id) ||
NULL==(estack=H5Aatom_object (estack_id))) {
HRETURN (FAIL);
}
if (!function_name || !file_name || !desc) {
HRETURN (FAIL);
}
if (!estack->push) {
HRETURN (FAIL);
}
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(ret_value);
} /* H5Edelete_err_stack */
/* Push the new error. It must be safe to call the push function. */
if ((estack->push)(estack, maj_num, min_num, function_name, file_name,
line, desc)<0) {
HRETURN (FAIL);
}
return SUCCEED; /*don't use FUNC_LEAVE() here*/
}
/*--------------------------------------------------------------------------
NAME
H5Eclear -- Clear an error stack for later error entries
USAGE
void H5Eclear(int32 err_hand)
int32 err_hand; IN: The ID of the error stack to push the error onto.
int32 err_hand; IN: The ID of the error stack to push the error onto.
RETURNS
SUCCEED/FAIL
@ -283,200 +332,275 @@ DESCRIPTION
--------------------------------------------------------------------------*/
herr_t
H5Eclear (int32 err_hand)
H5Eclear (hid_t estack_id)
{
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
herr_t ret_value = SUCCEED;
H5E_t *estack = NULL;
FUNC_ENTER (H5Eclear, FAIL);
FUNC_ENTER (H5Eclear, FAIL);
/* Get the error stack for this error handler, initialized earlier in H5Enew_err_stack */
if (H5Aatom_group(err_hand)!=H5_ERR)
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an error stack");
/*
* Normally we would clear the thread error stack since we're entering an
* API function, but we have to be careful here to not get into an
* infinite recursion.
*/
if (estack_id != H5E_thrdid_g) H5ECLEAR;
/* Get the error stack to put the error on */
if((err_stack=H5Aatom_object(err_hand))==NULL)
HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL, "not an error stack");
/* check args */
if (H5_ERR!=H5Aatom_group (estack_id) ||
NULL==(estack=H5Aatom_object (estack_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an error stack");
}
/* Clear the error descriptions and reset the stack top */
for(; err_stack->stack_top>0; err_stack->stack_top--)
{
if (err_stack->err_stack[err_stack->stack_top-1].desc)
{
HDfree(err_stack->err_stack[err_stack->stack_top-1].desc);
err_stack->err_stack[err_stack->stack_top-1].desc=NULL;
} /* end if */
} /* end if */
if (H5E_clear (estack)<0) {
HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL,
"unable to clear error stack");
}
done:
if(ret_value == FAIL)
{ /* Error condition cleanup */
FUNC_LEAVE (SUCCEED);
}
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE (ret_value);
} /* H5Eclear */
/*--------------------------------------------------------------------------
NAME
H5E_store -- Push an error value on an error stack
USAGE
void H5E_store(hdf_err_code_t err, const char *function_name, const char *file_name, intn line)
hdf_err_code_t err; IN: The error code which occurred.
const char *function_name; IN: Name of the function the error occurred within.
const char *file_name; IN: Name of the file the error occurred within.
intn line; IN: Line # in the file the error occurred on.
RETURNS
SUCCESS/FAIL
DESCRIPTION
Pushes an error onto an error stack for this thread. (This is the default
action when errors occur, but can be overridden by user's code)
--------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------
* Function: H5Eprint
*
* Purpose: Prints the current contents of error stack ESTACK_ID to the
* stream FILE.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, December 12, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5E_store(int32 errid, H5E_major_t maj, H5E_minor_t min, const char *function_name, const char *file_name, intn line)
H5Eprint (hid_t estack_id, FILE *file)
{
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5E_store, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5Eclear(errid);
/* Get the error stack to put the error on */
if((err_stack=H5Aatom_object(errid))==NULL)
HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL, "not an error stack");
/* Check if we need to expand the stack */
if(err_stack->stack_top>=err_stack->stack_size)
{
H5E_error_t *old_stack=err_stack->err_stack; /* in case realloc fails */
/* Ask for new stack that's twice as large */
if((err_stack->err_stack=HDrealloc(old_stack,2*err_stack->stack_size))==NULL)
{
err_stack->err_stack=old_stack;
HGOTO_DONE(FAIL);
} /* end if */
err_stack->stack_size *= 2; /* increase the size of the stack */
} /* end if */
/* Push the error onto the error stack */
err_stack->err_stack[err_stack->stack_top].maj=maj;
err_stack->err_stack[err_stack->stack_top].min=min;
HDstrncpy(err_stack->err_stack[err_stack->stack_top].function_name,function_name,MAX_FUNC_NAME_LEN);
err_stack->err_stack[err_stack->stack_top].file_name=file_name;
err_stack->err_stack[err_stack->stack_top].line=line;
/* Increment the top of the error stack */
err_stack->stack_top++;
done:
if(ret_value == FAIL)
{ /* Error condition cleanup */
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE (ret_value);
} /* H5E_store */
/*--------------------------------------------------------------------------
NAME
H5Epush -- Push an error value on an error stack
USAGE
void H5Epush(hdf_err_code_t err, const char *function_name, const char *file_name, intn line)
hdf_err_code_t err; IN: The error code which occurred.
const char *function_name; IN: Name of the function the error occurred within.
const char *file_name; IN: Name of the file the error occurred within.
intn line; IN: Line # in the file the error occurred on.
H5E_t *estack = NULL;
RETURNS
SUCCEED/FAIL
DESCRIPTION
Pushes an error onto an error stack for this thread.
FUNC_ENTER (H5Eprint, FAIL);
/*
* Don't clear the thread error stack if it's the one we're about to
* print.
*/
if (estack_id!=H5E_thrdid_g) H5ECLEAR;
--------------------------------------------------------------------------*/
/* check args */
if (H5_ERR!=H5Aatom_group (estack_id) ||
NULL==(estack=H5Aatom_object (estack_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an error stack");
}
if (!file) file = stderr;
/* print it */
if (H5E_print (estack, file)<0) {
HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL,
"can't print error stack");
}
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5E_close
*
* Purpose: Frees resources associated with an error stack.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, December 12, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5Epush(H5E_major_t maj, H5E_minor_t min, const char *function_name, const char *file_name, intn line)
H5E_close (H5E_t *estack)
{
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
herr_t ret_value = SUCCEED;
FUNC_ENTER (H5E_close, FAIL);
FUNC_ENTER(H5Epush, FAIL);
/* check args */
assert (estack);
/* Clear errors and check args and all the boring stuff. */
if (function_name==NULL || file_name==NULL || H5Aatom_group(thrderrid)!=H5_ERR)
HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "wrong arguments");
/* clear error stack, then free it */
H5E_clear (estack);
H5MM_xfree (estack->stack);
H5MM_xfree (estack);
/* Get the error stack to put the error on */
if((err_stack=H5Aatom_object(thrderrid))==NULL)
HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL, "not an error stack");
FUNC_LEAVE (SUCCEED);
}
(err_stack->push)(thrderrid, maj, min, function_name, file_name, line);
done:
if(ret_value == FAIL)
{ /* Error condition cleanup */
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE (ret_value);
} /* H5Epush */
#ifdef H5_ERROR_DEBUG
/*--------------------------------------------------------------------------
NAME
H5Eset_push -- Set the function to call when an error value is reported
USAGE
H5E_push_func_t H5Eset_push(H5E_push_func_t func)
H5E_push_func_t func; IN: New function to call when an error occurs.
/*-------------------------------------------------------------------------
* Function: H5E_clear
*
* Purpose: Clears an error stack but does not release the stack.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, December 12, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5E_clear (H5E_t *estack)
{
int i;
RETURNS
The function pointer to the previous error function on success, NULL on
failure.
DESCRIPTION
Changes the function which is called for errors on this thread. The thread
ID is implicit, ie. this function must be called within each thread whose
error function is to be changed.
FUNC_ENTER (H5E_clear, FAIL);
--------------------------------------------------------------------------*/
H5E_push_func_t H5Eset_push(H5E_push_func_t func)
/* check args */
assert (estack);
/* Clear the error descriptions and reset the stack top */
for (i=0; i<estack->top; i++) {
H5MM_xfree (estack->stack[i].desc);
estack->stack[i].desc = NULL;
}
estack->top = 0;
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5E_push
*
* Purpose: Push an error onto an error stack. The FUNCTION_NAME is
* copied (and possibly truncated) into the error record. The
* FILE_NAME pointer is used directly since we assume it came
* from the __FILE__ construct and is thus static data. The
* description, DESC, is strdup'd into the error record.
*
* Note: Warning: to prevent infinite recursivion this function must
* not call any other HDF5 function and especially not
* the HDF5 error handling macros.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, December 12, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5E_push (H5E_t *estack, H5E_major_t maj_num, H5E_minor_t min_num,
const char *function_name, const char *file_name, intn line,
const char *desc)
{
CONSTR(FUNC, "H5Eset_push"); /* For HERROR */
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
H5E_push_func_t ret_value = NULL;
FUNC_ENTER(H5Eset_push, NULL);
/* FUNC_ENTER (H5E_push, FAIL); -- can't do this here! */
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
if (func==NULL)
HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL);
/* check args */
assert (estack);
assert (function_name);
assert (file_name);
/* Get the error stack to put the error on */
if((err_stack=H5Aatom_object(thrderrid))==NULL)
HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, NULL);
/* Check if we need to expand the stack */
if (estack->top >= estack->nelmts) {
/*
* Ask for new stack that's twice as large. Do not use hdf5 functions
* to allocate the memory!
*/
estack->nelmts *= 2;
estack->stack = realloc (estack->stack,
estack->nelmts * sizeof(H5E_error_t));
assert (estack->stack);
}
/* Push the error onto the error stack */
estack->stack[estack->top].maj_num = maj_num;
estack->stack[estack->top].min_num = min_num;
HDstrncpy (estack->stack[estack->top].func_name, function_name,
MAX_FUNC_NAME);
estack->stack[estack->top].func_name[MAX_FUNC_NAME-1] = '\0';
estack->stack[estack->top].file_name = file_name;
estack->stack[estack->top].line = line;
ret_value=err_stack->push;
err_stack->push=func;
/* strdup the description but don't use H5MM_xstrdup() */
estack->stack[estack->top].desc = malloc (strlen (desc) + 1);
assert (estack->stack[estack->top].desc);
strcpy (estack->stack[estack->top].desc, desc);
done:
if(ret_value == NULL)
{ /* Error condition cleanup */
/* Increment the top of the error stack */
estack->top++;
} /* end if */
return SUCCEED; /*don't use FUNC_LEAVE() here*/
}
/* Normal function cleanup */
/*-------------------------------------------------------------------------
* Function: H5E_print
*
* Purpose: Prints an error stack ESTACK to the stream FILE.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, December 12, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5E_print (H5E_t *estack, FILE *file)
{
intn i, j;
const char *maj_str = NULL;
const char *min_str = NULL;
FUNC_ENTER (H5E_print, FAIL);
FUNC_LEAVE(ID_H5Eset_push, ret_value);
} /* H5Eset_push */
#endif /* H5_ERROR_DEBUG */
/* check args */
assert (estack);
assert (file);
if (0==estack->top) HRETURN (SUCCEED);
fprintf (file, "HDF5-DIAG: error stack:\n");
for (i=0; i<estack->top; i++) {
/* Find major and minor error strings */
for (j=0, maj_str="??"; j<NELMTS (H5E_major_mesg_g); j++) {
if (H5E_major_mesg_g[j].error_code==estack->stack[i].maj_num) {
maj_str = H5E_major_mesg_g[j].str;
break;
}
}
for (j=0, min_str="??"; j<NELMTS (H5E_minor_mesg_g); j++) {
if (H5E_minor_mesg_g[j].error_code==estack->stack[i].min_num) {
min_str = H5E_minor_mesg_g[j].str;
break;
}
}
/* Print error message */
fprintf (file, " #%03d: %s:%d in %s() error %02d/%02d: %s\n",
i, estack->stack[i].file_name, estack->stack[i].line,
estack->stack[i].func_name, estack->stack[i].maj_num,
estack->stack[i].min_num, estack->stack[i].desc);
fprintf (file, " %s (%s)\n", maj_str, min_str);
}
FUNC_LEAVE (SUCCEED);
}

86
src/H5Eprivate.h
View File

@ -36,7 +36,8 @@
Assume that func and file are both stored in static space, or at
least be not corrupted in the meanwhile. */
#define HERROR(maj, min, str) H5Epush(maj, min, FUNC, __FILE__, __LINE__)
#define HERROR(maj, min, str) H5Epush (H5E_thrdid_g, maj, min, \
FUNC, __FILE__, __LINE__, str)
/* HRETURN_ERROR macro, used to facilitate error reporting. Makes
same assumptions as HERROR. IN ADDITION, this macro causes
@ -76,62 +77,67 @@
This macro is just a wrapper to clear the error stack with the thread
error ID */
#define H5ECLEAR H5Eclear(thrderrid)
#define H5ECLEAR H5Eclear(H5E_thrdid_g)
/* Maximum length of function name to push onto error stack */
#define MAX_FUNC_NAME_LEN 32
#define MAX_FUNC_NAME 32
/*
* error_messages is the list of error messages in the system, kept as
* error_code-message pairs.
*/
typedef struct
{
H5E_major_t error_code;
const char *str;
}
hdf_maj_error_messages_t;
typedef struct H5E_major_mesg_t {
H5E_major_t error_code;
const char *str;
} H5E_major_mesg_t;
typedef struct H5E_minor_mesg_t {
H5E_minor_t error_code;
const char *str;
} H5E_minor_mesg_t;
typedef struct
{
H5E_minor_t error_code;
const char *str;
}
hdf_min_error_messages_t;
/* Function pointer to report errors through */
struct H5E_t; /*forward decl*/
typedef herr_t (*H5E_push_t)(struct H5E_t *estack, H5E_major_t maj_num,
H5E_minor_t min_num, const char *function_name,
const char *file_name, intn line,
const char *desc);
/* We use a stack to hold the errors plus we keep track of the function,
file and line where the error occurs. */
/*
* We use a stack to hold the errors plus we keep track of the function, file
* and line where the error occurs.
*/
/* the structure of the error stack element */
typedef struct error_t
{
H5E_major_t maj; /* Major error number */
H5E_minor_t min; /* Minor error number */
char function_name[MAX_FUNC_NAME_LEN]; /* function where error occur */
const char *file_name; /* file where error occur */
intn line; /* line in file where error occurs */
char *desc; /* optional supplied description */
}
H5E_error_t;
typedef struct H5E_error_t {
H5E_major_t maj_num; /* Major error number */
H5E_minor_t min_num; /* Minor error number */
char func_name[MAX_FUNC_NAME]; /* function where error occur */
const char *file_name; /* file where error occur */
intn line; /* line in file where error occurs */
char *desc; /* optional supplied description */
} H5E_error_t;
/* Structure to store error information for a thread */
typedef struct errstack_t
{
uintn stack_size; /* Number of elements allocated in the stack */
uintn stack_top; /* Offset of the next open stack element */
H5E_error_t *err_stack; /* Pointer to the error stack */
H5E_push_func_t push; /* Function to call when an error is to be reported */
} H5E_errstack_t;
typedef struct H5E_t {
uintn nelmts; /* Num elements allocated in the stack */
uintn top; /* Index of the next open stack element */
H5E_error_t *stack; /* Pointer to the error stack */
H5E_push_t push; /* Func that pushes new error on stack */
} H5E_t;
/* Private global variables in H5E.c */
extern int32 thrderrid; /* Thread-specific "global" error-handler ID */
extern hid_t H5E_thrdid_g; /* Thread-specific "global" error-handler ID */
extern hbool_t install_atexit; /* Whether to install the atexit routine */
/* Private functions in H5E.c */
herr_t H5E_store(int32 errid, H5E_major_t maj, H5E_minor_t min, const char *function_name, const char *file_name, intn line);
herr_t H5E_close (H5E_t *estack);
herr_t H5E_clear (H5E_t *estack);
herr_t H5E_print (H5E_t *estack, FILE *file);
herr_t H5E_push (H5E_t *estack, H5E_major_t maj_num, H5E_minor_t min_num,
const char *function_name, const char *file_name, intn line,
const char *desc);
#endif

24
src/H5Epublic.h
View File

@ -19,8 +19,11 @@
#ifndef _H5Epublic_H
#define _H5Epublic_H
#include <stdio.h> /*FILE arg of H5Eprint() */
/* Public headers needed by this file */
#include <H5public.h>
#include <H5Apublic.h>
/*
* Declare an enumerated type which holds all the valid major HDF error codes.
@ -114,25 +117,18 @@ typedef enum H5E_minor_t {
H5E_LINK /* Link count failure */
} H5E_minor_t;
/* Function pointer to report errors through */
typedef herr_t (*H5E_push_func_t)(int32 errid, H5E_major_t maj,
H5E_minor_t min, const char *function_name,
const char *file_name, intn line);
#ifdef __cplusplus
extern "C" {
#endif
/* Functions in H5E.c */
int32 H5Enew_err_stack (uintn initial_stack_size);
intn H5Edelete_err_stack (int32 err_hand);
#ifdef H5_ERROR_DEBUG
H5E_push_func_t H5Eset_push (H5E_push_func_t func);
#endif
herr_t H5Epush (H5E_major_t maj, H5E_minor_t min, const char *function_name,
const char *file_name, intn line);
herr_t H5Eclear(int32 err_hand);
void H5E_term_interface(void);
hid_t H5Ecreate (uintn initial_stack_nelmts);
herr_t H5Eclose (hid_t estack_id);
herr_t H5Epush (hid_t estack_id, H5E_major_t maj_num, H5E_minor_t min_num,
const char *function_name, const char *file_name, intn line,
const char *desc);
herr_t H5Eclear (hid_t estack_id);
herr_t H5Eprint (hid_t estack_id, FILE *file);
#ifdef __cplusplus
}

23
src/H5F.c
View File

@ -791,16 +791,6 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
HGOTO_ERROR (H5E_IO, H5E_READERROR, NULL, "can't read boot block");
}
/*
* All addresses are relative to a base address. Eventually, the base
* address will be able to be set independently of the boot block
* address, but for now, all addresses are relative to the beginning of
* the boot block. Anything before the base address is assumed to be
* user-defined data.
*/
f->shared->base_addr = f->shared->boot_addr;
f->shared->create_parms.userblock_size=f->shared->base_addr.offset;
/*
* Decode the fixed size part of the boot block. For each of the
* version parameters, check that the library is able to handle that
@ -879,9 +869,10 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
assert (p-buf == fixed_size);
/* Read the variable length part of the boot block... */
variable_size = H5F_SIZEOF_ADDR (f) + /*global small obj heap*/
variable_size = H5F_SIZEOF_ADDR (f) + /*base address*/
H5F_SIZEOF_ADDR (f) + /*global small obj heap*/
H5F_SIZEOF_ADDR (f) + /*global free list addr*/
H5F_SIZEOF_SIZE (f) + /*logical file size*/
H5F_SIZEOF_ADDR (f) + /*logical file size*/
H5G_SIZEOF_ENTRY (f);
assert (variable_size <= sizeof buf);
addr1 = f->shared->boot_addr;
@ -892,6 +883,7 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
}
p = buf;
H5F_addr_decode (f, &p, &(f->shared->base_addr));
H5F_addr_decode (f, &p, &(f->shared->smallobj_addr));
H5F_addr_decode (f, &p, &(f->shared->freespace_addr));
H5F_addr_decode (f, &p, &(f->shared->hdf5_eof));
@ -899,6 +891,12 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
"can't read root symbol entry");
}
/*
* The userdefined data is the area of the file before the base
* address.
*/
f->shared->create_parms.userblock_size=f->shared->base_addr.offset;
}
/*
@ -1205,6 +1203,7 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
UINT16ENCODE (p, f->shared->create_parms.sym_leaf_k);
UINT16ENCODE (p, f->shared->create_parms.btree_k[H5B_SNODE_ID]);
UINT32ENCODE (p, f->shared->consist_flags);
H5F_addr_encode (f, &p, &(f->shared->base_addr));
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));

2
src/H5Fstdio.c
View File

@ -103,7 +103,7 @@ H5F_stdio_open (const char *name, uintn flags, H5F_search_t *key/*out*/)
lf->u.stdio.op = H5F_OP_SEEK;
lf->u.stdio.cur = 0;
H5F_addr_reset (&(lf->eof));
if (fseek (lf->u.stdio.f, 0, SEEK_END)<=0) {
if (fseek (lf->u.stdio.f, 0, SEEK_END)<0) {
lf->u.stdio.op = H5F_OP_UNKNOWN;
} else {
H5F_addr_inc (&(lf->eof), ftell (lf->u.stdio.f));

35
src/H5H.c
View File

@ -27,6 +27,7 @@
#define H5H_FREE_NULL 1 /*end of free list on disk */
#define PABLO_MASK H5H_mask
#define H5H_ALIGN(X) (((X)+7)&~0x03) /*align on 8-byte boundary */
typedef struct H5H_free_t {
size_t offset; /*offset of free block */
@ -113,6 +114,7 @@ H5H_create (H5F_t *f, H5H_type_t heap_type, size_t size_hint,
if (size_hint && size_hint<H5H_SIZEOF_FREE(f)) {
size_hint = H5H_SIZEOF_FREE(f);
}
size_hint = H5H_ALIGN (size_hint);
/* allocate file version */
total_size = H5H_SIZEOF_HDR(f) + size_hint;
@ -547,7 +549,7 @@ H5H_insert (H5F_t *f, const haddr_t *addr, size_t buf_size, const void *buf)
H5H_t *heap=NULL;
H5H_free_t *fl=NULL, *max_fl=NULL;
size_t offset = 0;
size_t old_size, need_more;
size_t need_size, old_size, need_more;
hbool_t found;
#ifndef NDEBUG
static nmessages = 0;
@ -568,19 +570,26 @@ H5H_insert (H5F_t *f, const haddr_t *addr, size_t buf_size, const void *buf)
}
heap->dirty += 1;
/*
* In order to keep the free list descriptors aligned on word boundaries,
* whatever that might mean, we round the size up to the next multiple of
* a word.
*/
need_size = H5H_ALIGN (buf_size);
/*
* Look for a free slot large enough for this object and which would
* leave zero or at least H5G_SIZEOF_FREE bytes left over.
*/
for (fl=heap->freelist,found=FALSE; fl; fl=fl->next) {
if (fl->size>buf_size && fl->size-buf_size>=H5H_SIZEOF_FREE(f)) {
if (fl->size>need_size && fl->size-need_size>=H5H_SIZEOF_FREE(f)) {
/* a bigger free block was found */
offset = fl->offset;
fl->offset += buf_size;
fl->size -= buf_size;
fl->offset += need_size;
fl->size -= need_size;
found = TRUE;
break;
} else if (fl->size==buf_size) {
} else if (fl->size==need_size) {
/* free block of exact size found */
offset = fl->offset;
fl = H5H_remove_free (heap, fl);
@ -601,15 +610,15 @@ H5H_insert (H5F_t *f, const haddr_t *addr, size_t buf_size, const void *buf)
*/
if (!found) {
need_more = MAX3 (buf_size, heap->mem_alloc, H5H_SIZEOF_FREE(f));
need_more = MAX3 (need_size, heap->mem_alloc, H5H_SIZEOF_FREE(f));
if (max_fl && max_fl->offset+max_fl->size==heap->mem_alloc) {
/*
* Increase the size of the maximum free block.
*/
offset = max_fl->offset;
max_fl->offset += buf_size;
max_fl->size += need_more - buf_size;
max_fl->offset += need_size;
max_fl->size += need_more - need_size;
if (max_fl->size < H5H_SIZEOF_FREE(f)) {
#ifndef NDEBUG
@ -631,18 +640,18 @@ H5H_insert (H5F_t *f, const haddr_t *addr, size_t buf_size, const void *buf)
* take some space out of it right away.
*/
offset = heap->mem_alloc;
if (need_more-buf_size >= H5H_SIZEOF_FREE(f)) {
if (need_more-need_size >= H5H_SIZEOF_FREE(f)) {
fl = H5MM_xmalloc (sizeof(H5H_free_t));
fl->offset = heap->mem_alloc + buf_size;
fl->size = need_more - buf_size;
fl->offset = heap->mem_alloc + need_size;
fl->size = need_more - need_size;
fl->prev = NULL;
fl->next = heap->freelist;
if (heap->freelist) heap->freelist->prev = fl;
heap->freelist = fl;
#ifndef NDEBUG
} else if (need_more>buf_size) {
} else if (need_more>need_size) {
fprintf (stderr, "H5H_insert: lost %lu bytes at line %d\n",
(unsigned long)(need_more-buf_size), __LINE__);
(unsigned long)(need_more-need_size), __LINE__);
if (0==nmessages++) {
fprintf (stderr, "Messages from H5H_insert() will go away "
"when assertions are turned off.\n");

22
src/H5P.c
View File

@ -268,19 +268,22 @@ H5P_copy (const H5P_t *src)
case H5P_SIMPLE:
if (dst->u.simple.size) {
dst->u.simple.size = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn));
dst->u.simple.size = H5MM_xmalloc (dst->u.simple.rank *
sizeof(dst->u.simple.size[0]));
for (i=0; i<dst->u.simple.rank; i++) {
dst->u.simple.size[i] = src->u.simple.size[i];
}
}
if (dst->u.simple.max) {
dst->u.simple.max = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn));
dst->u.simple.max = H5MM_xmalloc (dst->u.simple.rank *
sizeof(dst->u.simple.max[0]));
for (i=0; i<dst->u.simple.rank; i++) {
dst->u.simple.max[i] = src->u.simple.max[i];
}
}
if (dst->u.simple.perm) {
dst->u.simple.perm = H5MM_xmalloc (dst->u.simple.rank * sizeof(intn));
dst->u.simple.perm = H5MM_xmalloc (dst->u.simple.rank *
sizeof(dst->u.simple.perm[0]));
for (i=0; i<dst->u.simple.rank; i++) {
dst->u.simple.perm[i] = src->u.simple.perm[i];
}
@ -811,7 +814,7 @@ done:
herr_t H5Pset_space(sid, rank, dims)
hid_t sid; IN: Dataspace object to query
intn rank; IN: # of dimensions for the dataspace
const intn *dims; IN: Size of each dimension for the dataspace
const size_t *dims; IN: Size of each dimension for the dataspace
RETURNS
SUCCEED/FAIL
DESCRIPTION
@ -823,7 +826,8 @@ done:
expand. Currently, only the first dimension in the array (the slowest) may
be unlimited in size.
--------------------------------------------------------------------------*/
herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims)
herr_t
H5Pset_space (hid_t sid, intn rank, const size_t *dims)
{
H5P_t *space=NULL; /* dataspace to modify */
intn u; /* local counting variable */
@ -886,8 +890,8 @@ herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims)
/* Set the rank and copy the dims */
space->u.simple.rank=rank;
space->u.simple.size = H5MM_xcalloc (sizeof(intn), rank);
HDmemcpy(space->u.simple.size,dims,sizeof(intn)*rank);
space->u.simple.size = H5MM_xcalloc (rank, sizeof(size_t));
HDmemcpy(space->u.simple.size,dims,sizeof(size_t)*rank);
/* check if there are unlimited dimensions and create the maximum dims array */
for(u=0; u<rank; u++)
@ -897,8 +901,8 @@ herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims)
HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
"unlimited dimensions not in the lowest "
"dimensionality");
space->u.simple.max = H5MM_xcalloc (sizeof(intn),rank);
HDmemcpy(space->u.simple.max,dims,sizeof(intn)*rank);
space->u.simple.max = H5MM_xcalloc (rank, sizeof(size_t));
HDmemcpy(space->u.simple.max,dims,sizeof(size_t)*rank);
space->u.simple.dim_flags|=H5P_VALID_MAX;
break;
} /* end if */

2
src/H5Ppublic.h
View File

@ -47,7 +47,7 @@ intn H5Pget_ndims (hid_t space_id);
intn H5Pget_dims (hid_t space_id, size_t dims[]);
hbool_t H5Pis_simple(hid_t space_id);
herr_t H5Pset_space(hid_t space_id, intn rank, const intn *dims);
herr_t H5Pset_space(hid_t space_id, intn rank, const size_t *dims);
#ifdef __cplusplus
}

617
src/H5T.c
View File

@ -139,74 +139,140 @@ H5Tcreate (H5T_class_t type, size_t size)
/*-------------------------------------------------------------------------
* Function: H5T_create
* Function: H5Tcopy
*
* Purpose: Creates a new data type and initializes it to reasonable
* values. The new data type is SIZE bytes and an instance of
* the class TYPE.
* Purpose: Copies a data type. The resulting data type is not locked.
* The data type should be closed when no longer needed by
* calling H5Tclose().
*
* Return: Success: Pointer to the new type.
* Return: Success: The ID of a new data type.
*
* Failure: NULL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, December 5, 1997
* Tuesday, December 9, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
H5T_t *
H5T_create (H5T_class_t type, size_t size)
hid_t
H5Tcopy (hid_t type_id)
{
H5T_t *dt = NULL;
H5T_t *new_dt = NULL;
hid_t ret_value = FAIL;
FUNC_ENTER (H5T_create, NULL);
FUNC_ENTER (H5Tcopy, FAIL);
H5ECLEAR;
assert (size>0);
switch (type) {
case H5T_FIXED:
/* Default type is a native `int' */
if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_INT)))) {
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL,
"can't derive type from native int");
}
break;
case H5T_FLOAT:
/* Default type is a native `double' */
if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_DOUBLE)))) {
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL,
"can't derive type from native double");
}
break;
case H5T_DATE:
case H5T_STRING:
case H5T_BITFIELD:
case H5T_OPAQUE:
assert ("not implemented yet" && 0);
HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, NULL,
"not implemented yet");
case H5T_COMPOUND:
dt = H5MM_xcalloc (1, sizeof(H5T_t));
dt->type = type;
break;
default:
HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, NULL,
"unknown data type class");
/* check args */
if (H5_DATATYPE!=H5Aatom_group (type_id) ||
NULL==(dt=H5Aatom_object (type_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
}
dt->size = size;
FUNC_LEAVE (dt);
/* copy */
if (NULL==(new_dt = H5T_copy (dt))) {
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't copy");
}
/* atomize result */
if ((ret_value=H5Aregister_atom (H5_DATATYPE, new_dt))<0) {
H5T_close (new_dt);
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
"can't register data type atom");
}
FUNC_LEAVE (ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5Tget_num_members
* Function: H5Tclose
*
* Purpose: Frees a data type and all associated memory.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Tuesday, December 9, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5Tclose (hid_t type_id)
{
H5T_t *dt = NULL;
FUNC_ENTER (H5Tclose, FAIL);
H5ECLEAR;
/* check args */
if (H5_DATATYPE!=H5Aatom_group (type_id) ||
NULL==(dt=H5Aatom_object (type_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
}
if (dt->locked) {
HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "predefined data type");
}
/* When the reference count reaches zero the resources are freed */
if (H5A_dec_ref (type_id)<0) {
HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
}
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5Tequal
*
* Purpose: Determines if two data types are equal.
*
* Return: Success: TRUE if equal, FALSE if unequal
*
* Failure: FAIL
*
* Errors:
*
* Programmer: Robb Matzke
* Wednesday, December 10, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
hbool_t
H5Tequal (hid_t type1_id, hid_t type2_id)
{
const H5T_t *dt1 = NULL;
const H5T_t *dt2 = NULL;
hbool_t ret_value = FAIL;
FUNC_ENTER (H5Tequal, FAIL);
/* check args */
if (H5_DATATYPE!=H5Aatom_group (type1_id) ||
NULL==(dt1=H5Aatom_object (type1_id)) ||
H5_DATATYPE!=H5Aatom_group (type2_id) ||
NULL==(dt2=H5Aatom_object (type2_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
}
ret_value = (0==H5T_cmp (dt1, dt2));
FUNC_LEAVE (ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5Tget_nmembers
*
* Purpose: Determines how many members compound data type TYPE_ID has.
*
@ -225,7 +291,7 @@ H5T_create (H5T_class_t type, size_t size)
*-------------------------------------------------------------------------
*/
intn
H5Tget_num_members (hid_t type_id)
H5Tget_nmembers (hid_t type_id)
{
H5T_t *dt = NULL;
@ -278,7 +344,6 @@ H5Tget_class (hid_t type_id)
FUNC_LEAVE (dt->type);
}
/*-------------------------------------------------------------------------
* Function: H5Tget_size
@ -319,36 +384,6 @@ H5Tget_size (hid_t type_id)
FUNC_LEAVE (size);
}
/*-------------------------------------------------------------------------
* Function: H5T_get_size
*
* Purpose: Determines the total size of a data type in bytes.
*
* Return: Success: Size of the data type in bytes. The size of
* the data type is the size of an instance of
* that data type.
*
* Failure: 0 (valid data types are never zero size)
*
* Programmer: Robb Matzke
* Tuesday, December 9, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
size_t
H5T_get_size (const H5T_t *dt)
{
FUNC_ENTER (H5T_get_size, 0);
/* check args */
assert (dt);
FUNC_LEAVE (dt->size);
}
/*-------------------------------------------------------------------------
* Function: H5Tinsert_member
@ -414,6 +449,205 @@ H5Tinsert_member (hid_t parent_id, const char *name, off_t offset,
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* API functions are above; library-private functions are below...
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* Function: H5T_create
*
* Purpose: Creates a new data type and initializes it to reasonable
* values. The new data type is SIZE bytes and an instance of
* the class TYPE.
*
* Return: Success: Pointer to the new type.
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Friday, December 5, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
H5T_t *
H5T_create (H5T_class_t type, size_t size)
{
H5T_t *dt = NULL;
FUNC_ENTER (H5T_create, NULL);
assert (size>0);
switch (type) {
case H5T_FIXED:
/* Default type is a native `int' */
if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_INT)))) {
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL,
"can't derive type from native int");
}
break;
case H5T_FLOAT:
/* Default type is a native `double' */
if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_DOUBLE)))) {
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL,
"can't derive type from native double");
}
break;
case H5T_DATE:
case H5T_STRING:
case H5T_BITFIELD:
case H5T_OPAQUE:
assert ("not implemented yet" && 0);
HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, NULL,
"not implemented yet");
case H5T_COMPOUND:
dt = H5MM_xcalloc (1, sizeof(H5T_t));
dt->type = type;
break;
default:
HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, NULL,
"unknown data type class");
}
dt->size = size;
FUNC_LEAVE (dt);
}
/*-------------------------------------------------------------------------
* Function: H5T_copy
*
* Purpose: Copies datatype OLD_DT. The resulting data type is not
* locked.
*
* Return: Success: Pointer to a new copy of the OLD_DT argument.
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Thursday, December 4, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
H5T_t *
H5T_copy (const H5T_t *old_dt)
{
H5T_t *new_dt = NULL;
intn i;
char *s;
FUNC_ENTER (H5T_copy, NULL);
/* check args */
assert (old_dt);
/* copy */
new_dt = H5MM_xcalloc (1, sizeof(H5T_t));
*new_dt = *old_dt;
new_dt->locked = FALSE;
if (H5T_COMPOUND==new_dt->type) {
new_dt->u.compnd.memb = H5MM_xmalloc (new_dt->u.compnd.nmembs *
sizeof(H5T_member_t));
HDmemcpy (new_dt->u.compnd.memb, old_dt->u.compnd.memb,
new_dt->u.compnd.nmembs * sizeof(H5T_member_t));
for (i=0; i<new_dt->u.compnd.nmembs; i++) {
s = new_dt->u.compnd.memb[i].name;
new_dt->u.compnd.memb[i].name = H5MM_xstrdup (s);
}
}
FUNC_LEAVE (new_dt);
}
/*-------------------------------------------------------------------------
* Function: H5T_close
*
* Purpose: Frees a data type and all associated memory.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Monday, December 8, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5T_close (H5T_t *dt)
{
intn i;
FUNC_ENTER (H5T_close, FAIL);
assert (dt);
assert (!dt->locked);
if (dt && H5T_COMPOUND==dt->type) {
for (i=0; i<dt->u.compnd.nmembs; i++) {
H5MM_xfree (dt->u.compnd.memb[i].name);
}
H5MM_xfree (dt->u.compnd.memb);
H5MM_xfree (dt);
} else if (dt) {
H5MM_xfree (dt);
}
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5T_get_size
*
* Purpose: Determines the total size of a data type in bytes.
*
* Return: Success: Size of the data type in bytes. The size of
* the data type is the size of an instance of
* that data type.
*
* Failure: 0 (valid data types are never zero size)
*
* Programmer: Robb Matzke
* Tuesday, December 9, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
size_t
H5T_get_size (const H5T_t *dt)
{
FUNC_ENTER (H5T_get_size, 0);
/* check args */
assert (dt);
FUNC_LEAVE (dt->size);
}
/*-------------------------------------------------------------------------
* Function: H5T_insert_member
@ -478,228 +712,6 @@ H5T_insert_member (H5T_t *parent, const char *name, off_t offset,
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5Tcopy
*
* Purpose: Copies a data type. The resulting data type is not locked.
*
* Return: Success: The ID of a new data type.
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Tuesday, December 9, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
hid_t
H5Tcopy (hid_t type_id)
{
H5T_t *dt = NULL;
H5T_t *new_dt = NULL;
hid_t ret_value = FAIL;
FUNC_ENTER (H5Tcopy, FAIL);
H5ECLEAR;
/* check args */
if (H5_DATATYPE!=H5Aatom_group (type_id) ||
NULL==(dt=H5Aatom_object (type_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
}
/* copy */
if (NULL==(new_dt = H5T_copy (dt))) {
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't copy");
}
/* atomize result */
if ((ret_value=H5Aregister_atom (H5_DATATYPE, new_dt))<0) {
H5T_close (new_dt);
HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
"can't register data type atom");
}
FUNC_LEAVE (ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5T_copy
*
* Purpose: Copies datatype OLD_DT. The resulting data type is not
* locked.
*
* Return: Success: Pointer to a new copy of the OLD_DT argument.
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Thursday, December 4, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
H5T_t *
H5T_copy (const H5T_t *old_dt)
{
H5T_t *new_dt = NULL;
intn i;
char *s;
FUNC_ENTER (H5T_copy, NULL);
/* check args */
assert (old_dt);
/* copy */
new_dt = H5MM_xcalloc (1, sizeof(H5T_t));
*new_dt = *old_dt;
new_dt->locked = FALSE;
if (H5T_COMPOUND==new_dt->type) {
new_dt->u.compnd.memb = H5MM_xmalloc (new_dt->u.compnd.nmembs *
sizeof(H5T_member_t));
HDmemcpy (new_dt->u.compnd.memb, old_dt->u.compnd.memb,
new_dt->u.compnd.nmembs * sizeof(H5T_member_t));
for (i=0; i<new_dt->u.compnd.nmembs; i++) {
s = new_dt->u.compnd.memb[i].name;
new_dt->u.compnd.memb[i].name = H5MM_xstrdup (s);
}
}
FUNC_LEAVE (new_dt);
}
/*-------------------------------------------------------------------------
* Function: H5Tclose
*
* Purpose: Frees a data type and all associated memory.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Tuesday, December 9, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5Tclose (hid_t type_id)
{
H5T_t *dt = NULL;
FUNC_ENTER (H5Tclose, FAIL);
H5ECLEAR;
/* check args */
if (H5_DATATYPE!=H5Aatom_group (type_id) ||
NULL==(dt=H5Aatom_object (type_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
}
if (dt->locked) {
HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "predefined data type");
}
/* When the reference count reaches zero the resources are freed */
if (H5A_dec_ref (type_id)<0) {
HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
}
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5T_close
*
* Purpose: Frees a data type and all associated memory.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Monday, December 8, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5T_close (H5T_t *dt)
{
intn i;
FUNC_ENTER (H5T_close, FAIL);
assert (dt);
assert (!dt->locked);
if (dt && H5T_COMPOUND==dt->type) {
for (i=0; i<dt->u.compnd.nmembs; i++) {
H5MM_xfree (dt->u.compnd.memb[i].name);
}
H5MM_xfree (dt->u.compnd.memb);
H5MM_xfree (dt);
} else if (dt) {
H5MM_xfree (dt);
}
FUNC_LEAVE (SUCCEED);
}
/*-------------------------------------------------------------------------
* Function: H5Tequal
*
* Purpose: Determines if two data types are equal.
*
* Return: Success: TRUE if equal, FALSE if unequal
*
* Failure: FAIL
*
* Errors:
*
* Programmer: Robb Matzke
* Wednesday, December 10, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
hbool_t
H5Tequal (hid_t type1_id, hid_t type2_id)
{
const H5T_t *dt1 = NULL;
const H5T_t *dt2 = NULL;
hbool_t ret_value = FAIL;
FUNC_ENTER (H5Tequal, FAIL);
/* check args */
if (H5_DATATYPE!=H5Aatom_group (type1_id) ||
NULL==(dt1=H5Aatom_object (type1_id)) ||
H5_DATATYPE!=H5Aatom_group (type2_id) ||
NULL==(dt2=H5Aatom_object (type2_id))) {
HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
}
ret_value = (0==H5T_cmp (dt1, dt2));
FUNC_LEAVE (ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5T_cmp
@ -778,6 +790,7 @@ H5T_cmp (const H5T_t *dt1, const H5T_t *dt2)
}
#ifndef NDEBUG
/* I don't quite trust the code above yet :-) --RPM */
for (i=0; i<dt1->u.compnd.nmembs; i++) {
assert (HDstrcmp (dt1->u.compnd.memb[idx1[i]].name,
dt1->u.compnd.memb[idx1[i+1]].name));

4
src/H5Tpublic.h
View File

@ -69,7 +69,7 @@ typedef enum H5T_cset_t {
typedef enum H5T_str_t {
H5T_STR_ERROR =-1, /*error */
H5T_STR_NULL =0, /*pad with null term like in C */
H5T_STR_SPACE =1, /*pad with spaces like in Fortran */
H5T_STR_SPACE =1 /*pad with spaces like in Fortran */
} H5T_str_t;
@ -101,7 +101,7 @@ hbool_t H5Tequal (hid_t type1_id, hid_t type2_id);
H5T_class_t H5Tget_class (hid_t type_id);
size_t H5Tget_size (hid_t type_id);
intn H5Tget_num_members (hid_t type_id);
intn H5Tget_nmembers (hid_t type_id);
herr_t H5Tinsert_member (hid_t parent_id, const char *name, off_t offset,
hid_t member_id);

2
src/H5detect.c
View File

@ -270,7 +270,7 @@ print_results (int nd, detected_t *d) {
/* Include files */
printf ("\
#define H5T_PACKAGE /*suppress error about including H5Tpkg.h*/
#define H5T_PACKAGE /*suppress error about including H5Tpkg.h*/\n\
\n\
#include <H5private.h>\n\
#include <H5Eprivate.h>\n\