mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-25 17:00:45 +08:00
Code Issues Packages Projects Releases Wiki Activity
hdf5/src/H5.c
Elena Pourmal c1df1b3ea4 [svn-r9857] Purpose: Maintenance 
Description: Removed PABLO from the source

Solution:

Platforms tested: arabica with 64-bit, copper with parallel,
                  heping with GNU C and C++ and PGI fortran (but
                  I disabled hl, there is some weird problem only
                  on heping: F9XMODFLAG is not
                  propagated to the Makefile files

Misc. update:
2005-01-21 20:16:57 -05:00

3172 lines
96 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define H5I_PACKAGE /*suppress error about including H5Ipkg */
#include "H5private.h" /* Generic Functions */
#include "H5Bprivate.h" /* B-link trees */
#include "H5Dprivate.h" /* Datasets */
#include "H5Eprivate.h" /* Error handling */
#include "H5FDprivate.h" /* File drivers */
#include "H5FLprivate.h" /* Free lists */
#include "H5Ipkg.h" /* IDs */
#include "H5MMprivate.h" /* Memory management */
#include "H5Pprivate.h" /* Property lists */
#include "H5Rpublic.h" /* References */
#include "H5Sprivate.h" /* Dataspaces */
#include "H5Tprivate.h" /* Datatypes */
#include "H5Zprivate.h" /* I/O pipeline filters */
#ifdef H5_HAVE_PARALLEL
/* datatypes of predefined drivers needed by H5_trace() */
#include "H5FDmpio.h"
#endif /* H5_HAVE_PARALLEL */
/* we need this for the struct rusage declaration */
#if defined(H5_HAVE_GETRUSAGE) && defined(H5_HAVE_SYS_RESOURCE_H)
# include <sys/resource.h>
#endif
/* statically initialize block for pthread_once call used in initializing */
/* the first global mutex */
#ifdef H5_HAVE_THREADSAFE
H5_api_t H5_g;
#else
hbool_t H5_libinit_g = FALSE; /* Library hasn't been initialized */
#endif
#ifdef H5_HAVE_MPE
hbool_t H5_MPEinit_g = FALSE; /* MPE Library hasn't been initialized */
#endif
char H5_lib_vers_info_g[] = H5_VERS_INFO;
static hbool_t H5_dont_atexit_g = FALSE;
H5_debug_t H5_debug_g; /*debugging info */
static void H5_debug_mask(const char*);
/*--------------------------------------------------------------------------
* NAME
* H5_init_library -- Initialize library-global information
* USAGE
* herr_t H5_init_library()
*
* RETURNS
* Non-negative on success/Negative on failure
*
* DESCRIPTION
* Initializes any library-global data or routines.
*
*--------------------------------------------------------------------------
*/
herr_t
H5_init_library(void)
{
herr_t ret_value=SUCCEED;
FUNC_ENTER_NOAPI(H5_init_library, FAIL)
/*
* Make sure the package information is updated.
*/
HDmemset(&H5_debug_g, 0, sizeof H5_debug_g);
H5_debug_g.pkg[H5_PKG_A].name = "a";
H5_debug_g.pkg[H5_PKG_AC].name = "ac";
H5_debug_g.pkg[H5_PKG_B].name = "b";
H5_debug_g.pkg[H5_PKG_D].name = "d";
H5_debug_g.pkg[H5_PKG_E].name = "e";
H5_debug_g.pkg[H5_PKG_F].name = "f";
H5_debug_g.pkg[H5_PKG_G].name = "g";
H5_debug_g.pkg[H5_PKG_HG].name = "hg";
H5_debug_g.pkg[H5_PKG_HL].name = "hl";
H5_debug_g.pkg[H5_PKG_I].name = "i";
H5_debug_g.pkg[H5_PKG_MF].name = "mf";
H5_debug_g.pkg[H5_PKG_MM].name = "mm";
H5_debug_g.pkg[H5_PKG_O].name = "o";
H5_debug_g.pkg[H5_PKG_P].name = "p";
H5_debug_g.pkg[H5_PKG_S].name = "s";
H5_debug_g.pkg[H5_PKG_T].name = "t";
H5_debug_g.pkg[H5_PKG_V].name = "v";
H5_debug_g.pkg[H5_PKG_Z].name = "z";
#ifdef H5_HAVE_MPE
/* Initialize MPE instrumentation library. May need to move this
* up earlier if any of the above initialization involves using
* the instrumentation code.
*/
if (!H5_MPEinit_g)
{
int mpe_code;
int mpi_initialized;
MPI_Initialized(&mpi_initialized);
if (mpi_initialized){
mpe_code = MPE_Init_log();
assert(mpe_code >=0);
H5_MPEinit_g = TRUE;
}
}
#endif
/*
* Install atexit() library cleanup routine unless the H5dont_atexit()
* has been called. Once we add something to the atexit() list it stays
* there permanently, so we set H5_dont_atexit_g after we add it to prevent
* adding it again later if the library is cosed and reopened.
*/
if (!H5_dont_atexit_g) {
(void)HDatexit(H5_term_library);
H5_dont_atexit_g = TRUE;
}
/*
* Initialize interfaces that might not be able to initialize themselves
* soon enough. The file & dataset interfaces must be initialized because
* calling H5P_create() might require the file/dataset property classes to be
* initialized. The property interface must be initialized before the file
* & dataset interfaces though, in order to provide them with the proper
* property classes.
*/
if (H5E_init()<0)
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize error interface")
if (H5P_init()<0)
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize property list interface")
if (H5F_init()<0)
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize file interface")
if (H5T_init()<0)
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize datatype interface")
if (H5D_init()<0)
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize dataset interface")
if (H5AC_init()<0)
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL, "unable to initialize metadata caching interface")
/* Debugging? */
H5_debug_mask("-all");
H5_debug_mask(HDgetenv("HDF5_DEBUG"));
done:
FUNC_LEAVE_NOAPI(ret_value)
}
/*-------------------------------------------------------------------------
* Function: H5_term_library
*
* Purpose: Terminate interfaces in a well-defined order due to
* dependencies among the interfaces, then terminate
* library-specific data.
*
* Return: void
*
* Programmer: Robb Matzke
* Friday, November 20, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_term_library(void)
{
int pending, ntries=0, n;
unsigned at=0;
char loop[1024];
H5E_auto_stack_t func;
#ifdef H5_HAVE_THREADSAFE
/* explicit locking of the API */
H5_FIRST_THREAD_INIT
H5_API_LOCK
#endif
/* Don't do anything if the library is already closed */
if (!(H5_INIT_GLOBAL))
goto done;
/* Check if we should display error output */
(void)H5Eget_auto_stack(H5E_DEFAULT,&func,NULL);
/*
* Terminate each interface. The termination functions return a positive
* value if they do something that might affect some other interface in a
* way that would necessitate some cleanup work in the other interface.
*/
#define DOWN(F) \
(((n=H5##F##_term_interface()) && at+8<sizeof loop)? \
(sprintf(loop+at, "%s%s", at?",":"", #F), \
at += HDstrlen(loop+at), \
n): \
((n>0 && at+5<sizeof loop)? \
(sprintf(loop+at, "..."), \
at += HDstrlen(loop+at), \
n):n))
do {
pending = 0;
/* Try to organize these so the "higher" level components get shut
* down before "lower" level components that they might rely on. -QAK
*/
pending += DOWN(R);
pending += DOWN(D);
pending += DOWN(G);
pending += DOWN(A);
pending += DOWN(S);
pending += DOWN(T);
/* Don't shut down the file code until objects in files are shut down */
if(pending==0)
pending += DOWN(F);
/* Don't shut down "low-level" components until "high-level" components
* have successfully shut down. This prevents property lists and IDs
* from being closed "out from underneath" of the high-level objects
* that depend on them. -QAK
*/
if(pending==0) {
pending += DOWN(AC);
pending += DOWN(Z);
pending += DOWN(FD);
pending += DOWN(P);
/* Don't shut down the error code until other APIs which use it are shut down */
if(pending==0)
pending += DOWN(E);
/* Don't shut down the ID code until other APIs which use them are shut down */
if(pending==0)
pending += DOWN(I);
/* Don't shut down the free list code until _everything_ else is down */
if(pending==0)
pending += DOWN(FL);
}
} while (pending && ntries++ < 100);
if (pending) {
/* Only display the error message if the user is interested in them. */
if (func) {
fprintf(stderr, "HDF5: infinite loop closing library\n");
fprintf(stderr, " %s\n", loop);
#ifndef NDEBUG
HDabort();
#endif /* NDEBUG */
}
}
#ifdef H5_HAVE_MPE
/* Close MPE instrumentation library. May need to move this
* down if any of the below code involves using the instrumentation code.
*/
if (H5_MPEinit_g)
{
int mpe_code;
int mpi_initialized;
MPI_Initialized(&mpi_initialized);
if (mpi_initialized){
mpe_code = MPE_Finish_log("cpilog");
assert(mpe_code >=0);
}
H5_MPEinit_g = FALSE; /* turn it off no matter what */
}
#endif
/* Mark library as closed */
H5_INIT_GLOBAL = FALSE;
done:
#ifdef H5_HAVE_THREADSAFE
H5_API_UNLOCK
#endif
return;
}
/*-------------------------------------------------------------------------
* Function: H5dont_atexit
*
* Purpose: Indicates that the library is not to clean up after itself
* when the application exits by calling exit() or returning
* from main(). This function must be called before any other
* HDF5 function or constant is used or it will have no effect.
*
* If this function is used then certain memory buffers will not
* be de-allocated nor will open files be flushed automatically.
* The application may still call H5close() explicitly to
* accomplish these things.
*
* Return: Success: non-negative
*
* Failure: negative if this function is called more than
* once or if it is called too late.
*
* Programmer: Robb Matzke
* Friday, November 20, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5dont_atexit(void)
{
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_API_NOINIT(H5dont_atexit)
H5TRACE0("e","");
if (H5_dont_atexit_g)
ret_value=FAIL;
else
H5_dont_atexit_g = TRUE;
FUNC_LEAVE_API(ret_value)
}
/*-------------------------------------------------------------------------
* Function: H5garbage_collect
*
* Purpose: Walks through all the garbage collection routines for the
* library, which are supposed to free any unused memory they have
* allocated.
*
* These should probably be registered dynamicly in a linked list of
* functions to call, but there aren't that many right now, so we
* hard-wire them...
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* Saturday, March 11, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5garbage_collect(void)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_API(H5garbage_collect, FAIL)
H5TRACE0("e","");
/* Call the garbage collection routines in the library */
if(H5FL_garbage_coll()<0)
HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGC, FAIL, "can't garbage collect objects")
done:
FUNC_LEAVE_API(ret_value)
} /* end H5garbage_collect() */
/*-------------------------------------------------------------------------
* Function: H5set_free_list_limits
*
* Purpose: Sets limits on the different kinds of free lists. Setting a value
* of -1 for a limit means no limit of that type. These limits are global
* for the entire library. Each "global" limit only applies to free lists
* of that type, so if an application sets a limit of 1 MB on each of the
* global lists, up to 3 MB of total storage might be allocated (1MB on
* each of regular, array and block type lists).
*
* Parameters:
* int reg_global_lim; IN: The limit on all "regular" free list memory used
* int reg_list_lim; IN: The limit on memory used in each "regular" free list
* int arr_global_lim; IN: The limit on all "array" free list memory used
* int arr_list_lim; IN: The limit on memory used in each "array" free list
* int blk_global_lim; IN: The limit on all "block" free list memory used
* int blk_list_lim; IN: The limit on memory used in each "block" free list
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* Wednesday, August 2, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5set_free_list_limits(int reg_global_lim, int reg_list_lim, int arr_global_lim,
int arr_list_lim, int blk_global_lim, int blk_list_lim)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_API(H5set_free_list_limits, FAIL)
H5TRACE6("e","IsIsIsIsIsIs",reg_global_lim,reg_list_lim,arr_global_lim,
arr_list_lim,blk_global_lim,blk_list_lim);
/* Call the free list function to actually set the limits */
if(H5FL_set_free_list_limits(reg_global_lim, reg_list_lim, arr_global_lim, arr_list_lim, blk_global_lim, blk_list_lim)<0)
HGOTO_ERROR(H5E_RESOURCE, H5E_CANTSET, FAIL, "can't set garbage collection limits")
done:
FUNC_LEAVE_API(ret_value)
} /* end H5set_free_list_limits() */
/*-------------------------------------------------------------------------
* Function: H5_debug_mask
*
* Purpose: Set runtime debugging flags according to the string S. The
* string should contain file numbers and package names
* separated by other characters. A file number applies to all
* following package names up to the next file number. The
* initial file number is `2' (the standard error stream). Each
* package name can be preceded by a `+' or `-' to add or remove
* the package from the debugging list (`+' is the default). The
* special name `all' means all packages.
*
* The name `trace' indicates that API tracing is to be turned
* on or off.
*
* Return: void
*
* Programmer: Robb Matzke
* Wednesday, August 19, 1998
*
* Modifications:
* Robb Matzke, 2002-08-08
* Accepts the `ttop' word. If enabled then show only the
* top level API calls, otherwise show all API calls. Also
* turns on tracing as if the `trace' word was present.
*-------------------------------------------------------------------------
*/
static void
H5_debug_mask(const char *s)
{
FILE *stream = stderr;
char pkg_name[32], *rest;
size_t i;
int clear;
while (s && *s) {
if (HDisalpha(*s) || '-'==*s || '+'==*s) {
/* Enable or Disable debugging? */
if ('-'==*s) {
clear = TRUE;
s++;
} else if ('+'==*s) {
clear = FALSE;
s++;
} else {
clear = FALSE;
}
/* Get the name */
for (i=0; HDisalpha(*s); i++, s++)
if (i<sizeof pkg_name)
pkg_name[i] = *s;
pkg_name[MIN(sizeof(pkg_name)-1, i)] = '\0';
/* Trace, all, or one? */
if (!HDstrcmp(pkg_name, "trace")) {
H5_debug_g.trace = clear?NULL:stream;
} else if (!HDstrcmp(pkg_name, "ttop")) {
H5_debug_g.trace = stream;
H5_debug_g.ttop = !clear;
} else if (!HDstrcmp(pkg_name, "ttimes")) {
H5_debug_g.trace = stream;
H5_debug_g.ttimes = !clear;
} else if (!HDstrcmp(pkg_name, "all")) {
for (i=0; i<(size_t)H5_NPKGS; i++)
H5_debug_g.pkg[i].stream = clear?NULL:stream;
} else {
for (i=0; i<(size_t)H5_NPKGS; i++) {
if (!HDstrcmp(H5_debug_g.pkg[i].name, pkg_name)) {
H5_debug_g.pkg[i].stream = clear?NULL:stream;
break;
}
}
if (i>=(size_t)H5_NPKGS)
fprintf(stderr, "HDF5_DEBUG: ignored %s\n", pkg_name);
}
} else if (HDisdigit(*s)) {
int fd = (int)HDstrtol (s, &rest, 0);
if ((stream=HDfdopen(fd, "w"))!=NULL)
(void)HDsetvbuf (stream, NULL, _IOLBF, 0);
s = rest;
} else {
s++;
}
}
}
/*-------------------------------------------------------------------------
* Function: H5get_libversion
*
* Purpose: Returns the library version numbers through arguments. MAJNUM
* will be the major revision number of the library, MINNUM the
* minor revision number, and RELNUM the release revision number.
*
* Note: When printing an HDF5 version number it should be printed as
*
* printf("%u.%u.%u", maj, min, rel) or
* printf("version %u.%u release %u", maj, min, rel)
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Unknown
*
* Modifications:
* Robb Matzke, 4 Mar 1998
* Now use "normal" data types for the interface. Any of the arguments
* may be null pointers
*
*-------------------------------------------------------------------------
*/
herr_t
H5get_libversion(unsigned *majnum, unsigned *minnum, unsigned *relnum)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_API(H5get_libversion, FAIL)
H5TRACE3("e","*Iu*Iu*Iu",majnum,minnum,relnum);
/* Set the version information */
if (majnum) *majnum = H5_VERS_MAJOR;
if (minnum) *minnum = H5_VERS_MINOR;
if (relnum) *relnum = H5_VERS_RELEASE;
done:
FUNC_LEAVE_API(ret_value)
}
/*-------------------------------------------------------------------------
* Function: H5check_version
*
* Purpose: Verifies that the arguments match the version numbers
* compiled into the library. This function is intended to be
* called from user to verify that the versions of header files
* compiled into the application match the version of the hdf5
* library.
*
* Return: Success: SUCCEED
*
* Failure: abort()
*
* Programmer: Robb Matzke
* Tuesday, April 21, 1998
*
* Modifications:
* Albert Cheng, May 12, 2001
* Added verification of H5_VERS_INFO.
*
*-------------------------------------------------------------------------
*/
herr_t
H5check_version(unsigned majnum, unsigned minnum, unsigned relnum)
{
char lib_str[256];
char substr[] = H5_VERS_SUBRELEASE;
static int checked = 0; /* If we've already checked the version info */
static int disable_version_check = 0; /* Set if the version check should be disabled */
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_API_NOINIT(H5check_version)
H5TRACE3("e","IuIuIu",majnum,minnum,relnum);
/* Don't check again, if we already have */
if (checked)
HGOTO_DONE(SUCCEED)
{ const char *s; /* Environment string for disabling version check */
/* Allow different versions of the header files and library? */
s = HDgetenv ("HDF5_DISABLE_VERSION_CHECK");
if (s && HDisdigit(*s))
disable_version_check = (int)HDstrtol (s, NULL, 0);
}
if (H5_VERS_MAJOR!=majnum || H5_VERS_MINOR!=minnum ||
H5_VERS_RELEASE!=relnum) {
switch (disable_version_check) {
case 0:
HDfputs ("Warning! The HDF5 header files included by this application "
"do not match the\nversion used by the HDF5 library to which "
"this application is linked. Data\ncorruption or "
"segmentation faults may occur if the application "
"is\nallowed to continue. You can, at your own risk, "
"disable this check by setting\nthe environment variable "
"'HDF5_DISABLE_VERSION_CHECK' to a value of '1'.\n"
"Setting it to 2 will suppress the warning totally.\n",
stderr);
/* Mention the versions we are referring to */
HDfprintf (stderr, "Headers are %u.%u.%u, library is %u.%u.%u\n",
majnum, minnum, relnum,
H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE);
/* Bail out now. */
HDfputs ("Bye...\n", stderr);
HDabort ();
case 2:
/* continue silently */
break;
default:
/* continue with a warning */
HDfputs ("Warning! The HDF5 header files included by this application "
"do not match the\nversion used by the HDF5 library to which "
"this application is linked. Data\ncorruption or "
"segmentation faults may occur if the application "
"continues.\n'HDF5_DISABLE_VERSION_CHECK' "
"environment variable set, application will\n"
"continue.\n", stderr);
/* Mention the versions we are referring to */
HDfprintf (stderr, "Headers are %u.%u.%u, library is %u.%u.%u\n",
majnum, minnum, relnum,
H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE);
break;
} /* end switch */
} /* end if */
/* Indicate that the version check has been performed */
checked = 1;
if (!disable_version_check){
/*
*verify if H5_VERS_INFO is consistent with the other version information.
*Check only the first sizeof(lib_str) char. Assume the information
*will fit within this size or enough significance.
*/
sprintf(lib_str, "HDF5 library version: %d.%d.%d",
H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE);
if (*substr){
HDstrcat(lib_str, "-");
HDstrncat(lib_str, substr, (sizeof(lib_str) - HDstrlen(lib_str)) - 1);
} /* end if */
if (HDstrcmp(lib_str, H5_lib_vers_info_g)){
HDfputs ("Warning! Library version information error.\n"
"The HDF5 library version information are not "
"consistent in its source code.\nThis is NOT a fatal error "
"but should be corrected. Setting the environment\n"
"variable 'HDF5_DISABLE_VERSION_CHECK' to a value of 1 "
"will suppress\nthis warning.\n",
stderr);
HDfprintf (stderr, "Library version information are:\n"
"H5_VERS_MAJOR=%d, H5_VERS_MINOR=%d, H5_VERS_RELEASE=%d, "
"H5_VERS_SUBRELEASE=%s,\nH5_VERS_INFO=%s\n",
H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE,
H5_VERS_SUBRELEASE, H5_VERS_INFO);
} /* end if */
}
done:
FUNC_LEAVE_API(ret_value)
}
/*-------------------------------------------------------------------------
* Function: H5open
*
* Purpose: Initialize the library. This is normally called
* automatically, but if you find that an HDF5 library function
* is failing inexplicably, then try calling this function
* first.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Tuesday, December 9, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5open(void)
{
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_API_NOCLEAR(H5open, FAIL)
H5TRACE0("e","");
/* all work is done by FUNC_ENTER() */
done:
FUNC_LEAVE_API(ret_value)
}
/*-------------------------------------------------------------------------
* Function: H5close
*
* Purpose: Terminate the library and release all resources.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Friday, January 30, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t
H5close(void)
{
/*
* Don't call FUNC_ENTER() since we don't want to initialize the whole
* thing just to release it all right away. It is safe to call this
* function for an uninitialized library.
*/
FUNC_ENTER_API_NOINIT(H5close)
H5TRACE0("e","");
H5_term_library();
FUNC_LEAVE_API(SUCCEED)
}
#ifndef H5_HAVE_SNPRINTF
/*-------------------------------------------------------------------------
* Function: HDsnprintf
*
* Purpose: Writes output to the string BUF under control of the format
* FMT that specifies how subsequent arguments are converted for
* output. It is similar to sprintf except that SIZE specifies
* the maximum number of characters to produce. The trailing
* null character is counted towards this limit, so you should
* allocated at least SIZE characters for the string BUF.
*
* Note: This function is for compatibility on systems that don't have
* snprintf(3). It doesn't actually check for overflow like the
* real snprintf() would.
*
* Return: Success: Number of characters stored, not including
* the terminating null. If this value equals
* SIZE then there was not enough space in BUF
* for all the output.
*
* Failure: -1
*
* Programmer: Robb Matzke
* Tuesday, November 24, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
/* ARGSUSED */
int
HDsnprintf(char *buf, size_t UNUSED size, const char *fmt, ...)
{
int n;
va_list ap;
va_start(ap, fmt);
n = HDvsprintf(buf, fmt, ap);
va_end(ap);
return n;
}
#endif /* H5_HAVE_SNPRINTF */
#ifndef H5_HAVE_VSNPRINTF
/*-------------------------------------------------------------------------
* Function: HDvsnprintf
*
* Purpose: The same as HDsnprintf() except the variable arguments are
* passed as a va_list.
*
* Note: This function is for compatibility on systems that don't have
* vsnprintf(3). It doesn't actually check for overflow like the
* real vsnprintf() would.
*
* Return: Success: Number of characters stored, not including
* the terminating null. If this value equals
* SIZE then there was not enough space in BUF
* for all the output.
*
* Failure: -1
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
/* ARGSUSED */
int
HDvsnprintf(char *buf, size_t UNUSED size, const char *fmt, va_list ap)
{
return HDvsprintf(buf, fmt, ap);
}
#endif /* H5_HAVE_VSNPRINTF */
/*-------------------------------------------------------------------------
* Function: HDfprintf
*
* Purpose: Prints the optional arguments under the control of the format
* string FMT to the stream STREAM. This function takes the
* same format as fprintf(3c) with a few added features:
*
* The conversion modifier `H' refers to the size of an
* `hsize_t' or `hssize_t' type. For instance, "0x%018Hx"
* prints an `hsize_t' value as a hex number right justified and
* zero filled in an 18-character field.
*
* The conversion `a' refers to an `haddr_t' type.
*
* Return: Success: Number of characters printed
*
* Failure: -1
*
* Programmer: Robb Matzke
* Thursday, April 9, 1998
*
* Modifications:
* Robb Matzke, 1999-07-27
* The `%a' format refers to an argument of `haddr_t' type
* instead of `haddr_t*' and the return value is correct.
*-------------------------------------------------------------------------
*/
int
HDfprintf(FILE *stream, const char *fmt, ...)
{
int n=0, nout = 0;
int fwidth, prec;
int zerofill;
int leftjust;
int plussign;
int ldspace;
int prefix;
char modifier[8];
int conv;
char *rest, format_templ[128];
const char *s;
va_list ap;
assert (stream);
assert (fmt);
va_start (ap, fmt);
while (*fmt) {
fwidth = prec = 0;
zerofill = 0;
leftjust = 0;
plussign = 0;
prefix = 0;
ldspace = 0;
modifier[0] = '\0';
if ('%'==fmt[0] && '%'==fmt[1]) {
HDputc ('%', stream);
fmt += 2;
nout++;
} else if ('%'==fmt[0]) {
s = fmt + 1;
/* Flags */
while (HDstrchr ("-+ #", *s)) {
switch (*s) {
case '-':
leftjust = 1;
break;
case '+':
plussign = 1;
break;
case ' ':
ldspace = 1;
break;
case '#':
prefix = 1;
break;
} /*lint !e744 Switch statement doesn't _need_ default */
s++;
}
/* Field width */
if (HDisdigit (*s)) {
zerofill = ('0'==*s);
fwidth = (int)HDstrtol (s, &rest, 10);
s = rest;
} else if ('*'==*s) {
fwidth = va_arg (ap, int);
if (fwidth<0) {
leftjust = 1;
fwidth = -fwidth;
}
s++;
}
/* Precision */
if ('.'==*s) {
s++;
if (HDisdigit (*s)) {
prec = (int)HDstrtol (s, &rest, 10);
s = rest;
} else if ('*'==*s) {
prec = va_arg (ap, int);
s++;
}
if (prec<1) prec = 1;
}
/* Extra type modifiers */
if (HDstrchr ("ZHhlqLI", *s)) {
switch (*s) {
/*lint --e{506} Don't issue warnings about constant value booleans */
/*lint --e{774} Don't issue warnings boolean within 'if' always evaluates false/true */
case 'H':
if (sizeof(hsize_t)<sizeof(long)) {
modifier[0] = '\0';
} else if (sizeof(hsize_t)==sizeof(long)) {
HDstrcpy (modifier, "l");
} else {
HDstrcpy (modifier, H5_PRINTF_LL_WIDTH);
}
break;
case 'Z':
if (sizeof(size_t)<sizeof(long)) {
modifier[0] = '\0';
} else if (sizeof(size_t)==sizeof(long)) {
HDstrcpy (modifier, "l");
} else {
HDstrcpy (modifier, H5_PRINTF_LL_WIDTH);
}
break;
default:
/* Handle 'I64' modifier for Microsoft's "__int64" type */
if(*s=='I' && *(s+1)=='6' && *(s+2)=='4') {
modifier[0] = *s;
modifier[1] = *(s+1);
modifier[2] = *(s+2);
modifier[3] = '\0';
s+=2; /* Increment over 'I6', the '4' is taken care of below */
} /* end if */
else {
/* Handle 'll' for long long types */
if(*s=='l' && *(s+1)=='l') {
modifier[0] = *s;
modifier[1] = *s;
modifier[2] = '\0';
s++; /* Increment over first 'l', second is taken care of below */
} /* end if */
else {
modifier[0] = *s;
modifier[1] = '\0';
} /* end else */
} /* end else */
break;
}
s++;
}
/* Conversion */
conv = *s++;
/* Create the format template */
sprintf (format_templ, "%%%s%s%s%s%s",
leftjust?"-":"", plussign?"+":"",
ldspace?" ":"", prefix?"#":"", zerofill?"0":"");
if (fwidth>0)
sprintf (format_templ+HDstrlen(format_templ), "%d", fwidth);
if (prec>0)
sprintf (format_templ+HDstrlen(format_templ), ".%d", prec);
if (*modifier)
sprintf (format_templ+HDstrlen(format_templ), "%s", modifier);
sprintf (format_templ+HDstrlen(format_templ), "%c", conv);
/* Conversion */
switch (conv) {
case 'd':
case 'i':
if (!HDstrcmp(modifier, "h")) {
short x = (short)va_arg (ap, int);
n = fprintf (stream, format_templ, x);
} else if (!*modifier) {
int x = va_arg (ap, int);
n = fprintf (stream, format_templ, x);
} else if (!HDstrcmp (modifier, "l")) {
long x = va_arg (ap, long);
n = fprintf (stream, format_templ, x);
} else {
int64_t x = va_arg(ap, int64_t);
n = fprintf (stream, format_templ, x);
}
break;
case 'o':
case 'u':
case 'x':
case 'X':
if (!HDstrcmp (modifier, "h")) {
unsigned short x = (unsigned short)va_arg (ap, unsigned int);
n = fprintf (stream, format_templ, x);
} else if (!*modifier) {
unsigned int x = va_arg (ap, unsigned int); /*lint !e732 Loss of sign not really occuring */
n = fprintf (stream, format_templ, x);
} else if (!HDstrcmp (modifier, "l")) {
unsigned long x = va_arg (ap, unsigned long); /*lint !e732 Loss of sign not really occuring */
n = fprintf (stream, format_templ, x);
} else {
uint64_t x = va_arg(ap, uint64_t); /*lint !e732 Loss of sign not really occuring */
n = fprintf (stream, format_templ, x);
}
break;
case 'f':
case 'e':
case 'E':
case 'g':
case 'G':
if (!HDstrcmp (modifier, "h")) {
float x = (float) va_arg (ap, double);
n = fprintf (stream, format_templ, x);
} else if (!*modifier || !HDstrcmp (modifier, "l")) {
double x = va_arg (ap, double);
n = fprintf (stream, format_templ, x);
} else {
/*
* Some compilers complain when `long double' and
* `double' are the same thing.
*/
#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE
long double x = va_arg (ap, long double);
n = fprintf (stream, format_templ, x);
#else
double x = va_arg (ap, double);
n = fprintf (stream, format_templ, x);
#endif
}
break;
case 'a':
{
haddr_t x = va_arg (ap, haddr_t); /*lint !e732 Loss of sign not really occuring */
if (H5F_addr_defined(x)) {
sprintf(format_templ, "%%%s%s%s%s%s",
leftjust?"-":"", plussign?"+":"",
ldspace?" ":"", prefix?"#":"",
zerofill?"0":"");
if (fwidth>0)
sprintf(format_templ+HDstrlen(format_templ), "%d", fwidth);
/*lint --e{506} Don't issue warnings about constant value booleans */
/*lint --e{774} Don't issue warnings boolean within 'if' always evaluates false/true */
if (sizeof(x)==H5_SIZEOF_INT) {
HDstrcat(format_templ, "u");
} else if (sizeof(x)==H5_SIZEOF_LONG) {
HDstrcat(format_templ, "lu");
} else if (sizeof(x)==H5_SIZEOF_LONG_LONG) {
HDstrcat(format_templ, H5_PRINTF_LL_WIDTH);
HDstrcat(format_templ, "u");
}
n = fprintf(stream, format_templ, x);
} else {
HDstrcpy(format_templ, "%");
if (leftjust)
HDstrcat(format_templ, "-");
if (fwidth)
sprintf(format_templ+HDstrlen(format_templ), "%d", fwidth);
HDstrcat(format_templ, "s");
fprintf(stream, format_templ, "UNDEF");
}
}
break;
case 'c':
{
char x = (char)va_arg (ap, int);
n = fprintf (stream, format_templ, x);
}
break;
case 's':
case 'p':
{
char *x = va_arg (ap, char*); /*lint !e64 Type mismatch not really occuring */
n = fprintf (stream, format_templ, x);
}
break;
case 'n':
format_templ[HDstrlen(format_templ)-1] = 'u';
n = fprintf (stream, format_templ, nout);
break;
default:
HDfputs (format_templ, stream);
n = (int)HDstrlen (format_templ);
break;
}
nout += n;
fmt = s;
} else {
HDputc (*fmt, stream);
fmt++;
nout++;
}
}
va_end (ap);
return nout;
}
/*-------------------------------------------------------------------------
* Function: HDstrtoll
*
* Purpose: Converts the string S to an int64_t value according to the
* given BASE, which must be between 2 and 36 inclusive, or be
* the special value zero.
*
* The string must begin with an arbitrary amount of white space
* (as determined by isspace(3c)) followed by a single optional
* `+' or `-' sign. If BASE is zero or 16 the string may then
* include a `0x' or `0X' prefix, and the number will be read in
* base 16; otherwise a zero BASE is taken as 10 (decimal)
* unless the next character is a `0', in which case it is taken
* as 8 (octal).
*
* The remainder of the string is converted to an int64_t in the
* obvious manner, stopping at the first character which is not
* a valid digit in the given base. (In bases above 10, the
* letter `A' in either upper or lower case represetns 10, `B'
* represents 11, and so forth, with `Z' representing 35.)
*
* If REST is not null, the address of the first invalid
* character in S is stored in *REST. If there were no digits
* at all, the original value of S is stored in *REST. Thus, if
* *S is not `\0' but **REST is `\0' on return the entire string
* was valid.
*
* Return: Success: The result.
*
* Failure: If the input string does not contain any
* digits then zero is returned and REST points
* to the original value of S. If an overflow
* or underflow occurs then the maximum or
* minimum possible value is returned and the
* global `errno' is set to ERANGE. If BASE is
* incorrect then zero is returned.
*
* Programmer: Robb Matzke
* Thursday, April 9, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int64_t
HDstrtoll(const char *s, const char **rest, int base)
{
int64_t sign=1, acc=0;
hbool_t overflow = FALSE;
errno = 0;
if (!s || (base && (base<2 || base>36))) {
if (rest) *rest = s;
return 0;
}
/* Skip white space */
while (HDisspace (*s)) s++;
/* Optional minus or plus sign */
if ('+'==*s) {
s++;
} else if ('-'==*s) {
sign = -1;
s++;
}
/* Zero base prefix */
if (0==base && '0'==*s && ('x'==s[1] || 'X'==s[1])) {
base = 16;
s += 2;
} else if (0==base && '0'==*s) {
base = 8;
s++;
} else if (0==base) {
base = 10;
}
/* Digits */
while ((base<=10 && *s>='0' && *s<'0'+base) ||
(base>10 && ((*s>='0' && *s<='9') ||
(*s>='a' && *s<'a'+base-10) ||
(*s>='A' && *s<'A'+base-10)))) {
if (!overflow) {
int64_t digit = 0;
if (*s>='0' && *s<='9') digit = *s - '0';
else if (*s>='a' && *s<='z') digit = (*s-'a')+10;
else digit = (*s-'A')+10;
if (acc*base+digit < acc) {
overflow = TRUE;
} else {
acc = acc*base + digit;
}
}
s++;
}
/* Overflow */
if (overflow) {
if (sign>0) {
acc = ((uint64_t)1<<(8*sizeof(int64_t)-1))-1;
} else {
acc = (uint64_t)1<<(8*sizeof(int64_t)-1);
}
errno = ERANGE;
}
/* Return values */
acc *= sign;
if (rest) *rest = s;
return acc;
}
/*-------------------------------------------------------------------------
* Function: H5_timer_reset
*
* Purpose: Resets the timer struct to zero. Use this to reset a timer
* that's being used as an accumulator for summing times.
*
* Return: void
*
* Programmer: Robb Matzke
* Thursday, April 16, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_timer_reset (H5_timer_t *timer)
{
assert (timer);
HDmemset (timer, 0, sizeof *timer);
}
/*-------------------------------------------------------------------------
* Function: H5_timer_begin
*
* Purpose: Initialize a timer to time something.
*
* Return: void
*
* Programmer: Robb Matzke
* Thursday, April 16, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_timer_begin (H5_timer_t *timer)
{
#ifdef H5_HAVE_GETRUSAGE
struct rusage rusage;
#endif
#ifdef H5_HAVE_GETTIMEOFDAY
struct timeval etime;
#endif
assert (timer);
#ifdef H5_HAVE_GETRUSAGE
HDgetrusage (RUSAGE_SELF, &rusage);
timer->utime = (double)rusage.ru_utime.tv_sec +
(double)rusage.ru_utime.tv_usec/1e6;
timer->stime = (double)rusage.ru_stime.tv_sec +
(double)rusage.ru_stime.tv_usec/1e6;
#else
timer->utime = 0.0;
timer->stime = 0.0;
#endif
#ifdef H5_HAVE_GETTIMEOFDAY
HDgettimeofday (&etime, NULL);
timer->etime = (double)etime.tv_sec + (double)etime.tv_usec/1e6;
#else
timer->etime = 0.0;
#endif
}
/*-------------------------------------------------------------------------
* Function: H5_timer_end
*
* Purpose: This function should be called at the end of a timed region.
* The SUM is an optional pointer which will accumulate times.
* TMS is the same struct that was passed to H5_timer_start().
* On return, TMS will contain total times for the timed region.
*
* Return: void
*
* Programmer: Robb Matzke
* Thursday, April 16, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_timer_end (H5_timer_t *sum/*in,out*/, H5_timer_t *timer/*in,out*/)
{
H5_timer_t now;
assert (timer);
H5_timer_begin (&now);
timer->utime = MAX(0.0, now.utime - timer->utime);
timer->stime = MAX(0.0, now.stime - timer->stime);
timer->etime = MAX(0.0, now.etime - timer->etime);
if (sum) {
sum->utime += timer->utime;
sum->stime += timer->stime;
sum->etime += timer->etime;
}
}
/*-------------------------------------------------------------------------
* Function: H5_bandwidth
*
* Purpose: Prints the bandwidth (bytes per second) in a field 10
* characters wide widh four digits of precision like this:
*
* NaN If <=0 seconds
* 1234. TB/s
* 123.4 TB/s
* 12.34 GB/s
* 1.234 MB/s
* 4.000 kB/s
* 1.000 B/s
* 0.000 B/s If NBYTES==0
* 1.2345e-10 For bandwidth less than 1
* 6.7893e+94 For exceptionally large values
* 6.678e+106 For really big values
*
* Return: void
*
* Programmer: Robb Matzke
* Wednesday, August 5, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds)
{
double bw;
if (nseconds<=0.0) {
HDstrcpy(buf, " NaN");
} else {
bw = nbytes/nseconds;
if (fabs(bw) < 0.0000000001) {
/* That is == 0.0, but direct comparison between floats is bad */
HDstrcpy(buf, "0.000 B/s");
} else if (bw<1.0) {
sprintf(buf, "%10.4e", bw);
} else if (bw<1024.0) {
sprintf(buf, "%05.4f", bw);
HDstrcpy(buf+5, " B/s");
} else if (bw<1024.0*1024.0) {
sprintf(buf, "%05.4f", bw/1024.0);
HDstrcpy(buf+5, " kB/s");
} else if (bw<1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f", bw/(1024.0*1024.0));
HDstrcpy(buf+5, " MB/s");
} else if (bw<1024.0*1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f",
bw/(1024.0*1024.0*1024.0));
HDstrcpy(buf+5, " GB/s");
} else if (bw<1024.0*1024.0*1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f",
bw/(1024.0*1024.0*1024.0*1024.0));
HDstrcpy(buf+5, " TB/s");
} else {
sprintf(buf, "%10.4e", bw);
if (HDstrlen(buf)>10) {
sprintf(buf, "%10.3e", bw);
}
}
}
}
/*-------------------------------------------------------------------------
* Function: H5_trace
*
* Purpose: This function is called whenever an API function is called
* and tracing is turned on. If RETURNING is non-zero then
* the caller is about to return and RETURNING points to the
* time for the corresponding function call event. Otherwise
* we print the function name and the arguments.
*
* The TYPE argument is a string which gives the type of each of
* the following argument pairs. Each type is zero or more
* asterisks (one for each level of indirection, although some
* types have one level of indirection already implied) followed
* by either one letter (lower case) or two letters (first one
* uppercase).
*
* The variable argument list consists of pairs of values. Each
* pair is a string which is the formal argument name in the
* calling function, followed by the argument value. The type
* of the argument value is given by the TYPE string.
*
* Note: The TYPE string is meant to be terse and is generated by a
* separate perl script.
*
* WARNING: DO NOT CALL ANY HDF5 FUNCTION THAT CALLS FUNC_ENTER(). DOING
* SO MAY CAUSE H5_trace() TO BE INVOKED RECURSIVELY OR MAY
* CAUSE LIBRARY INITIALIZATIONS THAT ARE NOT DESIRED.
*
* Return: void
*
* Programmer: Robb Matzke
* Tuesday, June 16, 1998
*
* Modifications:
* Robb Matzke, 1999-08-02
* Added the `a' type letter for haddr_t arguments and `Mt' for
* H5FD_mem_t arguments.
*
* Robb Matzke, 1999-10-25
* The `Ej' and `En' types are H5E_major_t and H5E_minor_t error
* types. We only print the integer value here.
*
* Robb Matzke, 2002-08-08
* Better output for nested calls. Show only top-level calls
* if so desired. Show event times if so desired.
*-------------------------------------------------------------------------
*/
double
H5_trace (const double *returning, const char *func, const char *type, ...)
{
va_list ap;
char buf[64], *rest;
const char *argname;
int argno=0, ptr, asize_idx;
hssize_t asize[16];
hssize_t i;
void *vp = NULL;
FILE *out = H5_debug_g.trace;
H5_timer_t event_time;
static H5_timer_t first_time = {0.0, 0.0, 0.0};
static int current_depth=0;
static int last_call_depth=0;
/* FUNC_ENTER() should not be called */
if (!out) return 0.0; /*tracing is off*/
va_start (ap, type);
if (H5_debug_g.ttop) {
if (returning) {
if (current_depth>1) {
--current_depth;
return 0.0;
}
} else {
if (current_depth>0) {
/*do not update last_call_depth*/
current_depth++;
return 0.0;
}
}
}
/* Get tim for event */
if (fabs(first_time.etime) < 0.0000000001)
/* That is == 0.0, but direct comparison between floats is bad */
H5_timer_begin(&first_time);
if (H5_debug_g.ttimes) {
H5_timer_begin(&event_time);
} else {
HDmemset(&event_time, 0, sizeof event_time);
}
/* Print the first part of the line. This is the indication of the
* nesting depth followed by the function name and either start of
* argument list or start of return value. If this call is for a
* function return and no other calls have been made to H5_trace()
* since the one for the function call, then we're continuing
* the same line. */
if (returning) {
assert(current_depth>0);
--current_depth;
if (current_depth<last_call_depth) {
/* We are at the beginning of a line */
if (H5_debug_g.ttimes) {
char tmp[128];
sprintf(tmp, "%.6f", event_time.etime-first_time.etime);
fprintf(out, " %*s ", (int)strlen(tmp), "");
}
for (i=0; i<current_depth; i++)
fputc('+', out);
fprintf(out, "%*s%s = ", 2*current_depth, "", func);
} else {
/* Continue current line with return value */
fprintf(out, " = ");
}
} else {
if (current_depth>last_call_depth)
fputs(" = <delayed>\n", out);
if (H5_debug_g.ttimes)
fprintf(out, "@%.6f ", event_time.etime-first_time.etime);
for (i=0; i<current_depth; i++)
fputc('+', out);
fprintf(out, "%*s%s(", 2*current_depth, "", func);
}
/* Clear array sizes */
for (i=0; i<(hssize_t)NELMTS(asize); i++) asize[i] = -1;
/* Parse the argument types */
for (argno=0; *type; argno++, type+=HDisupper(*type)?2:1) {
/* Count levels of indirection */
for (ptr=0; '*'==*type; type++) ptr++;
if ('['==*type) {
if ('a'==type[1]) {
asize_idx = (int)HDstrtol(type+2, &rest, 10);
assert(']'==*rest);
type = rest+1;
} else {
rest = (char *)HDstrchr(type, ']');
assert(rest);
type = rest+1;
asize_idx = -1;
}
} else {
asize_idx = -1;
}
/*
* The argument name. Leave off the `_id' part. If the argument
* name is the null pointer then don't print the argument or the
* following `='. This is used for return values.
*/
argname = va_arg (ap, char*); /*lint !e64 Type mismatch not really occuring */
if (argname) {
unsigned n = (unsigned)MAX (0, (int)HDstrlen(argname)-3); /*lint !e666 Allow expression with side effects */
if (!HDstrcmp (argname+n, "_id")) {
HDstrncpy (buf, argname, MIN ((int)sizeof(buf)-1, n));
buf[MIN((int)sizeof(buf)-1, n)] = '\0';
argname = buf;
}
fprintf (out, "%s%s=", argno?", ":"", argname);
} else {
argname = "";
}
/* The value */
if (ptr) vp = va_arg (ap, void*); /*lint !e64 Type mismatch not really occuring */
switch (type[0]) {
case 'a':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
haddr_t addr = va_arg(ap, haddr_t); /*lint !e732 Loss of sign not really occuring */
HDfprintf(out, "%a", addr);
}
break;
case 'b':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
hbool_t bool_var = va_arg (ap, hbool_t); /*lint !e732 Loss of sign not really occuring */
if (TRUE==bool_var) fprintf (out, "TRUE");
else if (!bool_var) fprintf (out, "FALSE");
else fprintf (out, "TRUE(%u)", (unsigned)bool_var);
}
break;
case 'd':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
double dbl = va_arg (ap, double);
fprintf (out, "%g", dbl);
}
break;
case 'D':
switch (type[1]) {
case 'a':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5D_alloc_time_t alloc_time = va_arg (ap, H5D_alloc_time_t); /*lint !e64 Type mismatch not really occuring */
switch (alloc_time) {
case H5D_ALLOC_TIME_ERROR:
fprintf (out, "H5D_ALLOC_TIME_ERROR");
break;
case H5D_ALLOC_TIME_DEFAULT:
fprintf (out, "H5D_ALLOC_TIME_DEFAULT");
break;
case H5D_ALLOC_TIME_EARLY:
fprintf (out, "H5D_ALLOC_TIME_EARLY");
break;
case H5D_ALLOC_TIME_LATE:
fprintf (out, "H5D_ALLOC_TIME_LATE");
break;
case H5D_ALLOC_TIME_INCR:
fprintf (out, "H5D_ALLOC_TIME_INCR");
break;
}
}
break;
case 'f':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5D_fill_time_t fill_time = va_arg (ap, H5D_fill_time_t); /*lint !e64 Type mismatch not really occuring */
switch (fill_time) {
case H5D_FILL_TIME_ERROR:
fprintf (out, "H5D_FILL_TIME_ERROR");
break;
case H5D_FILL_TIME_ALLOC:
fprintf (out, "H5D_FILL_TIME_ALLOC");
break;
case H5D_FILL_TIME_NEVER:
fprintf (out, "H5D_FILL_TIME_NEVER");
break;
case H5D_FILL_TIME_IFSET:
fprintf (out, "H5D_FILL_TIME_IFSET");
break;
}
}
break;
case 'F':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5D_fill_value_t fill_value = va_arg (ap, H5D_fill_value_t); /*lint !e64 Type mismatch not really occuring */
switch (fill_value) {
case H5D_FILL_VALUE_ERROR:
fprintf (out, "H5D_FILL_VALUE_ERROR");
break;
case H5D_FILL_VALUE_UNDEFINED:
fprintf (out, "H5D_FILL_VALUE_UNDEFINED");
break;
case H5D_FILL_VALUE_DEFAULT:
fprintf (out, "H5D_FILL_VALUE_DEFAULT");
break;
case H5D_FILL_VALUE_USER_DEFINED:
fprintf (out, "H5D_FILL_VALUE_USER_DEFINED");
break;
}
}
break;
case 'l':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5D_layout_t layout = va_arg (ap, H5D_layout_t); /*lint !e64 Type mismatch not really occuring */
switch (layout) {
case H5D_LAYOUT_ERROR:
fprintf (out, "H5D_LAYOUT_ERROR");
break;
case H5D_COMPACT:
fprintf (out, "H5D_COMPACT");
break;
case H5D_CONTIGUOUS:
fprintf (out, "H5D_CONTIGUOUS");
break;
case H5D_CHUNKED:
fprintf (out, "H5D_CHUNKED");
break;
case H5D_NLAYOUTS:
fprintf (out, "H5D_NLAYOUTS");
break;
default:
fprintf (out, "%ld", (long)layout);
break;
}
}
break;
case 's':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5D_space_status_t space_status = va_arg(ap, H5D_space_status_t); /*lint !e64 Type mismatch not really occuring */
switch (space_status) {
case H5D_SPACE_STATUS_NOT_ALLOCATED:
fprintf (out, "H5D_SPACE_STATUS_NOT_ALLOCATED");
break;
case H5D_SPACE_STATUS_PART_ALLOCATED:
fprintf (out, "H5D_SPACE_STATUS_PART_ALLOCATED");
break;
case H5D_SPACE_STATUS_ALLOCATED:
fprintf (out, "H5D_SPACE_STATUS_ALLOCATED");
break;
case H5D_SPACE_STATUS_ERROR:
fprintf (out, "H5D_SPACE_STATUS_ERROR");
break;
default:
fprintf (out, "%ld", (long)space_status);
break;
}
}
break;
case 't':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5FD_mpio_xfer_t transfer = va_arg(ap, H5FD_mpio_xfer_t); /*lint !e64 Type mismatch not really occuring */
switch (transfer) {
case H5FD_MPIO_INDEPENDENT:
fprintf (out, "H5FD_MPIO_INDEPENDENT");
break;
case H5FD_MPIO_COLLECTIVE:
fprintf (out, "H5FD_MPIO_COLLECTIVE");
break;
default:
fprintf (out, "%ld", (long)transfer);
break;
}
}
break;
default:
fprintf (out, "BADTYPE(D%c)", type[1]);
goto error;
}
break;
case 'e':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
herr_t status = va_arg (ap, herr_t);
if (status>=0) fprintf (out, "SUCCEED");
else fprintf (out, "FAIL");
}
break;
case 'E':
switch (type[1]) {
case 'd':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5E_direction_t direction = va_arg (ap, H5E_direction_t); /*lint !e64 Type mismatch not really occuring */
switch (direction) {
case H5E_WALK_UPWARD:
fprintf (out, "H5E_WALK_UPWARD");
break;
case H5E_WALK_DOWNWARD:
fprintf (out, "H5E_WALK_DOWNWARD");
break;
default:
fprintf (out, "%ld", (long)direction);
break;
}
}
break;
case 'e':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5E_error_t *error = va_arg (ap, H5E_error_t*); /*lint !e64 Type mismatch not really occuring */
fprintf (out, "0x%lx", (unsigned long)error);
}
break;
case 't':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5E_type_t etype = va_arg (ap, H5E_type_t); /*lint !e64 Type mismatch not really occuring */
switch (etype) {
case H5E_MAJOR:
fprintf (out, "H5E_MAJOR");
break;
case H5E_MINOR:
fprintf (out, "H5E_MINOR");
break;
default:
fprintf (out, "%ld", (long)etype);
break;
}
}
break;
default:
fprintf (out, "BADTYPE(E%c)", type[1]);
goto error;
}
break;
case 'F':
switch (type[1]) {
case 'd':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5F_close_degree_t degree = va_arg(ap, H5F_close_degree_t); /*lint !e64 Type mismatch not really occuring */
switch (degree) {
case H5F_CLOSE_DEFAULT:
fprintf(out, "H5F_CLOSE_DEFAULT");
break;
case H5F_CLOSE_WEAK:
fprintf(out, "H5F_CLOSE_WEAK");
break;
case H5F_CLOSE_SEMI:
fprintf(out, "H5F_CLOSE_SEMI");
break;
case H5F_CLOSE_STRONG:
fprintf(out, "H5F_CLOSE_STRONG");
break;
}
}
break;
case 's':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5F_scope_t scope = va_arg(ap, H5F_scope_t); /*lint !e64 Type mismatch not really occuring */
switch (scope) {
case H5F_SCOPE_LOCAL:
fprintf(out, "H5F_SCOPE_LOCAL");
break;
case H5F_SCOPE_GLOBAL:
fprintf(out, "H5F_SCOPE_GLOBAL");
break;
case H5F_SCOPE_DOWN:
fprintf(out, "H5F_SCOPE_DOWN "
"/*FOR INTERNAL USE ONLY!*/");
break;
}
}
break;
default:
fprintf(out, "BADTYPE(F%c)", type[1]);
goto error;
}
break;
case 'G':
switch (type[1]) {
case 'l':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5G_link_t link_type = va_arg (ap, H5G_link_t); /*lint !e64 Type mismatch not really occuring */
switch (link_type) {
case H5G_LINK_ERROR:
fprintf (out, "H5G_LINK_ERROR");
break;
case H5G_LINK_HARD:
fprintf (out, "H5G_LINK_HARD");
break;
case H5G_LINK_SOFT:
fprintf (out, "H5G_LINK_SOFT");
break;
default:
fprintf (out, "%ld", (long)link_type);
break;
}
}
break;
case 'o':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5G_obj_t obj_type = va_arg (ap, H5G_obj_t); /*lint !e64 Type mismatch not really occuring */
switch (obj_type) {
case H5G_UNKNOWN:
fprintf (out, "H5G_UNKNOWN");
break;
case H5G_LINK:
fprintf (out, "H5G_LINK");
break;
case H5G_GROUP:
fprintf (out, "H5G_GROUP");
break;
case H5G_DATASET:
fprintf (out, "H5G_DATASET");
break;
case H5G_TYPE:
fprintf (out, "H5G_TYPE");
break;
case H5G_RESERVED_4:
case H5G_RESERVED_5:
case H5G_RESERVED_6:
case H5G_RESERVED_7:
fprintf (out, "H5G_RESERVED(%ld)",(long)obj_type);
break;
default:
fprintf (out, "%ld", (long)obj_type);
break;
}
}
break;
case 's':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5G_stat_t *statbuf = va_arg (ap, H5G_stat_t*); /*lint !e64 Type mismatch not really occuring */
fprintf (out, "0x%lx", (unsigned long)statbuf);
}
break;
default:
fprintf (out, "BADTYPE(G%c)", type[1]);
goto error;
}
break;
case 'h':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
if (asize_idx>=0 && asize[asize_idx]>=0) {
hsize_t *p = (hsize_t*)vp;
fprintf(out, " {");
for (i=0; i<asize[asize_idx]; i++) {
if (H5S_UNLIMITED==p[i]) {
HDfprintf(out, "%sH5S_UNLIMITED", i?", ":"");
} else {
HDfprintf(out, "%s%Hu", i?", ":"", p[i]);
}
}
fprintf(out, "}");
}
} else {
fprintf(out, "NULL");
}
} else {
hsize_t hsize = va_arg (ap, hsize_t); /*lint !e732 Loss of sign not really occuring */
if (H5S_UNLIMITED==hsize) {
HDfprintf(out, "H5S_UNLIMITED");
} else {
HDfprintf (out, "%Hu", hsize);
asize[argno] = (hssize_t)hsize;
}
}
break;
case 'H':
switch (type[1]) {
case 's':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
if (asize_idx>=0 && asize[asize_idx]>=0) {
hssize_t *p = (hssize_t*)vp;
fprintf(out, " {");
for (i=0; i<asize[asize_idx]; i++) {
HDfprintf(out, "%s%Hd", i?", ":"", p[i]);
}
fprintf(out, "}");
}
} else {
fprintf(out, "NULL");
}
} else {
hssize_t hssize = va_arg (ap, hssize_t);
HDfprintf (out, "%Hd", hssize);
asize[argno] = (hssize_t)hssize;
}
break;
default:
fprintf (out, "BADTYPE(H%c)", type[1]);
goto error;
}
break;
case 'i':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
hid_t obj = va_arg (ap, hid_t);
if (H5P_DEFAULT == obj) {
fprintf (out, "H5P_DEFAULT");
} else if (obj<0) {
fprintf (out, "FAIL");
} else {
switch (H5I_TYPE(obj)) { /* Use internal H5I macro instead of function call */
case H5I_UNINIT:
fprintf (out, "%ld (uninit - error)", (long)obj);
break;
case H5I_BADID:
fprintf (out, "%ld (error)", (long)obj);
break;
case H5I_FILE:
fprintf(out, "%ld (file)", (long)obj);
break;
case H5I_FILE_CLOSING:
fprintf(out, "%ld (file closing)", (long)obj);
break;
case H5I_GROUP:
fprintf(out, "%ld (group)", (long)obj);
break;
case H5I_DATATYPE:
if (obj==H5T_NATIVE_SCHAR_g) {
fprintf(out, "H5T_NATIVE_SCHAR");
} else if (obj==H5T_NATIVE_UCHAR_g) {
fprintf(out, "H5T_NATIVE_UCHAR");
} else if (obj==H5T_NATIVE_SHORT_g) {
fprintf(out, "H5T_NATIVE_SHORT");
} else if (obj==H5T_NATIVE_USHORT_g) {
fprintf(out, "H5T_NATIVE_USHORT");
} else if (obj==H5T_NATIVE_INT_g) {
fprintf(out, "H5T_NATIVE_INT");
} else if (obj==H5T_NATIVE_UINT_g) {
fprintf(out, "H5T_NATIVE_UINT");
} else if (obj==H5T_NATIVE_LONG_g) {
fprintf(out, "H5T_NATIVE_LONG");
} else if (obj==H5T_NATIVE_ULONG_g) {
fprintf(out, "H5T_NATIVE_ULONG");
} else if (obj==H5T_NATIVE_LLONG_g) {
fprintf(out, "H5T_NATIVE_LLONG");
} else if (obj==H5T_NATIVE_ULLONG_g) {
fprintf(out, "H5T_NATIVE_ULLONG");
} else if (obj==H5T_NATIVE_FLOAT_g) {
fprintf(out, "H5T_NATIVE_FLOAT");
} else if (obj==H5T_NATIVE_DOUBLE_g) {
fprintf(out, "H5T_NATIVE_DOUBLE");
} else if (obj==H5T_NATIVE_LDOUBLE_g) {
fprintf(out, "H5T_NATIVE_LDOUBLE");
} else if (obj==H5T_IEEE_F32BE_g) {
fprintf(out, "H5T_IEEE_F32BE");
} else if (obj==H5T_IEEE_F32LE_g) {
fprintf(out, "H5T_IEEE_F32LE");
} else if (obj==H5T_IEEE_F64BE_g) {
fprintf(out, "H5T_IEEE_F64BE");
} else if (obj==H5T_IEEE_F64LE_g) {
fprintf(out, "H5T_IEEE_F64LE");
} else if (obj==H5T_STD_I8BE_g) {
fprintf(out, "H5T_STD_I8BE");
} else if (obj==H5T_STD_I8LE_g) {
fprintf(out, "H5T_STD_I8LE");
} else if (obj==H5T_STD_I16BE_g) {
fprintf(out, "H5T_STD_I16BE");
} else if (obj==H5T_STD_I16LE_g) {
fprintf(out, "H5T_STD_I16LE");
} else if (obj==H5T_STD_I32BE_g) {
fprintf(out, "H5T_STD_I32BE");
} else if (obj==H5T_STD_I32LE_g) {
fprintf(out, "H5T_STD_I32LE");
} else if (obj==H5T_STD_I64BE_g) {
fprintf(out, "H5T_STD_I64BE");
} else if (obj==H5T_STD_I64LE_g) {
fprintf(out, "H5T_STD_I64LE");
} else if (obj==H5T_STD_U8BE_g) {
fprintf(out, "H5T_STD_U8BE");
} else if (obj==H5T_STD_U8LE_g) {
fprintf(out, "H5T_STD_U8LE");
} else if (obj==H5T_STD_U16BE_g) {
fprintf(out, "H5T_STD_U16BE");
} else if (obj==H5T_STD_U16LE_g) {
fprintf(out, "H5T_STD_U16LE");
} else if (obj==H5T_STD_U32BE_g) {
fprintf(out, "H5T_STD_U32BE");
} else if (obj==H5T_STD_U32LE_g) {
fprintf(out, "H5T_STD_U32LE");
} else if (obj==H5T_STD_U64BE_g) {
fprintf(out, "H5T_STD_U64BE");
} else if (obj==H5T_STD_U64LE_g) {
fprintf(out, "H5T_STD_U64LE");
} else if (obj==H5T_STD_B8BE_g) {
fprintf(out, "H5T_STD_B8BE");
} else if (obj==H5T_STD_B8LE_g) {
fprintf(out, "H5T_STD_B8LE");
} else if (obj==H5T_STD_B16BE_g) {
fprintf(out, "H5T_STD_B16BE");
} else if (obj==H5T_STD_B16LE_g) {
fprintf(out, "H5T_STD_B16LE");
} else if (obj==H5T_STD_B32BE_g) {
fprintf(out, "H5T_STD_B32BE");
} else if (obj==H5T_STD_B32LE_g) {
fprintf(out, "H5T_STD_B32LE");
} else if (obj==H5T_STD_B64BE_g) {
fprintf(out, "H5T_STD_B64BE");
} else if (obj==H5T_STD_B64LE_g) {
fprintf(out, "H5T_STD_B64LE");
} else if (obj==H5T_C_S1_g) {
fprintf(out, "H5T_C_S1");
} else if (obj==H5T_FORTRAN_S1_g) {
fprintf(out, "H5T_FORTRAN_S1");
} else {
fprintf(out, "%ld (dtype)", (long)obj);
}
break;
case H5I_DATASPACE:
fprintf(out, "%ld (dspace)", (long)obj);
/* Save the rank of simple data spaces for arrays */
/* This may generate recursive call to the library... -QAK */
{
H5S_t *space = H5I_object(obj);
if (H5S_SIMPLE==H5S_GET_EXTENT_TYPE(space)) {
asize[argno] = H5S_GET_EXTENT_NDIMS(space);
}
}
break;
case H5I_DATASET:
fprintf(out, "%ld (dset)", (long)obj);
break;
case H5I_ATTR:
fprintf(out, "%ld (attr)", (long)obj);
break;
case H5I_REFERENCE:
fprintf(out, "%ld (reference)", (long)obj);
break;
case H5I_VFL:
fprintf(out, "%ld (file driver)", (long)obj);
break;
case H5I_GENPROP_CLS:
fprintf(out, "%ld (genprop class)", (long)obj);
break;
case H5I_GENPROP_LST:
fprintf(out, "%ld (genprop list)", (long)obj);
break;
case H5I_ERROR_CLASS:
fprintf(out, "%ld (err class)", (long)obj);
break;
case H5I_ERROR_MSG:
fprintf(out, "%ld (err msg)", (long)obj);
break;
case H5I_ERROR_STACK:
fprintf(out, "%ld (err stack)", (long)obj);
break;
case H5I_NTYPES:
fprintf (out, "%ld (ntypes - error)", (long)obj);
break;
default:
fprintf(out, "%ld (unknown class)", (long)obj);
break;
}
}
}
break;
case 'I':
switch (type[1]) {
case 's':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
if (asize_idx>=0 && asize[asize_idx]>=0) {
int *p = (int*)vp;
fprintf(out, " {");
for (i=0; i<asize[asize_idx]; i++) {
fprintf(out, "%s%d", i?", ":"", p[i]);
}
fprintf(out, "}");
}
} else {
fprintf(out, "NULL");
}
} else {
int is = va_arg (ap, int);
fprintf (out, "%d", is);
asize[argno] = is;
}
break;
case 'u':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
if (asize_idx>=0 && asize[asize_idx]>=0) {
unsigned *p = (unsigned*)vp;
fprintf(out, " {");
for (i=0; i<asize[asize_idx]; i++) {
HDfprintf(out, "%s%u", i?", ":"", p[i]);
}
fprintf(out, "}");
}
} else {
fprintf(out, "NULL");
}
} else {
unsigned iu = va_arg (ap, unsigned); /*lint !e732 Loss of sign not really occuring */
fprintf (out, "%u", iu);
asize[argno] = iu;
}
break;
case 't':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5I_type_t id_type = va_arg (ap, H5I_type_t); /*lint !e64 Type mismatch not really occuring */
switch (id_type) {
case H5I_UNINIT:
fprintf (out, "H5I_UNINIT");
break;
case H5I_BADID:
fprintf (out, "H5I_BADID");
break;
case H5I_FILE:
fprintf (out, "H5I_FILE");
break;
case H5I_FILE_CLOSING:
fprintf (out, "H5I_FILE_CLOSING");
break;
case H5I_GROUP:
fprintf (out, "H5I_GROUP");
break;
case H5I_DATATYPE:
fprintf (out, "H5I_DATATYPE");
break;
case H5I_DATASPACE:
fprintf (out, "H5I_DATASPACE");
break;
case H5I_DATASET:
fprintf (out, "H5I_DATASET");
break;
case H5I_ATTR:
fprintf (out, "H5I_ATTR");
break;
case H5I_REFERENCE:
fprintf (out, "H5I_REFERENCE");
break;
case H5I_VFL:
fprintf (out, "H5I_VFL");
break;
case H5I_GENPROP_CLS:
fprintf (out, "H5I_GENPROP_CLS");
break;
case H5I_GENPROP_LST:
fprintf (out, "H5I_GENPROP_LST");
break;
case H5I_ERROR_CLASS:
fprintf (out, "H5I_ERROR_CLASS");
break;
case H5I_ERROR_MSG:
fprintf (out, "H5I_ERROR_MSG");
break;
case H5I_ERROR_STACK:
fprintf (out, "H5I_ERROR_STACK");
break;
case H5I_NTYPES:
fprintf (out, "H5I_NTYPES");
break;
default:
fprintf (out, "%ld", (long)id_type);
break;
}
}
break;
default:
fprintf (out, "BADTYPE(I%c)", type[1]);
goto error;
}
break;
case 'M':
switch (type[1]) {
case 'c':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
#ifdef H5_HAVE_PARALLEL
MPI_Comm comm = va_arg (ap, MPI_Comm);
fprintf (out, "%ld", (long)comm);
#endif
}
break;
case 'i':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
#ifdef H5_HAVE_PARALLEL
MPI_Info info = va_arg (ap, MPI_Info);
fprintf (out, "%ld", (long)info);
#endif
}
break;
case 't':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5FD_mem_t mt = va_arg(ap, H5FD_mem_t); /*lint !e64 Type mismatch not really occuring */
switch (mt) {
case H5FD_MEM_NOLIST:
fprintf(out, "H5FD_MEM_NOLIST");
break;
case H5FD_MEM_DEFAULT:
fprintf(out, "H5FD_MEM_DEFAULT");
break;
case H5FD_MEM_SUPER:
fprintf(out, "H5FD_MEM_SUPER");
break;
case H5FD_MEM_BTREE:
fprintf(out, "H5FD_MEM_BTREE");
break;
case H5FD_MEM_DRAW:
fprintf(out, "H5FD_MEM_DRAW");
break;
case H5FD_MEM_GHEAP:
fprintf(out, "H5FD_MEM_GHEAP");
break;
case H5FD_MEM_LHEAP:
fprintf(out, "H5FD_MEM_LHEAP");
break;
case H5FD_MEM_OHDR:
fprintf(out, "H5FD_MEM_OHDR");
break;
case H5FD_MEM_NTYPES:
fprintf(out, "H5FD_MEM_NTYPES");
break;
default:
fprintf(out, "%ld", (long)mt);
break;
}
}
break;
default:
goto error;
}
break;
case 'o':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
off_t offset = va_arg (ap, off_t);
fprintf (out, "%ld", (long)offset);
}
break;
case 'p':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
hid_t pclass_id = va_arg (ap, hid_t);
char *class_name=NULL;
H5P_genclass_t *pclass;
/* Get the class name and print it */
/* This may generate recursive call to the library... -QAK */
if(NULL != (pclass = H5I_object(pclass_id)) &&
(class_name=H5P_get_class_name(pclass))!=NULL) {
fprintf (out, class_name);
H5MM_xfree(class_name);
} /* end if */
else {
fprintf (out, "%ld", (long)pclass_id);
} /* end else */
}
break;
case 'r':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
hobj_ref_t ref = va_arg (ap, hobj_ref_t); /*lint !e732 Loss of sign not really occuring */
HDfprintf(out, "Reference Object=%a", ref);
}
break;
case 'R':
switch (type[1]) {
case 't':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5R_type_t reftype = va_arg(ap, H5R_type_t); /*lint !e64 Type mismatch not really occuring */
switch (reftype) {
case H5R_BADTYPE:
fprintf(out, "H5R_BADTYPE");
break;
case H5R_OBJECT:
fprintf(out, "H5R_OBJECT");
break;
case H5R_DATASET_REGION:
fprintf(out, "H5R_DATASET_REGION");
break;
case H5R_INTERNAL:
fprintf(out, "H5R_INTERNAL");
break;
case H5R_MAXTYPE:
fprintf(out, "H5R_MAXTYPE");
break;
default:
fprintf(out, "BADTYPE(%ld)", (long)reftype);
break;
}
}
break;
default:
fprintf(out, "BADTYPE(S%c)", type[1]);
goto error;
}
break;
case 'S':
switch (type[1]) {
case 'c':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5S_class_t cls = va_arg(ap, H5S_class_t); /*lint !e64 Type mismatch not really occuring */
switch (cls) {
case H5S_NO_CLASS:
fprintf(out, "H5S_NO_CLASS");
break;
case H5S_SCALAR:
fprintf(out, "H5S_SCALAR");
break;
case H5S_SIMPLE:
fprintf(out, "H5S_SIMPLE");
break;
case H5S_NULL:
fprintf(out, "H5S_NULL");
break;
case H5S_COMPLEX:
fprintf(out, "H5S_COMPLEX");
break;
default:
fprintf(out, "%ld", (long)cls);
break;
}
}
break;
case 's':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5S_seloper_t so = va_arg(ap, H5S_seloper_t); /*lint !e64 Type mismatch not really occuring */
switch (so) {
case H5S_SELECT_NOOP:
fprintf(out, "H5S_NOOP");
break;
case H5S_SELECT_SET:
fprintf(out, "H5S_SELECT_SET");
break;
case H5S_SELECT_OR:
fprintf(out, "H5S_SELECT_OR");
break;
case H5S_SELECT_AND:
fprintf(out, "H5S_SELECT_AND");
break;
case H5S_SELECT_XOR:
fprintf(out, "H5S_SELECT_XOR");
break;
case H5S_SELECT_NOTB:
fprintf(out, "H5S_SELECT_NOTB");
break;
case H5S_SELECT_NOTA:
fprintf(out, "H5S_SELECT_NOTA");
break;
case H5S_SELECT_APPEND:
fprintf(out, "H5S_SELECT_APPEND");
break;
case H5S_SELECT_PREPEND:
fprintf(out, "H5S_SELECT_PREPEND");
break;
case H5S_SELECT_INVALID:
fprintf(out, "H5S_SELECT_INVALID");
break;
default:
fprintf(out, "%ld", (long)so);
break;
}
}
break;
case 't':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5S_sel_type st = va_arg(ap, H5S_sel_type); /*lint !e64 Type mismatch not really occuring */
switch (st) {
case H5S_SEL_ERROR:
fprintf(out, "H5S_SEL_ERROR");
break;
case H5S_SEL_NONE:
fprintf(out, "H5S_SEL_NONE");
break;
case H5S_SEL_POINTS:
fprintf(out, "H5S_SEL_POINTS");
break;
case H5S_SEL_HYPERSLABS:
fprintf(out, "H5S_SEL_HYPERSLABS");
break;
case H5S_SEL_ALL:
fprintf(out, "H5S_SEL_ALL");
break;
case H5S_SEL_N:
fprintf(out, "H5S_SEL_N");
break;
default:
fprintf(out, "%ld", (long)st);
break;
}
}
break;
default:
fprintf(out, "BADTYPE(S%c)", type[1]);
goto error;
}
break;
case 's':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
const char *str = va_arg (ap, const char*); /*lint !e64 Type mismatch not really occuring */
fprintf (out, "\"%s\"", str);
}
break;
case 'T':
switch (type[1]) {
case 'c':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_cset_t cset = va_arg (ap, H5T_cset_t); /*lint !e64 Type mismatch not really occuring */
switch (cset) {
case H5T_CSET_ERROR:
fprintf (out, "H5T_CSET_ERROR");
break;
case H5T_CSET_ASCII:
fprintf (out, "H5T_CSET_ASCII");
break;
case H5T_CSET_RESERVED_1:
case H5T_CSET_RESERVED_2:
case H5T_CSET_RESERVED_3:
case H5T_CSET_RESERVED_4:
case H5T_CSET_RESERVED_5:
case H5T_CSET_RESERVED_6:
case H5T_CSET_RESERVED_7:
case H5T_CSET_RESERVED_8:
case H5T_CSET_RESERVED_9:
case H5T_CSET_RESERVED_10:
case H5T_CSET_RESERVED_11:
case H5T_CSET_RESERVED_12:
case H5T_CSET_RESERVED_13:
case H5T_CSET_RESERVED_14:
case H5T_CSET_RESERVED_15:
fprintf (out, "H5T_CSET_RESERVED(%ld)",(long)cset);
break;
default:
fprintf (out, "%ld", (long)cset);
break;
}
}
break;
case 'd':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_direction_t direct = va_arg (ap, H5T_direction_t); /*lint !e64 Type mismatch not really occuring */
switch (direct) {
case H5T_DIR_DEFAULT:
fprintf (out, "H5T_DIR_DEFAULT");
break;
case H5T_DIR_ASCEND:
fprintf (out, "H5T_DIR_ASCEND");
break;
case H5T_DIR_DESCEND:
fprintf (out, "H5T_DIR_DESCEND");
break;
default:
fprintf (out, "%ld", (long)direct);
break;
}
}
break;
case 'e':
if (ptr) {
if (vp) {
fprintf(out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_pers_t pers = va_arg(ap, H5T_pers_t); /*lint !e64 Type mismatch not really occuring */
switch (pers) {
case H5T_PERS_DONTCARE:
fprintf(out, "H5T_PERS_DONTCARE");
break;
case H5T_PERS_SOFT:
fprintf(out, "H5T_PERS_SOFT");
break;
case H5T_PERS_HARD:
fprintf(out, "H5T_PERS_HARD");
break;
default:
fprintf(out, "%ld", (long)pers);
break;
}
}
break;
case 'n':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_norm_t norm = va_arg (ap, H5T_norm_t); /*lint !e64 Type mismatch not really occuring */
switch (norm) {
case H5T_NORM_ERROR:
fprintf (out, "H5T_NORM_ERROR");
break;
case H5T_NORM_IMPLIED:
fprintf (out, "H5T_NORM_IMPLIED");
break;
case H5T_NORM_MSBSET:
fprintf (out, "H5T_NORM_MSBSET");
break;
case H5T_NORM_NONE:
fprintf (out, "H5T_NORM_NONE");
break;
default:
fprintf (out, "%ld", (long)norm);
break;
}
}
break;
case 'o':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_order_t order = va_arg (ap, H5T_order_t); /*lint !e64 Type mismatch not really occuring */
switch (order) {
case H5T_ORDER_ERROR:
fprintf (out, "H5T_ORDER_ERROR");
break;
case H5T_ORDER_LE:
fprintf (out, "H5T_ORDER_LE");
break;
case H5T_ORDER_BE:
fprintf (out, "H5T_ORDER_BE");
break;
case H5T_ORDER_VAX:
fprintf (out, "H5T_ORDER_VAX");
break;
case H5T_ORDER_NONE:
fprintf (out, "H5T_ORDER_NONE");
break;
default:
fprintf (out, "%ld", (long)order);
break;
}
}
break;
case 'p':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_pad_t pad = va_arg (ap, H5T_pad_t); /*lint !e64 Type mismatch not really occuring */
switch (pad) {
case H5T_PAD_ERROR:
fprintf (out, "H5T_PAD_ERROR");
break;
case H5T_PAD_ZERO:
fprintf (out, "H5T_PAD_ZERO");
break;
case H5T_PAD_ONE:
fprintf (out, "H5T_PAD_ONE");
break;
case H5T_PAD_BACKGROUND:
fprintf (out, "H5T_PAD_BACKGROUND");
break;
case H5T_NPAD:
fprintf (out, "H5T_NPAD");
break;
default:
fprintf (out, "%ld", (long)pad);
break;
}
}
break;
case 's':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_sign_t sign = va_arg (ap, H5T_sign_t); /*lint !e64 Type mismatch not really occuring */
switch (sign) {
case H5T_SGN_ERROR:
fprintf (out, "H5T_SGN_ERROR");
break;
case H5T_SGN_NONE:
fprintf (out, "H5T_SGN_NONE");
break;
case H5T_SGN_2:
fprintf (out, "H5T_SGN_2");
break;
case H5T_NSGN:
fprintf (out, "H5T_NSGN");
break;
default:
fprintf (out, "%ld", (long)sign);
break;
}
}
break;
case 't':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_class_t type_class = va_arg(ap, H5T_class_t); /*lint !e64 Type mismatch not really occuring */
switch (type_class) {
case H5T_NO_CLASS:
fprintf(out, "H5T_NO_CLASS");
break;
case H5T_INTEGER:
fprintf(out, "H5T_INTEGER");
break;
case H5T_FLOAT:
fprintf(out, "H5T_FLOAT");
break;
case H5T_TIME:
fprintf(out, "H5T_TIME");
break;
case H5T_STRING:
fprintf(out, "H5T_STRING");
break;
case H5T_BITFIELD:
fprintf(out, "H5T_BITFIELD");
break;
case H5T_OPAQUE:
fprintf(out, "H5T_OPAQUE");
break;
case H5T_COMPOUND:
fprintf(out, "H5T_COMPOUND");
break;
case H5T_REFERENCE:
fprintf(out, "H5T_REFERENCE");
break;
case H5T_ENUM:
fprintf(out, "H5T_ENUM");
break;
case H5T_VLEN:
fprintf(out, "H5T_VLEN");
break;
case H5T_ARRAY:
fprintf(out, "H5T_ARRAY");
break;
case H5T_NCLASSES:
fprintf(out, "H5T_NCLASSES");
break;
default:
fprintf(out, "%ld", (long)type_class);
break;
}
}
break;
case 'z':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5T_str_t str = va_arg(ap, H5T_str_t); /*lint !e64 Type mismatch not really occuring */
switch (str) {
case H5T_STR_ERROR:
fprintf(out, "H5T_STR_ERROR");
break;
case H5T_STR_NULLTERM:
fprintf(out, "H5T_STR_NULLTERM");
break;
case H5T_STR_NULLPAD:
fprintf(out, "H5T_STR_NULLPAD");
break;
case H5T_STR_SPACEPAD:
fprintf(out, "H5T_STR_SPACEPAD");
break;
case H5T_STR_RESERVED_3:
case H5T_STR_RESERVED_4:
case H5T_STR_RESERVED_5:
case H5T_STR_RESERVED_6:
case H5T_STR_RESERVED_7:
case H5T_STR_RESERVED_8:
case H5T_STR_RESERVED_9:
case H5T_STR_RESERVED_10:
case H5T_STR_RESERVED_11:
case H5T_STR_RESERVED_12:
case H5T_STR_RESERVED_13:
case H5T_STR_RESERVED_14:
case H5T_STR_RESERVED_15:
fprintf(out, "H5T_STR_RESERVED(%ld)",(long)str);
break;
default:
fprintf(out, "%ld", (long)str);
break;
}
}
break;
default:
fprintf (out, "BADTYPE(T%c)", type[1]);
goto error;
}
break;
case 't':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
htri_t tri_var = va_arg (ap, htri_t);
if (tri_var>0) fprintf (out, "TRUE");
else if (!tri_var) fprintf (out, "FALSE");
else fprintf (out, "FAIL(%d)", (int)tri_var);
}
break;
case 'x':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
if (asize_idx>=0 && asize[asize_idx]>=0) {
void **p = (void**)vp;
fprintf(out, " {");
for (i=0; i<asize[asize_idx]; i++) {
if (p[i]) {
fprintf(out, "%s0x%lx", i?", ":"",
(unsigned long)(p[i]));
} else {
fprintf(out, "%sNULL", i?", ":"");
}
}
fprintf(out, "}");
}
} else {
fprintf(out, "NULL");
}
} else {
vp = va_arg (ap, void*); /*lint !e64 Type mismatch not really occuring */
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
}
break;
case 'z':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
if (asize_idx>=0 && asize[asize_idx]>=0) {
size_t *p = (size_t*)vp;
fprintf(out, " {");
for (i=0; i<asize[asize_idx]; i++) {
HDfprintf(out, "%s%Zu", i?", ":"", p[i]);
}
fprintf(out, "}");
}
} else {
fprintf(out, "NULL");
}
} else {
size_t size = va_arg (ap, size_t); /*lint !e732 Loss of sign not really occuring */
HDfprintf (out, "%Zu", size);
asize[argno] = (hssize_t)size;
}
break;
case 'Z':
switch (type[1]) {
case 'c':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5Z_class_t *filter = va_arg (ap, H5Z_class_t*); /*lint !e64 Type mismatch not really occuring */
fprintf (out, "0x%lx", (unsigned long)filter);
}
break;
case 'e':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5Z_EDC_t edc = va_arg (ap, H5Z_EDC_t); /*lint !e64 Type mismatch not really occuring */
if (H5Z_DISABLE_EDC==edc) {
fprintf (out, "H5Z_DISABLE_EDC");
} else if (H5Z_ENABLE_EDC==edc) {
fprintf (out, "H5Z_ENABLE_EDC");
} else {
fprintf (out, "%ld", (long)edc);
}
}
break;
case 'f':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
} else {
fprintf(out, "NULL");
}
} else {
H5Z_filter_t id = va_arg (ap, H5Z_filter_t);
if (H5Z_FILTER_DEFLATE==id) {
fprintf (out, "H5Z_FILTER_DEFLATE");
} else {
fprintf (out, "%ld", (long)id);
}
}
break;
case 's':
if (ptr) {
if (vp) {
fprintf (out, "0x%lx", (unsigned long)vp);
if (asize_idx>=0 && asize[asize_idx]>=0) {
ssize_t *p = (ssize_t*)vp;
fprintf(out, " {");
for (i=0; i<asize[asize_idx]; i++) {
HDfprintf(out, "%s%Zd", i?", ":"", p[i]);
}
fprintf(out, "}");
}
} else {
fprintf(out, "NULL");
}
} else {
ssize_t ssize = va_arg (ap, ssize_t);
HDfprintf (out, "%Zd", ssize);
asize[argno] = (hssize_t)ssize;
}
break;
default:
fprintf (out, "BADTYPE(Z%c)", type[1]);
goto error;
}
break;
default:
if (HDisupper (type[0])) {
fprintf (out, "BADTYPE(%c%c)", type[0], type[1]);
} else {
fprintf (out, "BADTYPE(%c)", type[0]);
}
goto error;
}
}
/* Display event time for return */
if (returning && H5_debug_g.ttimes)
fprintf(out, " @%.6f [dt=%.6f]",
event_time.etime - first_time.etime,
event_time.etime - *returning);
error:
va_end (ap);
if (returning) {
fprintf (out, ";\n");
} else {
last_call_depth = current_depth++;
fprintf (out, ")");
}
HDfflush (out);
return event_time.etime;
}
Reference in New Issue View Git Blame Copy Permalink