philipp/hdf5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
Added an `_g' to the end of library_initialize,
	thread_initialize, and interface_initialize to abide by the
	naming convention.  Removed setting of these variables from
	the various initialization functions since it happens in the
	FUNC_ENTER() macro now.

	Defined PABLO_MASK.

	Removed `CONSTR(FUNC,"function_name")' everywhere since it's
	handled by the various FUNC_ENTER macros.

	Fixed calls to FUNC_ENTER(), FUNC_LEAVE(), and HRETURN_ERROR()
	so they don't need so many arguments.

	Changed PABLO_TRACE_ON() to FUNC_ENTER() since there is no
	longer any danger of infinite recursion.

	H5_term_library() now returns SUCCEED/FAIL and uses
	FUNC_ENTER/FUNC_EXIT macros.

./src/H5A.c
	Changes similar to H5.c.

	Most (all?) of the functions called PABLO_TRACE_ON() and the
	package doesn't have an interface initializer that I can see,
	so the second argument to FUNC_ENTER() is always NULL.

	H5A_release_atom_node() returns SUCCEED/FAIL.

./src/H5AC.c
	Added error handling.

	Arguments for internal functions are checked with assert().

./src/H5C.c
	Changes similar to H5.c

	Fixed the FUNC variable in H5C_get_default_atom() since it was
	initialized to the wrong name.

./src/H5D.c
	Changes similar to H5.c

./src/H5E.c
	Changes similar to H5.c

	Changed the pablo mask from H5_mask to H5E_mask in
	H5E_init_interface().

	H5Eclear(), H5E_store(), and H5Epush() return SUCCEED/FAIL.
	Changed PABLO_TRACE_OFF() calls to FUNC_LEAVE() calls in the
	same functions.

./src/H5Eprivate.h
./src/H5Eproto.h
	Added additional error symbols for the H5AC package.

	Changed prototypes for H5Eclear() and H5Epush().

	Changes to HRETURN_ERROR() and HGOTO_ERROR() to reduce the
	number of arguments.

./src/H5F.c
	Changes similr to H5.c

	Changed the pablo mask from H5_mask to H5F_mask for the
	FUNC_LEAVE() call of H5F_init_interface().

	Added FUNC_ENTER() and FUNC_LEAVE() calls to some functions
	that didn't have them.

./src/H5M.c
	Changes similar to H5.c

	Fixed the FUNC variable in H5M_init_interface() since it was
	initialized to the wrong name.

./src/H5P.c
	Changes similar to H5.c

./src/H5T.c
	Changes similar to H5.c

./src/hdf5gen.c
	Changes to FUNC_ENTER() and FUNC_EXIT() to reduce the number
	of arguments.  FUNC_ENTER() is now safe from infinite
	recursion since it updates the library_initialize_g,
	thread_initialize_g, or interface_initialize_g variables
	before calling the appropriate initialize function.
This commit is contained in:
Robb Matzke
1997-08-04 21:07:08 -05:00
parent 6a3cb617d3
commit e251f45b87
14 changed files with 432 additions and 411 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
src/H5.c
View File

@@ -44,10 +44,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5Bprivate.h" /*B-link trees */
#include "H5private.h" /* Generic info */
#define PABLO_MASK H5_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/*------------------_-- Local function prototypes ----------------------------*/
static herr_t H5_init_interface(void);
@@ -66,27 +68,14 @@ DESCRIPTION
--------------------------------------------------------------------------*/
herr_t H5_init_library(void)
{
CONSTR(FUNC, "H5_init_library"); /* For HERROR */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5_mask, ID_H5_init_library);
/* Don't call this routine again... */
library_initialize = TRUE;
FUNC_ENTER (H5_init_library, NULL, FAIL);
/* Install atexit() library cleanup routine */
if(install_atexit==TRUE)
if (HDatexit(&H5_term_library) != 0)
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL);
HRETURN_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL);
done:
if(ret_value == FAIL)
{ /* Error condition cleanup */
} /* end if */
FUNC_LEAVE(H5_mask, ID_H5_init_library,ret_value);
FUNC_LEAVE (SUCCEED);
} /* H5_init_library */
/*--------------------------------------------------------------------------
@@ -97,7 +86,7 @@ done:
USAGE
void HPend()
RETURNS
none
SUCCEED/FAIL
DESCRIPTION
Walk through the shutdown routines for the various interfaces and
terminate them all.
@@ -107,12 +96,9 @@ done:
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
void H5_term_library(void)
void
H5_term_library (void)
{
#ifdef LATER
CONSTR(FUNC, "H5_term_library"); /* for HERROR */
#endif /* LATER */
} /* end H5_term_library() */
/*--------------------------------------------------------------------------
@@ -129,23 +115,13 @@ DESCRIPTION
--------------------------------------------------------------------------*/
herr_t H5_init_thread(void)
{
#ifdef LATER
CONSTR(FUNC, "H5_init_thread"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5_mask, ID_H5_init_thread);
/* Don't call this routine again... */
thread_initialize = TRUE;
FUNC_ENTER (H5_init_thread, NULL, FAIL);
/* Create/initialize this thread's error stack */
if((thrderrid=H5Enew_err_stack(16))==FAIL)
ret_value=FAIL;
HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL);
FUNC_LEAVE(H5_mask, ID_H5_init_thread, ret_value);
FUNC_LEAVE (SUCCEED);
} /* H5_init_thread */
/*--------------------------------------------------------------------------
@@ -162,18 +138,9 @@ DESCRIPTION
--------------------------------------------------------------------------*/
static herr_t H5_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5_init_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
FUNC_ENTER (H5_init_interface, NULL, FAIL);
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5_mask, ID_H5_init_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_LEAVE(H5_mask, ID_H5_init_interface, ret_value);
FUNC_LEAVE (SUCCEED);
} /* H5_init_interface */
/*--------------------------------------------------------------------------
@@ -204,28 +171,12 @@ static herr_t H5_init_interface(void)
--------------------------------------------------------------------------*/
herr_t H5dont_atexit(void)
{
#ifdef LATER
CONSTR(FUNC, "H5dont_atexit"); /* for HERROR */
#endif /* LATER */
intn ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, we are trying to avoid certain initialization code */
PABLO_TRACE_ON(H5_mask, ID_H5dont_atexit);
FUNC_ENTER (H5dont_atexit, NULL, FAIL);
if(install_atexit == TRUE)
install_atexit=FALSE;
#ifdef LATER
done:
if(ret_value == FAIL)
{ /* Error condition cleanup */
} /* end if */
#endif /* LATER */
/* Normal function cleanup */
FUNC_LEAVE(H5_mask, ID_H5dont_atexit,ret_value);
FUNC_LEAVE (SUCCEED);
} /* end H5dont_atexit() */
/*--------------------------------------------------------------------------
@@ -246,10 +197,9 @@ DESCRIPTION
--------------------------------------------------------------------------*/
herr_t H5version(uintn *majnum, uintn *minnum, uintn *relnum, uintn *patnum)
{
CONSTR(FUNC, "H5version"); /* For HERROR */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5_mask, ID_H5version, H5_init_interface,FAIL);
FUNC_ENTER(H5version, H5_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -270,6 +220,6 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5_mask, ID_H5version, ret_value);
FUNC_LEAVE(ret_value);
} /* H5version */

92
src/H5A.c
View File

@@ -62,15 +62,20 @@ MODIFICATION HISTORY
#define HDF5_ATOM_MASTER
#include "hdf5.h"
#include "H5private.h"
#include "H5Aprivate.h"
#define PABLO_MASK H5A_mask
static int interface_initialize_g = FALSE;
/* Private function prototypes */
static atom_info_t *H5A_find_atom(hatom_t atm);
static atom_info_t *H5A_get_atom_node(void);
static void H5A_release_atom_node(atom_info_t *atm);
static herr_t H5A_release_atom_node(atom_info_t *atm);
/******************************************************************************
NAME
@@ -94,13 +99,10 @@ intn H5Ainit_group(group_t grp, /* IN: Group to initialize */
uintn reserved /* IN: Number of hash table entries to reserve */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Ainit_group"); /* for HERROR */
#endif /* LATER */
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
intn ret_value=SUCCEED;
PABLO_TRACE_ON(H5A_mask, ID_H5Ainit_group);
FUNC_ENTER (H5Ainit_group, NULL, FAIL);
if((grp<=BADGROUP || grp>=MAXGROUP) && hash_size>0)
HGOTO_DONE(FAIL);
@@ -158,7 +160,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Ainit_group, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Ainit_group() */
/******************************************************************************
@@ -178,13 +180,10 @@ done:
intn H5Adestroy_group(group_t grp /* IN: Group to destroy */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Adestroy_group"); /* for HERROR */
#endif /* LATER */
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
intn ret_value=SUCCEED;
PABLO_TRACE_ON(H5A_mask, ID_H5Adestroy_group);
FUNC_ENTER (H5Adestroy_group, NULL, FAIL);
if(grp<=BADGROUP || grp>=MAXGROUP)
HGOTO_DONE(FAIL);
@@ -221,7 +220,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Adestroy_group, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Adestroy_group() */
/******************************************************************************
@@ -244,16 +243,13 @@ hatom_t H5Aregister_atom(group_t grp, /* IN: Group to register the object in
const VOIDP object /* IN: Object to attach to atom */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Aregister_atom"); /* for HERROR */
#endif /* LATER */
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
atom_info_t *atm_ptr=NULL; /* ptr to the new atom */
hatom_t atm_id; /* new atom ID */
uintn hash_loc; /* new item's hash table location */
hatom_t ret_value=SUCCEED;
PABLO_TRACE_ON(H5A_mask, ID_H5Aregister_atom);
FUNC_ENTER (H5Aregister_atom, NULL, FAIL);
if(grp<=BADGROUP || grp>=MAXGROUP)
HGOTO_DONE(FAIL);
@@ -324,7 +320,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Aregister_atom, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Aregister_atom() */
/******************************************************************************
@@ -341,16 +337,13 @@ done:
VOIDP H5Aatom_object(hatom_t atm /* IN: Atom to retrieve object for */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Aatom_object"); /* for HERROR */
#endif /* LATER */
#ifdef ATOMS_ARE_CACHED
uintn i; /* local counter */
#endif /* ATOMS_ARE_CACHED */
atom_info_t *atm_ptr=NULL; /* ptr to the new atom */
VOIDP ret_value=NULL;
PABLO_TRACE_ON(H5A_mask, ID_H5Aatom_object);
FUNC_ENTER (H5Aatom_object, NULL, NULL);
#ifdef ATOMS_ARE_CACHED
/* Look for the atom in the cache first */
@@ -387,7 +380,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Aatom_object, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Aatom_object() */
/******************************************************************************
@@ -404,12 +397,9 @@ done:
group_t H5Aatom_group(hatom_t atm /* IN: Atom to retrieve group for */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Aatom_group"); /* for HERROR */
#endif /* LATER */
group_t ret_value=BADGROUP;
PABLO_TRACE_ON(H5A_mask, ID_H5Aatom_group);
FUNC_ENTER (H5Aatom_group, NULL, FAIL);
ret_value=ATOM_TO_GROUP(atm);
if(ret_value<=BADGROUP || ret_value>=MAXGROUP)
@@ -422,7 +412,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Aatom_group, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Aatom_group() */
/******************************************************************************
@@ -439,9 +429,6 @@ done:
VOIDP H5Aremove_atom(hatom_t atm /* IN: Atom to remove */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Aremove_atom"); /* for HERROR */
#endif /* LATER */
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
atom_info_t *curr_atm, /* ptr to the current atom */
*last_atm; /* ptr to the last atom */
@@ -452,7 +439,7 @@ VOIDP H5Aremove_atom(hatom_t atm /* IN: Atom to remove */
#endif /* ATOMS_ARE_CACHED */
VOIDP ret_value=NULL;
PABLO_TRACE_ON(H5A_mask, ID_H5Aremove_atom);
FUNC_ENTER (H5Aremove_atom, NULL, NULL);
grp=ATOM_TO_GROUP(atm);
if(grp<=BADGROUP || grp>=MAXGROUP)
@@ -510,7 +497,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Aremove_atom, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Aremove_atom() */
/******************************************************************************
@@ -532,15 +519,12 @@ VOIDP H5Asearch_atom(group_t grp, /* IN: Group to search for the object i
const VOIDP key /* IN: pointer to key to compare against */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Asearch_atom"); /* for HERROR */
#endif /* LATER */
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
atom_info_t *atm_ptr=NULL; /* ptr to the new atom */
intn i; /* local counting variable */
VOIDP ret_value=NULL;
PABLO_TRACE_ON(H5A_mask, ID_H5Asearch_atom);
FUNC_ENTER (H5Asearch_atom, NULL, NULL);
if(grp<=BADGROUP || grp>=MAXGROUP)
HGOTO_DONE(NULL);
@@ -568,7 +552,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Asearch_atom, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Asearch_atom() */
/******************************************************************************
@@ -586,14 +570,11 @@ done:
intn H5Ais_reserved(hatom_t atm /* IN: Group to search for the object in */
)
{
#ifdef LATER
CONSTR(FUNC, "H5Ais_reserved"); /* for HERROR */
#endif /* LATER */
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
group_t grp; /* atom's atomic group */
hbool_t ret_value=BFAIL;
PABLO_TRACE_ON(H5A_mask, ID_H5Ais_reserved);
FUNC_ENTER (H5Ais_reserved, NULL, FAIL);
grp=ATOM_TO_GROUP(atm);
if(grp<=BADGROUP || grp>=MAXGROUP)
@@ -616,7 +597,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5A_mask, ID_H5Ais_reserved, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Ais_reserved() */
/******************************************************************************
@@ -633,15 +614,13 @@ done:
static atom_info_t *H5A_find_atom(hatom_t atm /* IN: Atom to retrieve atom for */
)
{
#ifdef LATER
CONSTR(FUNC, "H5A_find_atom"); /* for HERROR */
#endif /* LATER */
atom_group_t *grp_ptr=NULL; /* ptr to the atomic group */
atom_info_t *atm_ptr=NULL; /* ptr to the new atom */
group_t grp; /* atom's atomic group */
uintn hash_loc; /* atom's hash table location */
atom_info_t *ret_value=NULL;
FUNC_ENTER (H5A_find_atom, NULL, NULL);
grp=ATOM_TO_GROUP(atm);
if(grp<=BADGROUP || grp>=MAXGROUP)
@@ -678,7 +657,7 @@ done:
/* Normal function cleanup */
return ret_value;
FUNC_LEAVE (ret_value);
} /* end H5A_find_atom() */
/******************************************************************************
@@ -695,11 +674,10 @@ done:
*******************************************************************************/
static atom_info_t *H5A_get_atom_node(void)
{
#ifdef LATER
CONSTR(FUNC, "H5A_get_atom_node"); /* for HERROR */
#endif /* LATER */
atom_info_t *ret_value=NULL;
FUNC_ENTER (H5A_get_atom_node, NULL, NULL);
if(atom_free_list!=NULL)
{
ret_value=atom_free_list;
@@ -719,7 +697,7 @@ done:
/* Normal function cleanup */
return ret_value;
FUNC_LEAVE (ret_value);
} /* end H5A_get_atom_node() */
/******************************************************************************
@@ -730,18 +708,19 @@ done:
Puts an atom node into the free list
RETURNS
No return value
SUCCEED
*******************************************************************************/
static void H5A_release_atom_node(atom_info_t *atm)
static herr_t
H5A_release_atom_node(atom_info_t *atm)
{
#ifdef LATER
CONSTR(FUNC, "H5A_release_atom_node"); /* for HERROR */
#endif /* LATER */
FUNC_ENTER (H5A_release_atom_node, NULL, FAIL);
/* Insert the atom at the beginning of the free list */
atm->next=atom_free_list;
atom_free_list=atm;
FUNC_LEAVE (SUCCEED);
} /* end H5A_release_atom_node() */
/*--------------------------------------------------------------------------
@@ -767,6 +746,8 @@ H5Ashutdown(void)
atom_info_t *curr;
intn i;
FUNC_ENTER (H5Ashutdown, NULL, FAIL);
/* Release the free-list if it exists */
if(atom_free_list!=NULL)
{
@@ -784,6 +765,7 @@ H5Ashutdown(void)
HDfree(atom_group_list[i]);
atom_group_list[i]=NULL;
} /* end if */
return (SUCCEED);
FUNC_LEAVE (SUCCEED);
} /* end H5Ashutdown() */

116
src/H5AC.c
View File

@@ -13,26 +13,34 @@
* with a particular HDF file share the same cache; each
* HDF file has it's own cache.
*
* Modifications:
* Modifications:
*
* Robb Matzke, 4 Aug 1997
* Added calls to H5E.
*
*-------------------------------------------------------------------------
*/
#include <assert.h>
#include "hdf5.h"
#include "H5private.h"
#include "H5ACprivate.h"
#include "H5MMprivate.h"
#define PABLO_MASK H5AC_mask
#define HASH(addr) ((unsigned)(addr) % H5AC_NSLOTS)
static int interface_initialize_g = FALSE; /*initialized?*/
/*-------------------------------------------------------------------------
* Function: H5AC_new
*
* Purpose: Initialize the cache just after a file is opened.
*
* Return: Success: 0
* Return: Success: SUCCEED
*
* Failure: -1
* Failure: FAIL
*
* Programmer: Robb Matzke
* robb@maya.nuance.com
@@ -45,8 +53,14 @@
herr_t
H5AC_new (hdf5_file_t *f)
{
f->cache = HDcalloc (H5AC_NSLOTS, sizeof (H5AC_cache_t));
return 0;
FUNC_ENTER (H5AC_new, NULL, FAIL);
assert (f);
assert (NULL==f->cache);
f->cache = H5MM_xcalloc (H5AC_NSLOTS, sizeof (H5AC_cache_t));
FUNC_LEAVE (SUCCEED);
}
@@ -55,9 +69,9 @@ H5AC_new (hdf5_file_t *f)
*
* Purpose: Flushes all data to disk and destroys the cache.
*
* Return: Success: 0
* Return: Success: SUCCEED
*
* Failure: -1
* Failure: FAIL
*
* Programmer: Robb Matzke
* robb@maya.nuance.com
@@ -70,9 +84,17 @@ H5AC_new (hdf5_file_t *f)
herr_t
H5AC_dest (hdf5_file_t *f)
{
if (H5AC_flush (f, NULL, 0, TRUE)<0) return -1;
HDfree (f->cache);
return 0;
FUNC_ENTER (H5AC_dest, NULL, FAIL);
assert (f);
assert (f->cache);
if (H5AC_flush (f, NULL, 0, TRUE)<0) {
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
}
f->cache = H5MM_xfree (f->cache);
FUNC_LEAVE (SUCCEED);
}
@@ -113,6 +135,10 @@ H5AC_find (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
void *thing = NULL;
herr_t (*flush)(hdf5_file_t*,hbool_t,haddr_t,void*)=NULL;
FUNC_ENTER (H5AC_find, NULL, NULL);
assert (f);
assert (f->cache);
assert (type);
assert (type->load);
assert (type->flush);
@@ -130,7 +156,7 @@ H5AC_find (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
*/
if (f->cache[idx].type && f->cache[idx].addr==addr &&
f->cache[idx].type!=type) {
return NULL;
HRETURN_ERROR (H5E_CACHE, H5E_BADTYPE, NULL);
}
/*
@@ -138,7 +164,7 @@ H5AC_find (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
* without preempting anything.
*/
if (NULL==(thing=(type->load)(f, addr, udata))) {
return NULL;
HRETURN_ERROR (H5E_CACHE, H5E_CANTLOAD, NULL);
}
/*
@@ -152,9 +178,10 @@ H5AC_find (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
* The old thing could not be removed from the stack.
* Release the new thing and fail.
*/
status = (type->flush)(f, TRUE, addr, thing);
assert (status>=0);
return NULL;
if ((type->flush)(f, TRUE, addr, thing)<0) {
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, NULL);
}
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, NULL);
}
}
@@ -165,7 +192,7 @@ H5AC_find (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
f->cache[idx].addr = addr;
f->cache[idx].thing = thing;
return thing;
FUNC_LEAVE (thing);
}
@@ -177,9 +204,9 @@ H5AC_find (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
* all types of entries are flushed. If the ADDR is zero then
* all entries of the specified type are flushed.
*
* Return: Success: 0
* Return: Success: SUCCEED
*
* Failure: -1
* Failure: FAIL
*
* Programmer: Robb Matzke
* robb@maya.nuance.com
@@ -197,6 +224,11 @@ H5AC_flush (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
herr_t status;
herr_t (*flush)(hdf5_file_t*,hbool_t,haddr_t,void*)=NULL;
FUNC_ENTER (H5AC_flush, NULL, FAIL);
assert (f);
assert (f->cache);
if (!type || 0==addr) {
/*
* Look at all cache entries.
@@ -208,7 +240,9 @@ H5AC_flush (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
flush = f->cache[i].type->flush;
status = (flush)(f, destroy, f->cache[i].addr,
f->cache[i].thing);
if (status<0) return -1;
if (status<0) {
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
}
if (destroy) f->cache[i].type = NULL;
}
}
@@ -219,11 +253,14 @@ H5AC_flush (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
*/
flush = f->cache[i].type->flush;
status = (flush) (f, destroy, f->cache[i].addr, f->cache[i].thing);
if (status<0) return -1;
if (status<0) {
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
}
if (destroy) f->cache[i].type = NULL;
}
return 0;
FUNC_LEAVE (SUCCEED);
}
@@ -234,9 +271,9 @@ H5AC_flush (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr,
* exist on disk yet, but it must have an address and disk
* space reserved.
*
* Return: Success: 0
* Return: Success: SUCCEED
*
* Failure: -1
* Failure: FAIL
*
* Programmer: Robb Matzke
* robb@maya.nuance.com
@@ -253,19 +290,28 @@ H5AC_set (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr, void *thing)
uintn idx = HASH (addr);
herr_t (*flush)(hdf5_file_t*,hbool_t,haddr_t,void*)=NULL;
FUNC_ENTER (H5AC_set, NULL, FAIL);
assert (f);
assert (f->cache);
assert (type);
assert (type->flush);
assert (addr>=0);
assert (thing);
if (f->cache[idx].type) {
flush = f->cache[idx].type->flush;
status = (flush)(f, TRUE, f->cache[idx].addr, f->cache[idx].thing);
if (status<0) return -1;
if (status<0) {
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
}
}
f->cache[idx].type = type;
f->cache[idx].addr = addr;
f->cache[idx].thing = thing;
return 0;
FUNC_LEAVE (SUCCEED);
}
@@ -275,9 +321,9 @@ H5AC_set (hdf5_file_t *f, const H5AC_class_t *type, haddr_t addr, void *thing)
* Purpose: Use this function to notify the cache that an object's
* file address changed.
*
* Return: Success: 0
* Return: Success: SUCCEED
*
* Failure: -1
* Failure: FAIL
*
* Programmer: Robb Matzke
* robb@maya.nuance.com
@@ -296,15 +342,21 @@ H5AC_rename (hdf5_file_t *f, const H5AC_class_t *type,
herr_t (*flush)(hdf5_file_t*, hbool_t, haddr_t, void*);
herr_t status;
FUNC_ENTER (H5AC_rename, NULL, FAIL);
assert (f);
assert (f->cache);
assert (type);
assert (old_addr>=0);
assert (new_addr>=0);
if (f->cache[old_idx].type!=type || f->cache[old_idx].addr!=old_addr) {
return 0; /*item not in cache*/
HRETURN (SUCCEED);
}
if (old_idx==new_idx) {
f->cache[old_idx].addr = new_addr;
return 0;
HRETURN (SUCCEED);
}
/*
@@ -314,7 +366,9 @@ H5AC_rename (hdf5_file_t *f, const H5AC_class_t *type,
flush = f->cache[new_idx].type->flush;
status = (flush)(f, TRUE, f->cache[new_idx].addr,
f->cache[new_idx].thing);
if (status<0) return -1;
if (status<0) {
HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
}
}
/*
@@ -325,6 +379,6 @@ H5AC_rename (hdf5_file_t *f, const H5AC_class_t *type,
f->cache[new_idx].thing = f->cache[old_idx].thing;
f->cache[old_idx].type = NULL;
return 0;
FUNC_LEAVE (SUCCEED);
}

57
src/H5C.c
View File

@@ -38,10 +38,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5private.h" /* Generic Functions */
#include "H5Cprivate.h" /* Template information */
#define PABLO_MASK H5C_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/* Define the library's default file creation template (constants in hdf5lims.h) */
const file_create_temp_t default_file_create={
@@ -74,21 +76,14 @@ DESCRIPTION
--------------------------------------------------------------------------*/
static herr_t H5C_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5C_init_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5C_mask, ID_H5C_init_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_ENTER (H5C_init_interface, NULL, FAIL);
/* Initialize the atom group for the file IDs */
ret_value=H5Ainit_group(H5_TEMPLATE,HDF5_TEMPID_HASHSIZE,0);
FUNC_LEAVE(H5C_mask, ID_H5C_init_interface, ret_value);
FUNC_LEAVE(ret_value);
} /* H5C_init_interface */
/*--------------------------------------------------------------------------
@@ -104,14 +99,18 @@ static herr_t H5C_init_interface(void)
success, FAIL on failure
DESCRIPTION
This is function retrieves atoms for the default templates for the
different types of HDF5 templates.
different types of HDF5 templates.
MODIFICATIONS
Robb Matzke, 4 Aug 1997
The `FUNC' auto variable was changed from `H5C_create' to
`H5C_get_default_atom'.
--------------------------------------------------------------------------*/
hatom_t H5C_get_default_atom(hobjtype_t type)
{
CONSTR(FUNC, "H5C_create"); /* for HERROR */
hatom_t ret_value = FAIL;
FUNC_ENTER(H5C_mask, ID_H5C_get_default_atom, H5C_init_interface, FAIL);
FUNC_ENTER(H5C_get_default_atom, H5C_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -139,7 +138,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5C_mask, ID_H5C_get_default_atom, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5C_get_default_atom() */
/*--------------------------------------------------------------------------
@@ -159,11 +158,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5C_init(hatom_t dst_atm, const file_create_temp_t *src)
{
CONSTR(FUNC, "H5C_init"); /* for HERROR */
file_create_temp_t *dst; /* destination template */
herr_t ret_value = SUCCEED; /* return value */
FUNC_ENTER(H5C_mask, ID_H5C_init, H5C_init_interface, FAIL);
FUNC_ENTER(H5C_init, H5C_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -185,7 +183,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5C_mask, ID_H5C_init, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5C_init() */
/*--------------------------------------------------------------------------
@@ -206,10 +204,9 @@ done:
--------------------------------------------------------------------------*/
hatom_t H5C_create(hatom_t owner_id, hobjtype_t type, const char *name)
{
CONSTR(FUNC, "H5C_create"); /* for HERROR */
hatom_t ret_value = FAIL; /* atom for template object to return */
FUNC_ENTER(H5C_mask, ID_H5C_create, H5C_init_interface, FAIL);
FUNC_ENTER(H5C_create, H5C_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -239,7 +236,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5C_mask, ID_H5C_create, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5C_create() */
/*--------------------------------------------------------------------------
@@ -257,11 +254,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5C_release(hatom_t oid)
{
CONSTR(FUNC, "H5C_release"); /* for HERROR */
file_create_temp_t *template; /* template to destroy */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5C_mask, ID_H5C_release, H5C_init_interface, FAIL);
FUNC_ENTER(H5C_release, H5C_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -279,7 +275,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5C_mask, ID_H5C_release, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5C_release() */
/*--------------------------------------------------------------------------
@@ -300,11 +296,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5Cgetparm(hatom_t tid, file_create_param_t parm, VOIDP buf)
{
CONSTR(FUNC, "H5Cgetparm"); /* for HERROR */
file_create_temp_t *template; /* template to query */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5C_mask, ID_H5Cgetparm, H5C_init_interface, FAIL);
FUNC_ENTER(H5Cgetparm, H5C_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -365,7 +360,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5C_mask, ID_H5Cgetparm, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Cgetparm() */
/*--------------------------------------------------------------------------
@@ -385,11 +380,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5Csetparm(hatom_t tid, file_create_param_t parm, const VOIDP buf)
{
CONSTR(FUNC, "H5Csetparm"); /* for HERROR */
file_create_temp_t *template; /* template to query */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5C_mask, ID_H5Csetparm, H5C_init_interface, FAIL);
FUNC_ENTER(H5Csetparm, H5C_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -450,7 +444,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5C_mask, ID_H5Csetparm, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Csetparm() */
/*--------------------------------------------------------------------------
@@ -469,11 +463,10 @@ done:
--------------------------------------------------------------------------*/
hatom_t H5C_copy(hatom_t tid)
{
CONSTR(FUNC, "H5C_copy"); /* for HERROR */
file_create_temp_t *template, *new_template; /* template to query */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5C_mask, ID_H5C_copy, H5C_init_interface, FAIL);
FUNC_ENTER(H5C_copy, H5C_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -501,6 +494,6 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5C_mask, ID_H5C_copy, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5C_copy() */

26
src/H5D.c
View File

@@ -36,10 +36,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5private.h" /* Generic Functions */
#include "H5Dprivate.h" /* Dataset functions */
#define PABLO_MASK H5D_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/*--------------------------------------------------------------------------
NAME
@@ -55,21 +57,13 @@ DESCRIPTION
--------------------------------------------------------------------------*/
static herr_t H5D_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5D_init_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5D_mask, ID_H5D_init_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_ENTER (H5D_init_interface, NULL, FAIL);
/* Initialize the atom group for the file IDs */
ret_value=H5Ainit_group(H5_DATASET,HDF5_DATASETID_HASHSIZE,H5D_RESERVED_ATOMS);
FUNC_LEAVE(H5D_mask, ID_H5D_init_interface, ret_value);
FUNC_LEAVE(ret_value);
} /* H5D_init_interface */
/*--------------------------------------------------------------------------
@@ -89,11 +83,10 @@ static herr_t H5D_init_interface(void)
--------------------------------------------------------------------------*/
hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name)
{
CONSTR(FUNC, "H5D_create"); /* for HERROR */
H5D_dataset_t *new_dataset; /* new dataset object to create */
hatom_t ret_value = SUCCEED;
FUNC_ENTER(H5D_mask, ID_H5D_create, H5D_init_interface, FAIL);
FUNC_ENTER(H5D_create, H5D_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -116,7 +109,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5D_mask, ID_H5D_create, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5D_create() */
/*--------------------------------------------------------------------------
@@ -134,11 +127,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5D_release(hatom_t oid)
{
CONSTR(FUNC, "H5D_release"); /* for HERROR */
H5D_dataset_t *dataset; /* dataset object to release */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5D_mask, ID_H5Drelease, H5D_init_interface, FAIL);
FUNC_ENTER(H5Drelease, H5D_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -156,7 +148,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5D_mask, ID_H5D_release, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5D_release() */

64
src/H5E.c
View File

@@ -39,10 +39,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5private.h" /* Generic Functions */
#define PABLO_MASK H5E_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/*------------------_-- Local function prototypes ----------------------------*/
static herr_t H5E_init_interface(void);
@@ -58,24 +60,20 @@ RETURNS
DESCRIPTION
Initializes any interface-specific data or routines.
Modifications:
Robb Matzke, 4 Aug 1997
Changed the pablo mask from H5_mask to H5E_mask
--------------------------------------------------------------------------*/
static herr_t H5E_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5E_init_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5_mask, ID_H5Iinit_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_ENTER (H5E_init_interface, NULL, FAIL);
/* Initialize the atom group for the error stacks */
ret_value=H5Ainit_group(H5_ERR,HDF5_ERRSTACK_HASHSIZE,0);
FUNC_LEAVE(H5_mask, ID_H5E_init_interface, ret_value);
FUNC_LEAVE(ret_value);
} /* H5E_init_interface */
/*--------------------------------------------------------------------------
@@ -94,11 +92,10 @@ DESCRIPTION
--------------------------------------------------------------------------*/
int32 H5Enew_err_stack(uintn initial_stack_size)
{
CONSTR(FUNC, "H5Enew_err_stack"); /* For HERROR */
H5E_errstack_t *new_stack=NULL; /* Pointer to the new error stack */
int32 ret_value = FAIL;
FUNC_ENTER(H5E_mask, ID_H5Enew_err_stack, H5E_init_interface,FAIL);
FUNC_ENTER(H5Enew_err_stack, H5E_init_interface,FAIL);
/* Allocate the stack header */
if((new_stack=HDmalloc(sizeof(H5E_errstack_t)))==NULL)
@@ -125,7 +122,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5E_mask, ID_H5Enew_err_stack, ret_value);
FUNC_LEAVE(ret_value);
} /* H5Enew_err_stack */
/*--------------------------------------------------------------------------
@@ -144,11 +141,10 @@ DESCRIPTION
--------------------------------------------------------------------------*/
intn H5Edelete_err_stack(int32 err_stack)
{
CONSTR(FUNC, "H5Edelete_err_stack"); /* For HERROR */
H5E_errstack_t *old_stack=NULL; /* Pointer to the new error stack */
intn ret_value = SUCCEED;
FUNC_ENTER(H5E_mask, ID_H5Edelete_err_stack, H5E_init_interface,FAIL);
FUNC_ENTER(H5Edelete_err_stack, H5E_init_interface,FAIL);
/* Clear errors and check args and all the boring stuff. */
if (H5Aatom_group(err_stack)!=H5_ERR)
@@ -179,7 +175,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5E_mask, ID_H5Edelete_err_stack, ret_value);
FUNC_LEAVE(ret_value);
} /* H5Edelete_err_stack */
/*--------------------------------------------------------------------------
@@ -190,18 +186,18 @@ USAGE
int32 err_hand; IN: The ID of the error stack to push the error onto.
RETURNS
none
SUCCEED/FAIL
DESCRIPTION
Clear an error stack to allow errors to be pushed onto it.
--------------------------------------------------------------------------*/
void H5Eclear(int32 err_hand)
herr_t
H5Eclear (int32 err_hand)
{
CONSTR(FUNC, "H5Eclear"); /* For HERROR */
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5E_mask, ID_H5Eclear, H5E_init_interface,FAIL);
FUNC_ENTER (H5Eclear, H5E_init_interface, FAIL);
/* Get the error stack for this error handler, initialized earlier in H5Enew_err_stack */
if (H5Aatom_group(err_hand)!=H5_ERR)
@@ -229,7 +225,7 @@ done:
/* Normal function cleanup */
PABLO_TRACE_OFF(H5E_mask, ID_H5Eclear); /* ignore ret_value set */
FUNC_LEAVE (ret_value);
} /* H5Eclear */
/*--------------------------------------------------------------------------
@@ -243,19 +239,19 @@ USAGE
intn line; IN: Line # in the file the error occurred on.
RETURNS
none
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)
--------------------------------------------------------------------------*/
void H5E_store(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line)
herr_t
H5E_store(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line)
{
CONSTR(FUNC, "H5E_store"); /* For HERROR */
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5E_mask, ID_H5E_store, H5E_init_interface,FAIL);
FUNC_ENTER(H5E_store, H5E_init_interface,FAIL);
/* Clear errors and check args and all the boring stuff. */
H5Eclear(errid);
@@ -296,7 +292,7 @@ done:
/* Normal function cleanup */
PABLO_TRACE_OFF(H5E_mask, ID_H5E_store); /* ignore ret_value set */
FUNC_LEAVE (ret_value);
} /* H5E_store */
/*--------------------------------------------------------------------------
@@ -310,18 +306,18 @@ USAGE
intn line; IN: Line # in the file the error occurred on.
RETURNS
none
SUCCEED/FAIL
DESCRIPTION
Pushes an error onto an error stack for this thread.
--------------------------------------------------------------------------*/
void H5Epush(hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line)
herr_t
H5Epush(hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line)
{
CONSTR(FUNC, "H5Epush"); /* For HERROR */
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5E_mask, ID_H5Epush, H5E_init_interface,FAIL);
FUNC_ENTER(H5Epush, H5E_init_interface,FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -342,7 +338,7 @@ done:
/* Normal function cleanup */
PABLO_TRACE_OFF(H5E_mask, ID_H5Epush); /* ignore ret_value set */
FUNC_LEAVE (ret_value);
} /* H5Epush */
#ifdef H5_ERROR_DEBUG
@@ -368,7 +364,7 @@ H5E_push_func_t H5Eset_push(H5E_push_func_t func)
H5E_errstack_t *err_stack=NULL; /* Pointer to the error stack to put value on */
H5E_push_func_t ret_value = NULL;
FUNC_ENTER(H5E_mask, ID_H5Eset_push, H5E_init_interface,NULL);
FUNC_ENTER(H5Eset_push, H5E_init_interface,NULL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -390,7 +386,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5E_mask, ID_H5Eset_push, ret_value);
FUNC_LEAVE(ID_H5Eset_push, ret_value);
} /* H5Eset_push */
#endif /* H5_ERROR_DEBUG */

7
src/H5Eprivate.h
View File

@@ -57,6 +57,7 @@ static const hdf_maj_error_messages_t hdf_maj_error_messages[] =
{H5E_IO, "Low-level I/O"},
{H5E_FUNC, "Function Entry/Exit"},
{H5E_ATOM, "Object Atom"},
{H5E_CACHE, "Object Cache"},
};
typedef struct
@@ -86,7 +87,9 @@ static const hdf_min_error_messages_t hdf_min_error_messages[] =
{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_CANTREGISTER, "Can't register new atom"},
{H5E_CANTFLUSH, "Can't flush object from cache"},
{H5E_CANTLOAD, "Can't load object into cache"},
};
/* We use a stack to hold the errors plus we keep track of the function,
@@ -121,7 +124,7 @@ extern "C"
#endif /* c_plusplus || __cplusplus */
/* Private functions in H5E.c */
void H5E_store(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
herr_t H5E_store(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
#if defined c_plusplus || defined __cplusplus
}

35
src/H5Eproto.h
View File

@@ -30,15 +30,29 @@
same assumptions as HERROR. IN ADDITION, this macro causes
a return from the calling routine */
#define HRETURN_ERROR(pablo_mask, pablo_func_id, maj, min, ret_val) {HERROR(maj, min); PABLO_TRACE_OFF(pablo_mask,pablo_func_id); return(ret_val);}
#define HRETURN_ERROR(maj, min, ret_val) { \
HERROR (maj, min); \
PABLO_TRACE_OFF (PABLO_MASK, pablo_func_id); \
return (ret_val); \
}
/* HRETURN macro, similar to HRETURN_ERROR() except for success */
#define HRETURN(ret_val) { \
PABLO_TRACE_OFF (PABLO_MASK, pablo_func_id); \
return (ret_val); \
}
/* HGOTO_ERROR macro, used to facilitate error reporting. Makes
same assumptions as HERROR. IN ADDITION, this macro causes
a jump to the label 'done' which should be in every fucntion
Also there is an assumption of a variable 'ret_value' */
#define HGOTO_ERROR(maj, min, ret_val) { HERROR(maj, min); \
ret_value = ret_val; goto done; }
#define HGOTO_ERROR(maj, min, ret_val) { \
HERROR (maj, min); \
ret_value = ret_val; \
goto done; \
}
/* HGOTO_DONE macro, used to facilitate the new error reporting model.
This macro is just a wrapper to set the return value and jump to the 'done'
@@ -62,7 +76,8 @@ typedef enum
H5E_FILE, /* File Accessability */
H5E_IO, /* Low-level I/O */
H5E_FUNC, /* Function Entry/Exit */
H5E_ATOM /* Object Atom */
H5E_ATOM, /* Object Atom */
H5E_CACHE /* Object Cache */
}
hdf_maj_err_code_t;
@@ -99,12 +114,16 @@ typedef enum
/* Object atom related errors */
H5E_BADATOM, /* Can't find atom information */
H5E_CANTREGISTER /* Can't register new atom */
H5E_CANTREGISTER, /* Can't register new atom */
/* Cache related errors */
H5E_CANTFLUSH, /* Can't flush object from cache */
H5E_CANTLOAD /* Can't load object into cache */
}
hdf_min_err_code_t;
/* Function pointer to report errors through */
typedef void (*H5E_push_func_t)(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
typedef herr_t (*H5E_push_func_t)(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
#if defined c_plusplus || defined __cplusplus
extern "C"
@@ -117,8 +136,8 @@ intn H5Edelete_err_stack(int32 err_hand);
#ifdef H5_ERROR_DEBUG
H5E_push_func_t H5Eset_push(H5E_push_func_t func);
#endif /* H5_ERROR_DEBUG */
void H5Epush(hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
void H5Eclear(int32 err_hand);
herr_t H5Epush(hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
herr_t H5Eclear(int32 err_hand);
#if defined c_plusplus || defined __cplusplus
}

128
src/H5F.c
View File

@@ -42,10 +42,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5Gprivate.h" /*symbol tables */
#include "H5MMprivate.h" /*core memory management */
#define PABLO_MASK H5F_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/*--------------------- Local function prototypes ----------------------------*/
static herr_t H5F_init_interface(void);
@@ -63,24 +65,21 @@ RETURNS
DESCRIPTION
Initializes any interface-specific data or routines.
Modifications:
Robb Matzke, 4 Aug 1997
Changed pablo mask from H5_mask to H5F_mask for the FUNC_LEAVE call.
It was already H5F_mask for the PABLO_TRACE_ON call.
--------------------------------------------------------------------------*/
static herr_t H5F_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5F_init_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5F_mask, ID_H5F_init_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_ENTER (H5F_init_interface, NULL, FAIL);
/* Initialize the atom group for the file IDs */
ret_value=H5Ainit_group(H5_FILE,HDF5_FILEID_HASHSIZE,0);
FUNC_LEAVE(H5_mask, ID_H5F_init_interface, ret_value);
FUNC_LEAVE(ret_value);
} /* H5F_init_interface */
#ifdef LATER
@@ -99,9 +98,6 @@ static herr_t H5F_init_interface(void)
--------------------------------------------------------------------------*/
void H5F_encode_length_unusual(const hdf5_file_t *f, uint8 **p, uint8 *l)
{
#ifdef LATER
CONSTR(FUNC, "H5F_encode_length_unusual");
#endif /* LATER */
intn i = H5F_SIZEOF_SIZE (f);
/* For non-little-endian platforms, encode each byte in memory backwards */
@@ -140,9 +136,6 @@ done:
--------------------------------------------------------------------------*/
void H5F_encode_offset_unusual(const hdf5_file_t *f, uint8 **p, uint8 *o)
{
#ifdef LATER
CONSTR(FUNC, "H5F_encode_offset_unusual");
#endif /* LATER */
intn i = H5F_SIZEOF_OFFSET(f);
/* For non-little-endian platforms, encode each byte in memory backwards */
@@ -180,24 +173,18 @@ done:
Look inside the file record for the atom API and compare the the
filenames.
--------------------------------------------------------------------------*/
intn H5F_compare_filename(const VOIDP obj, const VOIDP key)
intn
H5F_compare_filename (const VOIDP _obj, const VOIDP _key)
{
#ifdef LATER
CONSTR(FUNC, "H5F_compare_filename");
#endif /* LATER */
const hdf5_file_t *obj = (const hdf5_file_t *)_obj;
const char *key = (const char *)_key;
int ret_value = FALSE;
FUNC_ENTER (H5F_compare_filename, NULL, FALSE);
ret_value = !HDstrcmp (obj->filename, key);
#ifdef LATER
done:
if(ret_value == FALSE)
{ /* Error condition cleanup */
} /* end if */
#endif /* LATER */
/* Normal function cleanup */
return(!HDstrcmp(((const hdf5_file_t *)obj)->filename,(const char *)key));
FUNC_LEAVE (ret_value);
} /* H5F_compare_filename */
/*--------------------------------------------------------------------------
@@ -216,11 +203,10 @@ done:
--------------------------------------------------------------------------*/
hatom_t H5Fget_create_template(hatom_t fid)
{
CONSTR(FUNC, "H5Fget_create_template"); /* for HERROR */
hdf5_file_t *file=NULL; /* file struct for file to close */
hatom_t ret_value = FAIL;
FUNC_ENTER(H5F_mask, ID_H5Fget_create_template, H5F_init_interface, FAIL);
FUNC_ENTER(H5Fget_create_template, H5F_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -244,7 +230,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5F_mask, ID_H5Fget_create_template, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Fget_create_template() */
/*--------------------------------------------------------------------------
@@ -262,14 +248,13 @@ done:
--------------------------------------------------------------------------*/
hbool_t H5Fis_hdf5(const char *filename)
{
CONSTR(FUNC, "H5Fis_hdf5"); /* for HERROR */
hdf_file_t f_handle=H5F_INVALID_FILE; /* file handle */
uint8 temp_buf[HDF5_FILE_SIGNATURE_LEN]; /* temporary buffer for checking file signature */
haddr_t curr_off=0; /* The current offset to check in the file */
size_t file_len=0; /* The length of the file we are checking */
hbool_t ret_value = BFALSE;
FUNC_ENTER(H5F_mask, ID_H5Fis_hdf5, H5F_init_interface, BFAIL);
FUNC_ENTER(H5Fis_hdf5, H5F_init_interface, BFAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -317,7 +302,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5F_mask, ID_H5Fis_hdf5, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Fis_hdf5() */
@@ -419,7 +404,6 @@ H5F_dest (hdf5_file_t *f)
--------------------------------------------------------------------------*/
hatom_t H5Fcreate(const char *filename, uintn flags, hatom_t create_temp, hatom_t access_temp)
{
CONSTR(FUNC, "H5Fcreate"); /* for HERROR */
hdf5_file_t *new_file=NULL; /* file struct for new file */
hdf_file_t f_handle=H5F_INVALID_FILE; /* file handle */
const file_create_temp_t *f_create_parms; /* pointer to the parameters to use when creating the file */
@@ -427,7 +411,7 @@ hatom_t H5Fcreate(const char *filename, uintn flags, hatom_t create_temp, hatom_
intn file_exists=0; /* flag to indicate that file exists already */
hatom_t ret_value = FAIL;
FUNC_ENTER(H5F_mask, ID_H5Fcreate, H5F_init_interface, FAIL);
FUNC_ENTER(H5Fcreate, H5F_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -542,7 +526,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5F_mask, ID_H5Fcreate, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Fcreate() */
@@ -575,7 +559,6 @@ done:
--------------------------------------------------------------------------*/
hatom_t H5Fopen(const char *filename, uintn flags, hatom_t access_temp)
{
CONSTR(FUNC, "H5Fopen"); /* for HERROR */
hdf5_file_t *new_file=NULL; /* file struct for new file */
hdf_file_t f_handle=H5F_INVALID_FILE; /* file handle */
hatom_t create_temp; /* file-creation template ID */
@@ -586,7 +569,7 @@ hatom_t H5Fopen(const char *filename, uintn flags, hatom_t access_temp)
hatom_t ret_value = FAIL;
size_t variable_size; /*size of the variable part of the bb */
FUNC_ENTER(H5F_mask, ID_H5Fopen, H5F_init_interface, FAIL);
FUNC_ENTER(H5Fopen, H5F_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -723,7 +706,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5F_mask, ID_H5Fopen, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Fopen() */
/*--------------------------------------------------------------------------
@@ -747,11 +730,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5Fclose(hatom_t fid)
{
CONSTR(FUNC, "H5Fclose"); /* for HERROR */
hdf5_file_t *file=NULL; /* file struct for file to close */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5F_mask, ID_H5Fclose, H5F_init_interface, FAIL);
FUNC_ENTER(H5Fclose, H5F_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -782,7 +764,7 @@ done:
} /* end if */
/* Normal function cleanup */
FUNC_LEAVE(H5F_mask, ID_H5Fclose, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Fclose() */
@@ -792,9 +774,9 @@ done:
* Purpose: Reads some data from a file/server/etc into a buffer.
* The data is contiguous.
*
* Return: Success: 0
* Return: Success: SUCCEED
*
* Failure: -1
* Failure: FAIL
*
* Programmer: Robb Matzke
* robb@maya.nuance.com
@@ -807,19 +789,19 @@ done:
herr_t
H5F_block_read (hdf5_file_t *f, haddr_t addr, size_t size, void *buf)
{
CONSTR(FUNC, "H5F_block_read"); /* for HERROR */
FUNC_ENTER (H5F_block_read, NULL, FAIL);
PABLO_TRACE_ON(H5F_mask, ID_H5F_block_read);
if (0==size) return 0;
addr += f->file_create_parms.userblock_size;
if (0==size) return 0;
addr += f->file_create_parms.userblock_size;
if (H5F_SEEK (f->file_handle, addr)<0)
HRETURN_ERROR(H5F_mask, ID_H5F_block_read, H5E_IO, H5E_SEEKERROR, FAIL);
if (H5F_READ (f->file_handle, buf, size)<0)
HRETURN_ERROR(H5F_mask, ID_H5F_block_read, H5E_IO, H5E_READERROR, FAIL);
PABLO_TRACE_OFF(H5F_mask, ID_H5F_block_read);
return SUCCEED;
if (H5F_SEEK (f->file_handle, addr)<0) {
HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL);
}
if (H5F_READ (f->file_handle, buf, size)<0) {
HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL);
}
FUNC_LEAVE (SUCCEED);
}
@@ -829,9 +811,9 @@ H5F_block_read (hdf5_file_t *f, haddr_t addr, size_t size, void *buf)
* Purpose: Writes some data from memory to a file/server/etc. The
* data is contiguous.
*
* Return: Success: 0
* Return: Success: SUCCEED
*
* Failure: -1
* Failure: FAIL
*
* Programmer: Robb Matzke
* robb@maya.nuance.com
@@ -844,19 +826,19 @@ H5F_block_read (hdf5_file_t *f, haddr_t addr, size_t size, void *buf)
herr_t
H5F_block_write (hdf5_file_t *f, haddr_t addr, size_t size, void *buf)
{
CONSTR(FUNC, "H5F_block_write"); /* for HERROR */
PABLO_TRACE_ON(H5F_mask, ID_H5F_block_read);
FUNC_ENTER (H5F_block_write, NULL, FAIL);
if (0==size) return 0;
addr += f->file_create_parms.userblock_size;
if (0==size) return 0;
addr += f->file_create_parms.userblock_size;
if (H5F_SEEK (f->file_handle, addr)<0)
HRETURN_ERROR(H5F_mask, ID_H5F_block_write, H5E_IO, H5E_SEEKERROR, FAIL);
if (H5F_WRITE (f->file_handle, buf, size)<0)
HRETURN_ERROR(H5F_mask, ID_H5F_block_write, H5E_IO, H5E_WRITEERROR, FAIL);
PABLO_TRACE_OFF(H5F_mask, ID_H5F_block_write);
return SUCCEED;
if (H5F_SEEK (f->file_handle, addr)<0) {
HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL);
}
if (H5F_WRITE (f->file_handle, buf, size)<0) {
HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
}
FUNC_LEAVE (SUCCEED);
}

40
src/H5M.c
View File

@@ -40,10 +40,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5Mprivate.h" /* Meta-object interface */
#include "H5Cprivate.h" /* Template interface */
#define PABLO_MASK H5M_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/*------------------_-- Local function prototypes ----------------------------*/
static herr_t H5M_init_interface(void);
@@ -59,21 +61,17 @@ RETURNS
DESCRIPTION
Initializes any interface-specific data or routines.
MODIFICATIONS
Robb Matzke, 4 Aug 1997
Changed the FUNC variable value to H5M_init_interface.
--------------------------------------------------------------------------*/
static herr_t H5M_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5CIinit_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
FUNC_ENTER (H5M_init_interface, NULL, FAIL);
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5M_mask, ID_H5M_init_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_LEAVE(H5M_mask, ID_H5M_init_interface, ret_value);
FUNC_LEAVE(ret_value);
} /* H5M_init_interface */
/*--------------------------------------------------------------------------
@@ -93,11 +91,10 @@ static herr_t H5M_init_interface(void)
--------------------------------------------------------------------------*/
static intn H5M_find_type(hobjtype_t type)
{
CONSTR(FUNC, "H5M_find_type"); /* for HERROR */
intn i; /* local counting variable */
intn ret_value = FAIL;
FUNC_ENTER(H5M_mask, ID_H5M_find_type, H5M_init_interface, FAIL);
FUNC_ENTER(H5M_find_type, H5M_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -118,7 +115,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5M_mask, ID_H5M_find_type, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5M_find_type() */
/*--------------------------------------------------------------------------
@@ -139,11 +136,10 @@ done:
--------------------------------------------------------------------------*/
hatom_t H5Mcreate(hatom_t owner_id, hobjtype_t type, const char *name)
{
CONSTR(FUNC, "H5Mcreate"); /* for HERROR */
intn i; /* local counting variable */
hatom_t ret_value = SUCCEED;
FUNC_ENTER(H5M_mask, ID_H5Mcreate, H5M_init_interface, FAIL);
FUNC_ENTER(H5Mcreate, H5M_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -163,7 +159,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5M_mask, ID_H5Mcreate, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Mcreate() */
@@ -183,12 +179,11 @@ done:
--------------------------------------------------------------------------*/
hatom_t H5Mcopy(hatom_t oid)
{
CONSTR(FUNC, "H5Mcopy"); /* for HERROR */
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5M_mask, ID_H5Mcopy, H5M_init_interface, FAIL);
FUNC_ENTER(H5Mcopy, H5M_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -208,7 +203,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5M_mask, ID_H5Mcopy, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Mcopy() */
/*--------------------------------------------------------------------------
@@ -227,12 +222,11 @@ done:
--------------------------------------------------------------------------*/
herr_t H5Mrelease(hatom_t oid)
{
CONSTR(FUNC, "H5Mrelease"); /* for HERROR */
group_t group=H5Aatom_group(oid); /* Atom group for incoming object */
intn i; /* local counting variable */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5M_mask, ID_H5Mrelease, H5M_init_interface, FAIL);
FUNC_ENTER(H5Mrelease, H5M_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -252,6 +246,6 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5M_mask, ID_H5Mrelease, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Mrelease() */

31
src/H5P.c
View File

@@ -36,10 +36,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5private.h" /* Generic Functions */
#include "H5Pprivate.h" /* Data-space functions */
#define PABLO_MASK H5P_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/*--------------------------------------------------------------------------
NAME
@@ -55,21 +57,13 @@ DESCRIPTION
--------------------------------------------------------------------------*/
static herr_t H5P_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5P_init_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5P_mask, ID_H5P_init_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_ENTER (H5P_init_interface, NULL, FAIL);
/* Initialize the atom group for the file IDs */
ret_value=H5Ainit_group(H5_DATASPACE,HDF5_DATASPACEID_HASHSIZE,H5P_RESERVED_ATOMS);
FUNC_LEAVE(H5P_mask, ID_H5P_init_interface, ret_value);
FUNC_LEAVE(ret_value);
} /* H5P_init_interface */
/*--------------------------------------------------------------------------
@@ -89,11 +83,10 @@ static herr_t H5P_init_interface(void)
--------------------------------------------------------------------------*/
hatom_t H5P_create(hatom_t owner_id, hobjtype_t type, const char *name)
{
CONSTR(FUNC, "H5P_create"); /* for HERROR */
H5P_dim_t *new_dim; /* new dimensionality object to create */
hatom_t ret_value = SUCCEED;
FUNC_ENTER(H5P_mask, ID_H5P_create, H5P_init_interface, FAIL);
FUNC_ENTER(H5P_create, H5P_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -118,7 +111,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5P_mask, ID_H5P_create, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5P_create() */
/*--------------------------------------------------------------------------
@@ -139,10 +132,9 @@ done:
--------------------------------------------------------------------------*/
uintn H5Pnelem(hatom_t sid)
{
CONSTR(FUNC, "H5Pnelem"); /* for HERROR */
uintn ret_value = UFAIL;
FUNC_ENTER(H5P_mask, ID_H5Pnelem, H5P_init_interface, UFAIL);
FUNC_ENTER(H5Pnelem, H5P_init_interface, UFAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -161,7 +153,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5P_mask, ID_H5Pnelem, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Pnelem() */
/*--------------------------------------------------------------------------
@@ -179,11 +171,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5P_release(hatom_t oid)
{
CONSTR(FUNC, "H5P_release"); /* for HERROR */
H5P_dim_t *dim; /* dimensionality object to release */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5P_mask, ID_H5Prelease, H5P_init_interface, FAIL);
FUNC_ENTER(H5Prelease, H5P_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -203,6 +194,6 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5P_mask, ID_H5P_release, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5P_release() */

61
src/H5T.c
View File

@@ -42,10 +42,12 @@ static char RcsId[] = "@(#)$Revision$";
#include "H5private.h" /* Generic Functions */
#include "H5Tprivate.h" /* Data-type functions */
#define PABLO_MASK H5T_mask
/*--------------------- Locally scoped variables -----------------------------*/
/* Whether we've installed the library termination function yet for this interface */
static intn interface_initialize = FALSE;
static intn interface_initialize_g = FALSE;
/*------------------_-- Local function prototypes ----------------------------*/
static herr_t H5T_init_interface(void);
@@ -64,21 +66,13 @@ DESCRIPTION
--------------------------------------------------------------------------*/
static herr_t H5T_init_interface(void)
{
#ifdef LATER
CONSTR(FUNC, "H5T_init_interface"); /* For HERROR */
#endif /* LATER */
herr_t ret_value = SUCCEED;
/* Don't use "FUNC_ENTER" macro, to avoid potential infinite recursion */
PABLO_TRACE_ON(H5T_mask, ID_H5T_init_interface);
/* Don't call this routine again... */
interface_initialize = TRUE;
FUNC_ENTER (H5T_init_interface, NULL, FAIL);
/* Initialize the atom group for the file IDs */
ret_value=H5Ainit_group(H5_DATATYPE,HDF5_DATATYPEID_HASHSIZE,H5T_RESERVED_ATOMS);
FUNC_LEAVE(H5T_mask, ID_H5T_init_interface, ret_value);
FUNC_LEAVE(ret_value);
} /* H5T_init_interface */
/*--------------------------------------------------------------------------
@@ -98,11 +92,10 @@ static herr_t H5T_init_interface(void)
--------------------------------------------------------------------------*/
hatom_t H5T_create(hatom_t owner_id, hobjtype_t type, const char *name)
{
CONSTR(FUNC, "H5T_create"); /* for HERROR */
h5_datatype_t *new_dt; /* new data-type object to create */
hatom_t ret_value = SUCCEED;
FUNC_ENTER(H5T_mask, ID_H5T_create, H5T_init_interface, FAIL);
FUNC_ENTER(H5T_create, H5T_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -128,7 +121,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5T_create, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5T_create() */
/*--------------------------------------------------------------------------
@@ -148,11 +141,10 @@ done:
--------------------------------------------------------------------------*/
uint32 H5Tget_num_fields(hatom_t tid)
{
CONSTR(FUNC, "H5Tget_num_fields"); /* for HERROR */
h5_datatype_t *dt; /* new data-type object to create */
uint32 ret_value = UFAIL;
FUNC_ENTER(H5T_mask, ID_H5Tget_num_fields, H5T_init_interface, UFAIL);
FUNC_ENTER(H5Tget_num_fields, H5T_init_interface, UFAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -180,7 +172,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5Tget_num_fields, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Tget_num_fields() */
/*--------------------------------------------------------------------------
@@ -201,11 +193,10 @@ done:
--------------------------------------------------------------------------*/
hbool_t H5Tis_field_atomic(hatom_t tid, uintn fidx)
{
CONSTR(FUNC, "H5Tis_field_atomic"); /* for HERROR */
h5_datatype_t *dt; /* new data-type object to create */
hbool_t ret_value = BTRUE;
FUNC_ENTER(H5T_mask, ID_H5Tis_field_atomic, H5T_init_interface, BFAIL);
FUNC_ENTER(H5Tis_field_atomic, H5T_init_interface, BFAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -238,7 +229,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5Tis_field_atomic, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Tis_field_atomic() */
/*--------------------------------------------------------------------------
@@ -258,11 +249,10 @@ done:
--------------------------------------------------------------------------*/
hbool_t H5Tis_atomic(hatom_t tid)
{
CONSTR(FUNC, "H5Tis_atomic"); /* for HERROR */
h5_datatype_t *dt; /* new data-type object to create */
hbool_t ret_value = BTRUE;
FUNC_ENTER(H5T_mask, ID_H5Tis_atomic, H5T_init_interface, BFAIL);
FUNC_ENTER(H5Tis_atomic, H5T_init_interface, BFAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -283,7 +273,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5Tis_atomic, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Tis_atomic() */
/*--------------------------------------------------------------------------
@@ -307,11 +297,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5Tset_type(hatom_t tid,hatom_t base,uint8 len,uint8 arch)
{
CONSTR(FUNC, "H5Tset_type"); /* for HERROR */
h5_datatype_t *dt; /* new data-type object to create */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5T_mask, ID_H5Tset_type, H5T_init_interface, FAIL);
FUNC_ENTER(H5Tset_type, H5T_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -337,7 +326,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5Tset_type, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Tset_type() */
/*--------------------------------------------------------------------------
@@ -366,12 +355,11 @@ done:
--------------------------------------------------------------------------*/
herr_t H5Tadd_field(hatom_t tid, const char *name, hatom_t base, uint8 len, uint8 arch, hatom_t space)
{
CONSTR(FUNC, "H5Tadd_field"); /* for HERROR */
h5_field_info_t *new_field; /* pointer to new field to add */
h5_datatype_t *dt; /* data-type object to manipulate */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5T_mask, ID_H5Tadd_field, H5T_init_interface, FAIL);
FUNC_ENTER(H5Tadd_field, H5T_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -426,7 +414,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5Tadd_field, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Tadd_field() */
/*--------------------------------------------------------------------------
@@ -447,10 +435,9 @@ done:
--------------------------------------------------------------------------*/
uintn H5Tsize(hatom_t tid, uint8 len, uint8 arch, hbool_t mem_flag)
{
CONSTR(FUNC, "H5Tsize"); /* for HERROR */
uintn ret_value = UFAIL;
FUNC_ENTER(H5T_mask, ID_H5Tsize, H5T_init_interface, UFAIL);
FUNC_ENTER(H5Tsize, H5T_init_interface, UFAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -519,7 +506,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5Tsize, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Tsize() */
/*--------------------------------------------------------------------------
@@ -540,10 +527,9 @@ done:
--------------------------------------------------------------------------*/
herr_t H5Tget_fields(hatom_t tid, hatom_t *field_list)
{
CONSTR(FUNC, "H5Tget_fields"); /* for HERROR */
herr_t ret_value = FAIL;
FUNC_ENTER(H5T_mask, ID_H5Tget_fields, H5T_init_interface, FAIL);
FUNC_ENTER(H5Tget_fields, H5T_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -560,7 +546,7 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5Tget_fields, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5Tget_fields() */
/*--------------------------------------------------------------------------
@@ -578,11 +564,10 @@ done:
--------------------------------------------------------------------------*/
herr_t H5T_release(hatom_t oid)
{
CONSTR(FUNC, "H5T_release"); /* for HERROR */
h5_datatype_t *dt; /* new data-type object to create */
herr_t ret_value = SUCCEED;
FUNC_ENTER(H5T_mask, ID_H5T_release, H5T_init_interface, FAIL);
FUNC_ENTER(H5T_release, H5T_init_interface, FAIL);
/* Clear errors and check args and all the boring stuff. */
H5ECLEAR;
@@ -605,6 +590,6 @@ done:
/* Normal function cleanup */
FUNC_LEAVE(H5T_mask, ID_H5T_release, ret_value);
FUNC_LEAVE(ret_value);
} /* end H5T_release() */

96
src/hdf5gen.h
View File

@@ -36,14 +36,94 @@
# define TRUE (!FALSE)
#endif
/* Function entry & exit macros */
#define FUNC_ENTER(pablo_mask,pablo_func_id,interface_init_func,err) \
{ PABLO_TRACE_ON(pablo_mask,pablo_func_id); \
if(library_initialize==FALSE) if(H5_init_library()==FAIL) HGOTO_ERROR(H5E_FUNC,H5E_CANTINIT,err); \
if(thread_initialize==FALSE) if(H5_init_thread()==FAIL) HGOTO_ERROR(H5E_FUNC,H5E_CANTINIT,err); \
if(interface_initialize==FALSE) if(interface_init_func()==FAIL) HGOTO_ERROR(H5E_FUNC,H5E_CANTINIT,err); }
#define FUNC_LEAVE(pablo_mask,pablo_func_id,return_value) \
{ PABLO_TRACE_OFF(pablo_mask,pablo_func_id); return(return_value); }
/*-------------------------------------------------------------------------
* Purpose: Register function entry for library initialization and code
* profiling.
*
* Notes: Every file must have a file-scope variable called
* `initialize_interface'.
*
* Don't use local variable initializers which contain
* calls to other library functions since the initializer
* would happen before the FUNC_ENTER() gets called. Don't
* use initializers that require special cleanup code to
* execute if FUNC_ENTER() fails since a failing FUNC_ENTER()
* returns immediately without branching to the `done' label.
*
* Programmer: Quincey Koziol
*
* Modifications:
*
* Robb Matzke, 4 Aug 1997
* The `interface_init_func' can be the null pointer. Changed
* HGOTO_ERROR() to HRETURN_ERROR() since no clean-up needs to occur
* when an error is detected at this point since this must be the
* first executable statement in a function. This allows functions
* to omit the `done:' label when convenient to do so.
*
* Robb Matzke, 4 Aug 1997
* The pablo mask comes from the constant PABLO_MASK defined on
* a per-file basis. The `pablo_func_id' is generated from the
* `func_name' argument by prepending an `ID_' to the name. The
* pablo function identifier should be saved in a local variable
* so FUNC_LEAVE() can access it.
*
* Robb Matzke, 4 Aug 1997
* It is safe to call this function even inside various library
* initializing functions. Infinite recursion is no longer a
* danger.
*
*-------------------------------------------------------------------------
*/
#define FUNC_ENTER(func_name,interface_init_func,err) \
CONSTR (FUNC, #func_name); \
/* int pablo_func_id = ID_ ## func_name; */ \
\
PABLO_TRACE_ON (PABLO_MASK, ID_ ## func_name); \
\
if (!library_initialize_g) { \
library_initialize_g = TRUE; \
if (H5_init_library()<0) { \
HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err); \
} \
} \
\
if (!thread_initialize_g) { \
thread_initialize_g = TRUE; \
if (H5_init_thread()<0) { \
HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err); \
} \
} \
\
if (!interface_initialize_g) { \
interface_initialize_g = TRUE; \
if (interface_init_func && \
((herr_t(*)(void))interface_init_func)()<0) { \
HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err); \
} \
}
/*-------------------------------------------------------------------------
* Purpose: Register function exit for code profiling. This should be
* the last statement executed by a function.
*
* Programmer: Quincey Koziol
*
* Modifications:
*
* Robb Matzke, 4 Aug 1997
* The pablo mask comes from the constant PABLO_MASK defined on a
* per-file basis. The pablo_func_id comes from an auto variable
* defined by FUNC_ENTER.
*
*-------------------------------------------------------------------------
*/
#define FUNC_LEAVE(return_value) { \
PABLO_TRACE_OFF (PABLO_MASK, pablo_func_id); \
return (return_value); \
}
#endif /* HDF5GEN_H */

4
src/hdf5glob.h
View File

@@ -25,7 +25,7 @@
#ifndef HDF5_MASTER
extern
#endif /* HDF5_MASTER */
intn library_initialize /* Whether we've initialized library global information yet */
intn library_initialize_g /* Whether we've initialized library global information yet */
#ifdef HDF5_MASTER
= FALSE
#endif /* HDF5_MASTER */
@@ -43,7 +43,7 @@ intn install_atexit /* Whether to install the atexit routine */
#ifndef HDF5_MASTER
extern
#endif /* HDF5_MASTER */
intn thread_initialize /* Whether we've initialized thread global information yet */
intn thread_initialize_g /* Whether we've initialized thread global information yet */
#ifdef HDF5_MASTER
= FALSE
#endif /* HDF5_MASTER */