mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-02-11 16:01:00 +08:00
Code Issues Packages Projects Releases Wiki Activity
fe6c92ebd3
hdf5/src/H5private.h
Scott Wegner 21134e48e1 [svn-r13916] Purpose: Fix MinGW inconsistency 
Description:
Windows does not accept the buffer size parameter of setvbuf to be less than 2.  Previously, we had our fix split between two files, H5private.h and the Windows H5pubconf.h.  This was a problem for MinGW, because it generates its own H5private.h.  This moves the fix out of H5pubconf.h and into H5private.h.

This shouldn't affect other platforms.

Tested:
MinGW on WinXP
2007-06-26 11:23:59 -05:00

1420 lines
50 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* 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://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Programmer: Robb Matzke <matzke@llnl.gov>
* Friday, October 30, 1998
*
* Purpose: This file is included by all HDF5 library source files to
* define common things which are not defined in the HDF5 API.
* The configuration constants like H5_HAVE_UNISTD_H etc. are
* defined in H5config.h which is included by H5public.h.
*
*/
#ifndef _H5private_H
#define _H5private_H
#include "H5public.h" /* Include Public Definitions */
/* include the pthread header */
#ifdef H5_HAVE_THREADSAFE
#include <pthread.h>
#endif
/*
* Include ANSI-C header files.
*/
#ifdef H5_STDC_HEADERS
# include <assert.h>
# include <ctype.h>
# include <errno.h>
# include <fcntl.h>
# include <float.h>
# include <limits.h>
# include <math.h>
# include <signal.h>
# include <stdarg.h>
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
#endif
/*
* If _POSIX_VERSION is defined in unistd.h then this system is Posix.1
* compliant. Otherwise all bets are off.
*/
#ifdef H5_HAVE_UNISTD_H
# include <sys/types.h>
# include <unistd.h>
#endif
#ifdef _POSIX_VERSION
# include <sys/wait.h>
# include <pwd.h>
#endif
/*
* C9x integer types
*/
#ifndef __cplusplus
#ifdef H5_HAVE_STDINT_H
# include <stdint.h>
#endif
#endif
/*
* The `struct stat' data type for stat() and fstat(). This is a Posix file
* but often apears on non-Posix systems also. The `struct stat' is required
* for hdf5 to compile, although only a few fields are actually used.
*/
#ifdef H5_HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
/*
* If a program may include both `time.h' and `sys/time.h' then
* TIME_WITH_SYS_TIME is defined (see AC_HEADER_TIME in configure.in).
* On some older systems, `sys/time.h' includes `time.h' but `time.h' is not
* protected against multiple inclusion, so programs should not explicitly
* include both files. This macro is useful in programs that use, for example,
* `struct timeval' or `struct timezone' as well as `struct tm'. It is best
* used in conjunction with `HAVE_SYS_TIME_H', whose existence is checked
* by `AC_CHECK_HEADERS(sys/time.h)' in configure.in.
*/
#if defined(H5_TIME_WITH_SYS_TIME)
# include <sys/time.h>
# include <time.h>
#elif defined(H5_HAVE_SYS_TIME_H)
# include <sys/time.h>
#else
# include <time.h>
#endif
/*
* Longjumps are used to detect alignment constrants
*/
#ifdef H5_HAVE_SETJMP_H
# include <setjmp.h>
#endif
/*
* Resource usage is not Posix.1 but HDF5 uses it anyway for some performance
* and debugging code if available.
*/
#ifdef H5_HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
#endif
/*
* Unix ioctls. These are used by h5ls (and perhaps others) to determine a
* resonable output width.
*/
#ifdef H5_HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
/*
* System information. These are needed on the DEC Alpha to turn off fixing
* of unaligned accesses by the operating system during detection of
* alignment constraints in H5detect.c:main().
*/
#ifdef H5_HAVE_SYS_SYSINFO_H
# include <sys/sysinfo.h>
#endif
#ifdef H5_HAVE_SYS_PROC_H
# include <sys/proc.h>
#endif
#ifdef H5_HAVE_IO_H
# include <io.h>
#endif
#ifdef _WIN32
#define VC_EXTRALEAN /*Exclude rarely-used stuff from Windows headers */
#include <windows.h>
#endif /*_WIN32*/
/* H5_inline */
#ifndef H5_inline
#define H5_inline
#endif /* H5_inline */
#ifndef F_OK
# define F_OK 00
# define W_OK 02
# define R_OK 04
#endif
/*
* MPE Instrumentation support
*/
#ifdef H5_HAVE_MPE
/*------------------------------------------------------------------------
* Purpose: Begin to collect MPE log information for a function. It should
* be ahead of the actual function's process.
*
* Programmer: Long Wang
*
*------------------------------------------------------------------------
*/
#include "mpe.h"
/*
* #define eventa(func_name) h5_mpe_ ## func_name ## _a
* #define eventb(func_name) h5_mpe_ ## func_name ## _b
*/
#define eventa(func_name) h5_mpe_eventa
#define eventb(func_name) h5_mpe_eventb
#define MPE_LOG_VARS(func_name) \
static int eventa(func_name) = -1; \
static int eventb(func_name) = -1; \
const char* p_end_funcname = #func_name; \
const char* p_event_start = "start" #func_name;
/* Hardwire the color to "red", since that's what all the routines are using
* now. In the future, if we want to change that color for a given routine,
* we should define a "FUNC_ENTER_API_COLOR" macro which takes an extra 'color'
* parameter and then make additional FUNC_ENTER_<foo>_COLOR macros to get that
* color information down to the BEGIN_MPE_LOG macro (which should have a new
* BEGIN_MPE_LOG_COLOR variant). -QAK
*/
#define BEGIN_MPE_LOG(func_name) \
if (H5_MPEinit_g){ \
if (eventa(func_name) == -1 && eventb(func_name) == -1) { \
const char* p_color = "red"; \
eventa(func_name)=MPE_Log_get_event_number(); \
eventb(func_name)=MPE_Log_get_event_number(); \
MPE_Describe_state(eventa(func_name), eventb(func_name), (char *)p_end_funcname, (char *)p_color); \
} \
MPE_Log_event(eventa(func_name), 0, (char *)p_event_start); \
}
/*------------------------------------------------------------------------
* Purpose: Finish the collection of MPE log information for a function.
* It should be after the actual function's process.
*
* Programmer: Long Wang
*/
#define FINISH_MPE_LOG \
if (H5_MPEinit_g) { \
MPE_Log_event(eventb(func_name), 0, (char *)p_end_funcname); \
}
#else /* H5_HAVE_MPE */
#define MPE_LOG_VARS(func_name) /* void */
#define BEGIN_MPE_LOG(func_name) /* void */
#define FINISH_MPE_LOG /* void */
#endif /* H5_HAVE_MPE */
/*
* dmalloc (debugging malloc) support
*/
#ifdef H5_HAVE_DMALLOC_H
#include "dmalloc.h"
#endif /* H5_HAVE_DMALLOC_H */
/*
* NT doesn't define SIGBUS, but since NT only runs on processors
* that do not have alignment constraints a SIGBUS would never be
* raised, so we just replace it with SIGILL (which also should
* never be raised by the hdf5 library).
*/
#ifndef SIGBUS
# define SIGBUS SIGILL
#endif
/*
* Does the compiler support the __attribute__(()) syntax? This is how gcc
* suppresses warnings about unused function arguments. It's no big deal if
* we don't.
*/
#ifdef __cplusplus
# define __attribute__(X) /*void*/
# define UNUSED /*void*/
#else /* __cplusplus */
#ifdef H5_HAVE_ATTRIBUTE
# define UNUSED __attribute__((unused))
#else
# define __attribute__(X) /*void*/
# define UNUSED /*void*/
#endif
#endif /* __cplusplus */
/*
* Does the compiler expand __FUNCTION__ to be the name of the function
* currently being defined? If not then define it to be some constant
* string.
*/
#ifndef H5_HAVE_FUNCTION
# define __FUNCTION__ "NoFunctionName"
#endif
/*
* Status return values for the `herr_t' type.
* Since some unix/c routines use 0 and -1 (or more precisely, non-negative
* vs. negative) as their return code, and some assumption had been made in
* the code about that, it is important to keep these constants the same
* values. When checking the success or failure of an integer-valued
* function, remember to compare against zero and not one of these two
* values.
*/
#define SUCCEED 0
#define FAIL (-1)
#define UFAIL (unsigned)(-1)
/* number of members in an array */
#ifndef NELMTS
# define NELMTS(X) (sizeof(X)/sizeof(X[0]))
#endif
/* minimum of two, three, or four values */
#undef MIN
#define MIN(a,b) (((a)<(b)) ? (a) : (b))
#define MIN2(a,b) MIN(a,b)
#define MIN3(a,b,c) MIN(a,MIN(b,c))
#define MIN4(a,b,c,d) MIN(MIN(a,b),MIN(c,d))
/* maximum of two, three, or four values */
#undef MAX
#define MAX(a,b) (((a)>(b)) ? (a) : (b))
#define MAX2(a,b) MAX(a,b)
#define MAX3(a,b,c) MAX(a,MAX(b,c))
#define MAX4(a,b,c,d) MAX(MAX(a,b),MAX(c,d))
/* limit the middle value to be within a range (inclusive) */
#define RANGE(LO,X,HI) MAX(LO,MIN(X,HI))
/* absolute value */
#ifndef ABS
# define ABS(a) (((a)>=0) ? (a) : -(a))
#endif
/* sign of argument */
#ifndef SIGN
# define SIGN(a) ((a)>0 ? 1 : (a)<0 ? -1 : 0)
#endif
/* test for number that is a power of 2 */
/* (from: http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2) */
# define POWER_OF_TWO(n) (!(n & (n - 1)) && n)
/*
* HDF Boolean type.
*/
#ifndef FALSE
# define FALSE 0
#endif
#ifndef TRUE
# define TRUE 1
#endif
/*
* Numeric data types. Some of these might be defined in Posix.1g, otherwise
* we define them with the closest available type which is at least as large
* as the number of bits indicated in the type name. The `int8' types *must*
* be exactly one byte wide because we use it for pointer calculations to
* void* memory.
*/
#if H5_SIZEOF_INT8_T==0
typedef signed char int8_t;
# undef H5_SIZEOF_INT8_T
# define H5_SIZEOF_INT8_T H5_SIZEOF_CHAR
#elif H5_SIZEOF_INT8_T==1
#else
# error "the int8_t type must be 1 byte wide"
#endif
#if H5_SIZEOF_UINT8_T==0
typedef unsigned char uint8_t;
# undef H5_SIZEOF_UINT8_T
# define H5_SIZEOF_UINT8_T H5_SIZEOF_CHAR
#elif H5_SIZEOF_UINT8_T==1
#else
# error "the uint8_t type must be 1 byte wide"
#endif
#if H5_SIZEOF_INT16_T>=2
#elif H5_SIZEOF_SHORT>=2
typedef short int16_t;
# undef H5_SIZEOF_INT16_T
# define H5_SIZEOF_INT16_T H5_SIZEOF_SHORT
#elif H5_SIZEOF_INT>=2
typedef int int16_t;
# undef H5_SIZEOF_INT16_T
# define H5_SIZEOF_INT16_T H5_SIZEOF_INT
#else
# error "nothing appropriate for int16_t"
#endif
#if H5_SIZEOF_UINT16_T>=2
#elif H5_SIZEOF_SHORT>=2
typedef unsigned short uint16_t;
# undef H5_SIZEOF_UINT16_T
# define H5_SIZEOF_UINT16_T H5_SIZEOF_SHORT
#elif H5_SIZEOF_INT>=2
typedef unsigned uint16_t;
# undef H5_SIZEOF_UINT16_T
# define H5_SIZEOF_UINT16_T H5_SIZEOF_INT
#else
# error "nothing appropriate for uint16_t"
#endif
#if H5_SIZEOF_INT32_T>=4
#elif H5_SIZEOF_SHORT>=4
typedef short int32_t;
# undef H5_SIZEOF_INT32_T
# define H5_SIZEOF_INT32_T H5_SIZEOF_SHORT
#elif H5_SIZEOF_INT>=4
typedef int int32_t;
# undef H5_SIZEOF_INT32_T
# define H5_SIZEOF_INT32_T H5_SIZEOF_INT
#elif H5_SIZEOF_LONG>=4
typedef long int32_t;
# undef H5_SIZEOF_INT32_T
# define H5_SIZEOF_INT32_T H5_SIZEOF_LONG
#else
# error "nothing appropriate for int32_t"
#endif
/* Definition of uint32_t was moved to H5public.h */
/* Definition of int64_t was moved to H5public.h */
/* Definition of uint64_t was moved to H5public.h */
/*
* Maximum and minimum values. These should be defined in <limits.h> for the
* most part.
*/
#ifndef LLONG_MAX
# define LLONG_MAX ((long_long)(((unsigned long_long)1 \
<<(8*sizeof(long_long)-1))-1))
# define LLONG_MIN ((long_long)(-LLONG_MAX)-1)
#endif
#ifndef ULLONG_MAX
# define ULLONG_MAX ((unsigned long_long)((long_long)(-1)))
#endif
#ifndef SIZET_MAX
# define SIZET_MAX ((size_t)(ssize_t)(-1))
# define SSIZET_MAX ((ssize_t)(((size_t)1<<(8*sizeof(ssize_t)-1))-1))
#endif
#ifdef H5_HAVE_LARGE_HSIZET
#define HSIZET_MAX ((hsize_t)ULLONG_MAX)
#define HSSIZET_MAX ((hssize_t)LLONG_MAX)
#else /* H5_HAVE_LARGE_HSIZET */
#define HSIZET_MAX ((hsize_t)SIZET_MAX)
#define HSSIZET_MAX ((hssize_t)SSIZET_MAX)
#endif /* H5_HAVE_LARGE_HSIZET */
#define HSSIZET_MIN (~(HSSIZET_MAX))
/*
* A macro to portably increment enumerated types.
*/
#ifndef H5_INC_ENUM
# define H5_INC_ENUM(TYPE,VAR) (VAR)=((TYPE)((VAR)+1))
#endif
/*
* A macro to portably decrement enumerated types.
*/
#ifndef H5_DEC_ENUM
# define H5_DEC_ENUM(TYPE,VAR) (VAR)=((TYPE)((VAR)-1))
#endif
/*
* A macro for detecting over/under-flow when casting between types
*/
#ifndef NDEBUG
#define H5_CHECK_OVERFLOW(var, vartype, casttype) \
{ \
casttype _tmp_overflow = (casttype)(var); \
assert((var) == (vartype)_tmp_overflow); \
}
#else /* NDEBUG */
#define H5_CHECK_OVERFLOW(var, vartype, casttype)
#endif /* NDEBUG */
/*
* A macro for detecting over/under-flow when assigning between types
*/
#ifndef NDEBUG
#define H5_ASSIGN_OVERFLOW(dst, src, srctype, dsttype) \
{ \
srctype _tmp_overflow = (srctype)(src); \
dsttype _tmp_overflow2 = (dsttype)(_tmp_overflow); \
assert((dsttype)_tmp_overflow == _tmp_overflow2); \
(dst) = _tmp_overflow2; \
}
#else /* NDEBUG */
#define H5_ASSIGN_OVERFLOW(dst, src, srctype, dsttype) \
(dst) = (dsttype)(src);
#endif /* NDEBUG */
/*
* Data types and functions for timing certain parts of the library.
*/
typedef struct {
double utime; /*user time */
double stime; /*system time */
double etime; /*elapsed wall-clock time */
} H5_timer_t;
H5_DLL void H5_timer_reset (H5_timer_t *timer);
H5_DLL void H5_timer_begin (H5_timer_t *timer);
H5_DLL void H5_timer_end (H5_timer_t *sum/*in,out*/,
H5_timer_t *timer/*in,out*/);
H5_DLL void H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds);
H5_DLL time_t H5_now(void);
/* Depth of object copy */
typedef enum {
H5_COPY_SHALLOW, /* Shallow copy from source to destination, just copy field pointers */
H5_COPY_DEEP /* Deep copy from source to destination, including duplicating fields pointed to */
} H5_copy_depth_t;
/*
* Redefine all the POSIX functions. We should never see a POSIX
* function (or any other non-HDF5 function) in the source!
*/
#define HDabort() abort()
#define HDabs(X) abs(X)
#define HDaccess(F,M) access(F, M)
#define HDacos(X) acos(X)
#ifdef H5_HAVE_ALARM
#define HDalarm(N) alarm(N)
#else /* H5_HAVE_ALARM */
#define HDalarm(N) (0)
#endif /* H5_HAVE_ALARM */
#define HDasctime(T) asctime(T)
#define HDasin(X) asin(X)
#define HDassert(X) assert(X)
#define HDatan(X) atan(X)
#define HDatan2(X,Y) atan2(X,Y)
#define HDatexit(F) atexit(F)
#define HDatof(S) atof(S)
#define HDatoi(S) atoi(S)
#define HDatol(S) atol(S)
#define HDBSDgettimeofday(S,P) BSDgettimeofday(S,P)
#define HDbsearch(K,B,N,Z,F) bsearch(K,B,N,Z,F)
#define HDcalloc(N,Z) calloc(N,Z)
#define HDceil(X) ceil(X)
#define HDcfgetispeed(T) cfgetispeed(T)
#define HDcfgetospeed(T) cfgetospeed(T)
#define HDcfsetispeed(T,S) cfsetispeed(T,S)
#define HDcfsetospeed(T,S) cfsetospeed(T,S)
#define HDchdir(S) chdir(S)
#define HDchmod(S,M) chmod(S,M)
#define HDchown(S,O,G) chown(S,O,G)
#define HDclearerr(F) clearerr(F)
#define HDclock() clock()
#define HDclose(F) close(F)
#define HDclosedir(D) closedir(D)
#define HDcos(X) cos(X)
#define HDcosh(X) cosh(X)
#define HDcreat(S,M) creat(S,M)
#define HDctermid(S) ctermid(S)
#define HDctime(T) ctime(T)
#define HDcuserid(S) cuserid(S)
#ifdef H5_HAVE_DIFFTIME
#define HDdifftime(X,Y) difftime(X,Y)
#else
#define HDdifftime(X,Y) ((double)(X)-(double)(Y))
#endif
#define HDdiv(X,Y) div(X,Y)
#define HDdup(F) dup(F)
#define HDdup2(F,I) dup2(F,I)
/* execl() variable arguments */
/* execle() variable arguments */
/* execlp() variable arguments */
#define HDexecv(S,AV) execv(S,AV)
#define HDexecve(S,AV,E) execve(S,AV,E)
#define HDexecvp(S,AV) execvp(S,AV)
#define HDexit(N) exit(N)
#if defined __MWERKS__
#include <abort_exit.h>
#define HD_exit(N) __exit(N)
#else /* __MWERKS __ */
#define HD_exit(N) _exit(N)
#endif /* __MWERKS __ */
#define HDexp(X) exp(X)
#define HDfabs(X) fabs(X)
/* use ABS() because fabsf() fabsl() are not common yet. */
#define HDfabsf(X) ABS(X)
#define HDfabsl(X) ABS(X)
#define HDfclose(F) fclose(F)
/* fcntl() variable arguments */
#define HDfdopen(N,S) fdopen(N,S)
#define HDfeof(F) feof(F)
#define HDferror(F) ferror(F)
#define HDfflush(F) fflush(F)
#define HDfgetc(F) fgetc(F)
#define HDfgetpos(F,P) fgetpos(F,P)
#define HDfgets(S,N,F) fgets(S,N,F)
#ifdef _WIN32
#define HDfileno(F) _fileno(F)
#else /* _WIN32 */
#define HDfileno(F) fileno(F)
#endif /* _WIN32 */
#define HDfloor(X) floor(X)
#define HDfmod(X,Y) fmod(X,Y)
#define HDfopen(S,M) fopen(S,M)
#define HDfork() fork()
#define HDfpathconf(F,N) fpathconf(F,N)
H5_DLL int HDfprintf (FILE *stream, const char *fmt, ...);
#define HDfputc(C,F) fputc(C,F)
#define HDfputs(S,F) fputs(S,F)
#define HDfread(M,Z,N,F) fread(M,Z,N,F)
#define HDfree(M) free(M)
#define HDfreopen(S,M,F) freopen(S,M,F)
#define HDfrexp(X,N) frexp(X,N)
/* Check for Cray-specific 'frexpf()' and 'frexpl()' routines */
#ifdef H5_HAVE_FREXPF
#define HDfrexpf(X,N) frexpf(X,N)
#else /* H5_HAVE_FREXPF */
#define HDfrexpf(X,N) frexp(X,N)
#endif /* H5_HAVE_FREXPF */
#ifdef H5_HAVE_FREXPL
#define HDfrexpl(X,N) frexpl(X,N)
#else /* H5_HAVE_FREXPL */
#define HDfrexpl(X,N) frexp(X,N)
#endif /* H5_HAVE_FREXPL */
/* fscanf() variable arguments */
#ifdef H5_HAVE_FSEEKO
#define HDfseek(F,O,W) fseeko(F,O,W)
#else
#define HDfseek(F,O,W) fseek(F,O,W)
#endif
#define HDfsetpos(F,P) fsetpos(F,P)
/* definitions related to the file stat utilities.
* Windows have its own function names.
* For Unix, if off_t is not 64bit big, try use the pseudo-standard
* xxx64 versions if available.
*/
#ifdef _WIN32
#ifdef __MWERKS__
#define HDfstat(F,B) fstat(F,B)
#define HDstat(S,B) stat(S,B)
typedef struct stat h5_stat_t;
typedef off_t h5_stat_size_t;
#else /*MSVC*/
#define HDfstat(F,B) _fstati64(F,B)
#define HDstat(S,B) _stati64(S,B)
typedef struct _stati64 h5_stat_t;
typedef __int64 h5_stat_size_t;
#endif
#elif H5_SIZEOF_OFF_T!=8 && H5_SIZEOF_OFF64_T==8 && defined(H5_HAVE_STAT64)
#define HDfstat(F,B) fstat64(F,B)
#define HDstat(S,B) stat64(S,B)
typedef struct stat64 h5_stat_t;
typedef off64_t h5_stat_size_t;
#else
#define HDfstat(F,B) fstat(F,B)
#define HDstat(S,B) stat(S,B)
typedef struct stat h5_stat_t;
typedef off_t h5_stat_size_t;
#endif
#define HDftell(F) ftell(F)
#define HDftruncate(F,L) ftruncate(F,L)
#define HDfwrite(M,Z,N,F) fwrite(M,Z,N,F)
#define HDgetc(F) getc(F)
#define HDgetchar() getchar()
#define HDgetcwd(S,Z) getcwd(S,Z)
#define HDgetegid() getegid()
#define HDgetenv(S) getenv(S)
#define HDgeteuid() geteuid()
#define HDgetgid() getgid()
#define HDgetgrgid(G) getgrgid(G)
#define HDgetgrnam(S) getgrnam(S)
#define HDgetgroups(Z,G) getgroups(Z,G)
#define HDgetlogin() getlogin()
#define HDgetpgrp() getpgrp()
#define HDgetpid() getpid()
#define HDgetppid() getppid()
#define HDgetpwnam(S) getpwnam(S)
#define HDgetpwuid(U) getpwuid(U)
#define HDgetrusage(X,S) getrusage(X,S)
#define HDgets(S) gets(S)
#define HDgettimeofday(S,P) gettimeofday(S,P)
#define HDgetuid() getuid()
#define HDgmtime(T) gmtime(T)
#define HDisalnum(C) isalnum((int)(C)) /*cast for solaris warning*/
#define HDisalpha(C) isalpha((int)(C)) /*cast for solaris warning*/
#define HDisatty(F) isatty(F)
#define HDiscntrl(C) iscntrl((int)(C)) /*cast for solaris warning*/
#define HDisdigit(C) isdigit((int)(C)) /*cast for solaris warning*/
#define HDisgraph(C) isgraph((int)(C)) /*cast for solaris warning*/
#define HDislower(C) islower((int)(C)) /*cast for solaris warning*/
#define HDisprint(C) isprint((int)(C)) /*cast for solaris warning*/
#define HDispunct(C) ispunct((int)(C)) /*cast for solaris warning*/
#define HDisspace(C) isspace((int)(C)) /*cast for solaris warning*/
#define HDisupper(C) isupper((int)(C)) /*cast for solaris warning*/
#define HDisxdigit(C) isxdigit((int)(C)) /*cast for solaris warning*/
#define HDkill(P,S) kill(P,S)
#define HDlabs(X) labs(X)
#define HDldexp(X,N) ldexp(X,N)
#define HDldiv(X,Y) ldiv(X,Y)
#define HDlink(OLD,NEW) link(OLD,NEW)
#define HDlocaleconv() localeconv()
#define HDlocaltime(T) localtime(T)
#define HDlog(X) log(X)
#define HDlog10(X) log10(X)
#define HDlongjmp(J,N) longjmp(J,N)
#ifdef _WIN32
#ifdef __MWERKS__
#define HDlseek(F,O,W) lseek(F,O,W)
#else /*MSVS */
#define HDlseek(F,O,W) _lseeki64(F,O,W)
#endif
#else
#ifdef H5_HAVE_FSEEK64
#define HDlseek(F,O,W) lseek64(F,O,W)
#else
#define HDlseek(F,O,W) lseek(F,O,W)
#endif
#endif
#define HDmalloc(Z) malloc(Z)
#define HDposix_memalign(P,A,Z) posix_memalign(P,A,Z)
#define HDmblen(S,N) mblen(S,N)
#define HDmbstowcs(P,S,Z) mbstowcs(P,S,Z)
#define HDmbtowc(P,S,Z) mbtowc(P,S,Z)
#define HDmemchr(S,C,Z) memchr(S,C,Z)
#define HDmemcmp(X,Y,Z) memcmp(X,Y,Z)
/*
* The (char*) casts are required for the DEC when optimizations are turned
* on and the source and/or destination are not aligned.
*/
#define HDmemcpy(X,Y,Z) memcpy((char*)(X),(const char*)(Y),Z)
#define HDmemmove(X,Y,Z) memmove((char*)(X),(const char*)(Y),Z)
/*
* The (void*) cast just avoids a compiler warning in _WIN32
*/
#ifdef _WIN32
#define HDmemset(X,C,Z) memset((void*)(X),C,Z)
#else /* _WIN32 */
#define HDmemset(X,C,Z) memset(X,C,Z)
#endif /* _WIN32 */
#ifdef _WIN32
#define HDmkdir(S,M) _mkdir(S)
#else /* _WIN32 */
#define HDmkdir(S,M) mkdir(S,M)
#endif /* _WIN32 */
#define HDmkfifo(S,M) mkfifo(S,M)
#define HDmktime(T) mktime(T)
#define HDmodf(X,Y) modf(X,Y)
#ifdef _O_BINARY
#define HDopen(S,F,M) open(S,F|_O_BINARY,M)
#else
#define HDopen(S,F,M) open(S,F,M)
#endif
#define HDopendir(S) opendir(S)
#define HDpathconf(S,N) pathconf(S,N)
#define HDpause() pause()
#define HDperror(S) perror(S)
#define HDpipe(F) pipe(F)
#define HDpow(X,Y) pow(X,Y)
/* printf() variable arguments */
#define HDputc(C,F) putc(C,F)
#define HDputchar(C) putchar(C)
#define HDputs(S) puts(S)
#define HDqsort(M,N,Z,F) qsort(M,N,Z,F)
#define HDraise(N) raise(N)
#ifdef H5_HAVE_RAND_R
#define HDrandom() HDrand()
H5_DLL int HDrand(void);
#elif H5_HAVE_RANDOM
#define HDrand() random()
#define HDrandom() random()
#else
#define HDrand() rand()
#define HDrandom() rand()
#endif
#define HDread(F,M,Z) read(F,M,Z)
#define HDreaddir(D) readdir(D)
#define HDrealloc(M,Z) realloc(M,Z)
#ifdef H5_VMS
#ifdef __cplusplus
extern "C" {
#endif
int HDremove_all(const char * fname);
#ifdef __cplusplus
}
#endif
#define HDremove(S) HDremove_all(S)
#else
#define HDremove(S) remove(S)
#endif /*H5_VMS*/
#define HDrename(OLD,NEW) rename(OLD,NEW)
#define HDrewind(F) rewind(F)
#define HDrewinddir(D) rewinddir(D)
#define HDrmdir(S) rmdir(S)
/* scanf() variable arguments */
#define HDsetbuf(F,S) setbuf(F,S)
#define HDsetgid(G) setgid(G)
#define HDsetjmp(J) setjmp(J)
#define HDsetlocale(N,S) setlocale(N,S)
#define HDsetpgid(P,PG) setpgid(P,PG)
#define HDsetsid() setsid()
#define HDsetuid(U) setuid(U)
/* Windows does not permit setting the buffer size to values
less than 2. */
#ifndef _WIN32
#define HDsetvbuf(F,S,M,Z) setvbuf(F,S,M,Z)
#else
#define HDsetvbuf(F,S,M,Z) setvbuf(F,S,M,(Z>1?Z:2))
#endif
#define HDsigaction(N,A) sigaction(N,A)
#define HDsigaddset(S,N) sigaddset(S,N)
#define HDsigdelset(S,N) sigdelset(S,N)
#define HDsigemptyset(S) sigemptyset(S)
#define HDsigfillset(S) sigfillset(S)
#define HDsigismember(S,N) sigismember(S,N)
#define HDsiglongjmp(J,N) siglongjmp(J,N)
#define HDsignal(N,F) signal(N,F)
#define HDsigpending(S) sigpending(S)
#define HDsigprocmask(H,S,O) sigprocmask(H,S,O)
#define HDsigsetjmp(J,N) sigsetjmp(J,N)
#define HDsigsuspend(S) sigsuspend(S)
#define HDsin(X) sin(X)
#define HDsinh(X) sinh(X)
#define HDsleep(N) sleep(N)
#ifdef _WIN32
#define HDsnprintf _snprintf /*varargs*/
#else
#define HDsnprintf snprintf /*varargs*/
#endif
/* sprintf() variable arguments */
#define HDsqrt(X) sqrt(X)
#ifdef H5_HAVE_RAND_R
H5_DLL void HDsrand(unsigned int seed);
#define HDsrandom(S) HDsrand(S)
#elif H5_HAVE_RANDOM
#define HDsrand(S) srandom(S)
#define HDsrandom(S) srandom(S)
#else
#define HDsrand(S) srand(S)
#define HDsrandom(S) srand(S)
#endif
/* sscanf() variable arguments */
#define HDstrcat(X,Y) strcat(X,Y)
#define HDstrchr(S,C) strchr(S,C)
#define HDstrcmp(X,Y) strcmp(X,Y)
#define HDstrcoll(X,Y) strcoll(X,Y)
#define HDstrcpy(X,Y) strcpy(X,Y)
#define HDstrcspn(X,Y) strcspn(X,Y)
#define HDstrerror(N) strerror(N)
#define HDstrftime(S,Z,F,T) strftime(S,Z,F,T)
#define HDstrlen(S) strlen(S)
#define HDstrncat(X,Y,Z) strncat(X,Y,Z)
#define HDstrncmp(X,Y,Z) strncmp(X,Y,Z)
#define HDstrncpy(X,Y,Z) strncpy(X,Y,Z)
#define HDstrpbrk(X,Y) strpbrk(X,Y)
#define HDstrrchr(S,C) strrchr(S,C)
#define HDstrspn(X,Y) strspn(X,Y)
#define HDstrstr(X,Y) strstr(X,Y)
#define HDstrtod(S,R) strtod(S,R)
#define HDstrtok(X,Y) strtok(X,Y)
#define HDstrtol(S,R,N) strtol(S,R,N)
H5_DLL int64_t HDstrtoll (const char *s, const char **rest, int base);
#define HDstrtoul(S,R,N) strtoul(S,R,N)
#define HDstrxfrm(X,Y,Z) strxfrm(X,Y,Z)
#define HDsysconf(N) sysconf(N)
#define HDsystem(S) system(S)
#define HDtan(X) tan(X)
#define HDtanh(X) tanh(X)
#define HDtcdrain(F) tcdrain(F)
#define HDtcflow(F,A) tcflow(F,A)
#define HDtcflush(F,N) tcflush(F,N)
#define HDtcgetattr(F,T) tcgetattr(F,T)
#define HDtcgetpgrp(F) tcgetpgrp(F)
#define HDtcsendbreak(F,N) tcsendbreak(F,N)
#define HDtcsetattr(F,O,T) tcsetattr(F,O,T)
#define HDtcsetpgrp(F,N) tcsetpgrp(F,N)
#define HDtime(T) time(T)
#define HDtimes(T) times(T)
#define HDtmpfile() tmpfile()
#define HDtmpnam(S) tmpnam(S)
#define HDtolower(C) tolower(C)
#define HDtoupper(C) toupper(C)
#define HDttyname(F) ttyname(F)
#define HDtzset() tzset()
#define HDumask(N) umask(N)
#define HDuname(S) uname(S)
#define HDungetc(C,F) ungetc(C,F)
#ifdef _WIN32
#define HDunlink(S) _unlink(S)
#else
#define HDunlink(S) unlink(S)
#endif
#define HDutime(S,T) utime(S,T)
#define HDva_arg(A,T) va_arg(A,T)
#define HDva_end(A) va_end(A)
#define HDva_start(A,P) va_start(A,P)
#define HDvasprintf(RET,FMT,A) vasprintf(RET,FMT,A)
#define HDvfprintf(F,FMT,A) vfprintf(F,FMT,A)
#define HDvprintf(FMT,A) vprintf(FMT,A)
#define HDvsprintf(S,FMT,A) vsprintf(S,FMT,A)
#ifdef _WIN32
# define HDvsnprintf(S,N,FMT,A) _vsnprintf(S,N,FMT,A)
#else
# define HDvsnprintf(S,N,FMT,A) vsnprintf(S,N,FMT,A)
#endif
#define HDwait(W) wait(W)
#define HDwaitpid(P,W,O) waitpid(P,W,O)
#define HDwcstombs(S,P,Z) wcstombs(S,P,Z)
#define HDwctomb(S,C) wctomb(S,C)
#if defined (__MWERKS__)
/* workaround for a bug in the Metrowerks version 6.0 header file for write
which is not defined as const void*
*/
#define HDwrite(F,M,Z) write(F,(void*)M,Z)
#else
#define HDwrite(F,M,Z) write(F,M,Z)
#endif
/*
* And now for a couple non-Posix functions... Watch out for systems that
* define these in terms of macros.
*/
#ifdef _WIN32
#define HDstrdup(S) _strdup(S)
#else /* _WIN32 */
#if !defined strdup && !defined H5_HAVE_STRDUP
extern char *strdup(const char *s);
#endif
#define HDstrdup(S) strdup(S)
#endif /* _WIN32 */
/*
* These macros check whether debugging has been requested for a certain
* package at run-time. Code for debugging is conditionally compiled by
* defining constants like `H5X_DEBUG'. In order to see the output though
* the code must be enabled at run-time with an environment variable
* HDF5_DEBUG which is a list of packages to debug.
*
* Note: If you add/remove items from this enum then be sure to update the
* information about the package in H5_init_library().
*/
typedef enum {
H5_PKG_A, /*Attributes */
H5_PKG_AC, /*Meta data cache */
H5_PKG_B, /*B-trees */
H5_PKG_D, /*Datasets */
H5_PKG_E, /*Error handling */
H5_PKG_F, /*Files */
H5_PKG_G, /*Groups */
H5_PKG_HG, /*Global heap */
H5_PKG_HL, /*Local heap */
H5_PKG_I, /*Interface */
H5_PKG_MF, /*File memory management */
H5_PKG_MM, /*Core memory management */
H5_PKG_O, /*Object headers */
H5_PKG_P, /*Property lists */
H5_PKG_S, /*Data spaces */
H5_PKG_T, /*Data types */
H5_PKG_V, /*Vector functions */
H5_PKG_Z, /*Raw data filters */
H5_NPKGS /*Must be last */
} H5_pkg_t;
typedef struct H5_debug_t {
FILE *trace; /*API trace output stream */
hbool_t ttop; /*Show only top-level calls? */
hbool_t ttimes; /*Show trace event times? */
struct {
const char *name; /*package name */
FILE *stream; /*output stream or NULL */
} pkg[H5_NPKGS];
} H5_debug_t;
extern H5_debug_t H5_debug_g;
#define H5DEBUG(X) (H5_debug_g.pkg[H5_PKG_##X].stream)
/*-------------------------------------------------------------------------
* Purpose: These macros are inserted automatically just after the
* FUNC_ENTER() macro of API functions and are used to trace
* application program execution. Unless H5_DEBUG_API has been
* defined they are no-ops.
*
* Arguments: R - Return type encoded as a string
* T - Argument types encoded as a string
* A0-An - Arguments. The number at the end of the macro name
* indicates the number of arguments.
*
* Programmer: Robb Matzke
*
* Modifications:
*-------------------------------------------------------------------------
*/
#ifdef H5_DEBUG_API
#define H5TRACE_DECL const char *RTYPE=NULL; \
double CALLTIME;
#define H5TRACE0(R,T) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T)
#define H5TRACE1(R,T,A0) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0)
#define H5TRACE2(R,T,A0,A1) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1)
#define H5TRACE3(R,T,A0,A1,A2) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2)
#define H5TRACE4(R,T,A0,A1,A2,A3) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3)
#define H5TRACE5(R,T,A0,A1,A2,A3,A4) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4)
#define H5TRACE6(R,T,A0,A1,A2,A3,A4,A5) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5)
#define H5TRACE7(R,T,A0,A1,A2,A3,A4,A5,A6) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5,#A6,A6)
#define H5TRACE8(R,T,A0,A1,A2,A3,A4,A5,A6,A7) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5,#A6,A6,#A7,A7)
#define H5TRACE9(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5,#A6,A6,#A7,A7,#A8,A8)
#define H5TRACE10(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5,#A6,A6,#A7,A7,#A8,A8,#A9,A9)
#define H5TRACE11(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) RTYPE=R; \
CALLTIME=H5_trace(NULL,FUNC,T,#A0,A0,#A1,A1,#A2,A2,#A3,A3, \
#A4,A4,#A5,A5,#A6,A6,#A7,A7,#A8,A8,#A9,A9, \
#A10,A10)
#define H5TRACE_RETURN(V) if (RTYPE) { \
H5_trace(&CALLTIME,FUNC,RTYPE,NULL,V); \
RTYPE=NULL; \
}
#else
#define H5TRACE_DECL /*void*/
#define H5TRACE0(R,T) /*void*/
#define H5TRACE1(R,T,A0) /*void*/
#define H5TRACE2(R,T,A0,A1) /*void*/
#define H5TRACE3(R,T,A0,A1,A2) /*void*/
#define H5TRACE4(R,T,A0,A1,A2,A3) /*void*/
#define H5TRACE5(R,T,A0,A1,A2,A3,A4) /*void*/
#define H5TRACE6(R,T,A0,A1,A2,A3,A4,A5) /*void*/
#define H5TRACE7(R,T,A0,A1,A2,A3,A4,A5,A6) /*void*/
#define H5TRACE8(R,T,A0,A1,A2,A3,A4,A5,A6,A7) /*void*/
#define H5TRACE9(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8) /*void*/
#define H5TRACE10(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9) /*void*/
#define H5TRACE11(R,T,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10) /*void*/
#define H5TRACE_RETURN(V) /*void*/
#endif
H5_DLL double H5_trace(const double *calltime, const char *func, const char *type, ...);
/*-------------------------------------------------------------------------
* Purpose: Register function entry for library initialization and code
* profiling.
*
* Notes: Every file must have a file-scope variable called
* `initialize_interface_g' of type hbool_t which is initialized
* to FALSE.
*
* 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:
*
*-------------------------------------------------------------------------
*/
/* `S' is the name of a function which is being tested to check if its */
/* an API function */
#define H5_IS_API(S) ('_'!=S[2] && '_'!=S[3] && (!S[4] || '_'!=S[4]))
/* global library version information string */
extern char H5_lib_vers_info_g[];
/* Lock headers */
#ifdef H5_HAVE_THREADSAFE
/* Include required thread-safety header */
#include "H5TSprivate.h"
/* replacement structure for original global variable */
typedef struct H5_api_struct {
H5TS_mutex_t init_lock; /* API entrance mutex */
hbool_t H5_libinit_g; /* Has the library been initialized? */
} H5_api_t;
/* Macros for accessing the global variables */
#define H5_INIT_GLOBAL H5_g.H5_libinit_g
/* Macro for first thread initialization */
#define H5_FIRST_THREAD_INIT \
pthread_once(&H5TS_first_init_g, H5TS_first_thread_init);
/* Macros for threadsafe HDF-5 Phase I locks */
#define H5_API_LOCK \
H5TS_mutex_lock(&H5_g.init_lock);
#define H5_API_UNLOCK \
H5TS_mutex_unlock(&H5_g.init_lock);
/* Macros for thread cancellation-safe mechanism */
#define H5_API_UNSET_CANCEL \
H5TS_cancel_count_inc();
#define H5_API_SET_CANCEL \
H5TS_cancel_count_dec();
extern H5_api_t H5_g;
#else /* H5_HAVE_THREADSAFE */
/* disable any first thread init mechanism */
#define H5_FIRST_THREAD_INIT
/* disable locks (sequential version) */
#define H5_API_LOCK
#define H5_API_UNLOCK
/* disable cancelability (sequential version) */
#define H5_API_UNSET_CANCEL
#define H5_API_SET_CANCEL
/* extern global variables */
extern hbool_t H5_libinit_g; /* Has the library been initialized? */
/* Macros for accessing the global variables */
#define H5_INIT_GLOBAL H5_libinit_g
#endif /* H5_HAVE_THREADSAFE */
#ifdef H5_HAVE_CODESTACK
/* Include required function stack header */
#include "H5CSprivate.h"
#define H5_PUSH_FUNC(func_name) H5CS_push(#func_name)
#define H5_POP_FUNC H5CS_pop()
#else /* H5_HAVE_CODESTACK */
#define H5_PUSH_FUNC(func_name) /* void */
#define H5_POP_FUNC /* void */
#endif /* H5_HAVE_CODESTACK */
#ifdef H5_HAVE_MPE
extern hbool_t H5_MPEinit_g; /* Has the MPE Library been initialized? */
#endif
/* Check if the function name is correct (if the compiler supports __FUNCTION__) */
#ifdef H5_HAVE_FUNCTION
#define H5_CHECK_FUNCNAME(func_name) \
assert(!HDstrcmp(#func_name, __FUNCTION__))
#else /* H5_HAVE_FUNCTION */
#define H5_CHECK_FUNCNAME(func_name) \
assert(func_name)
#endif /* H5_HAVE_FUNCTION */
/* Macros for defining interface initialization routines */
#ifdef H5_INTERFACE_INIT_FUNC
static int H5_interface_initialize_g = 0;
static herr_t H5_INTERFACE_INIT_FUNC(void);
#define H5_INTERFACE_INIT(err) \
/* Initialize this interface or bust */ \
if (!H5_interface_initialize_g) { \
H5_interface_initialize_g = 1; \
if (H5_INTERFACE_INIT_FUNC()<0) { \
H5_interface_initialize_g = 0; \
HGOTO_ERROR (H5E_FUNC, H5E_CANTINIT, err, \
"interface initialization failed") \
} \
}
#else /* H5_INTERFACE_INIT_FUNC */
#define H5_INTERFACE_INIT(err)
#endif /* H5_INTERFACE_INIT_FUNC */
#ifndef NDEBUG
#define FUNC_ENTER_COMMON_NOFUNC(func_name,asrt) \
static hbool_t func_check = FALSE; \
\
if(!func_check) { \
/* Check API status */ \
HDassert(asrt); \
\
/* Check function name */ \
H5_CHECK_FUNCNAME(func_name); \
\
/* Don't check again */ \
func_check = TRUE; \
} /* end if */
#else /* NDEBUG */
#define FUNC_ENTER_COMMON_NOFUNC(func_name,asrt)
#endif /* NDEBUG */
#define FUNC_ENTER_COMMON(func_name,asrt) \
static const char FUNC[]=#func_name; \
FUNC_ENTER_COMMON_NOFUNC(func_name,asrt);
/* Threadsafety initialization code for API routines */
#define FUNC_ENTER_API_THREADSAFE \
/* Initialize the thread-safe code */ \
H5_FIRST_THREAD_INIT \
\
/* Grab the mutex for the library */ \
H5_API_UNSET_CANCEL \
H5_API_LOCK
/* Threadsafety termination code for API routines */
#define FUNC_LEAVE_API_THREADSAFE \
H5_API_UNLOCK \
H5_API_SET_CANCEL
/* Local variables for API routines */
#define FUNC_ENTER_API_VARS(func_name) \
MPE_LOG_VARS(func_name) \
H5TRACE_DECL
/* Use this macro for all "normal" API functions */
#define FUNC_ENTER_API(func_name,err) {{ \
FUNC_ENTER_API_VARS(func_name) \
FUNC_ENTER_COMMON(func_name,H5_IS_API(#func_name)); \
FUNC_ENTER_API_THREADSAFE; \
FUNC_ENTER_API_COMMON(func_name,err); \
/* Clear thread error stack entering public functions */ \
H5E_clear_stack(NULL); \
{
/*
* Use this macro for API functions that shouldn't clear the error stack
* like H5Eprint and H5Ewalk.
*/
#define FUNC_ENTER_API_NOCLEAR(func_name,err) {{ \
FUNC_ENTER_API_VARS(func_name) \
FUNC_ENTER_COMMON(func_name,H5_IS_API(#func_name)); \
FUNC_ENTER_API_THREADSAFE; \
FUNC_ENTER_API_COMMON(func_name,err); \
{
/*
* Use this macro for API functions that shouldn't perform _any_ initialization
* of the library or an interface, just perform tracing, etc. Examples
* are: H5check_version, etc.
*
*/
#define FUNC_ENTER_API_NOINIT(func_name) {{ \
FUNC_ENTER_API_VARS(func_name) \
FUNC_ENTER_COMMON(func_name,H5_IS_API(#func_name)); \
FUNC_ENTER_API_THREADSAFE; \
H5_PUSH_FUNC(func_name); \
BEGIN_MPE_LOG(func_name); \
{
/*
* Use this macro for API functions that shouldn't perform _any_ initialization
* of the library or an interface or push themselves on the function
* stack, just perform tracing, etc. Examples
* are: H5close, H5check_version, etc.
*
*/
#define FUNC_ENTER_API_NOINIT_NOFS(func_name) {{ \
FUNC_ENTER_API_VARS(func_name) \
FUNC_ENTER_COMMON(func_name,H5_IS_API(#func_name)); \
FUNC_ENTER_API_THREADSAFE; \
BEGIN_MPE_LOG(func_name); \
{
/* Use this macro for all "normal" non-API functions */
#define FUNC_ENTER_NOAPI(func_name,err) { \
FUNC_ENTER_COMMON(func_name,!H5_IS_API(#func_name)); \
FUNC_ENTER_NOAPI_INIT(func_name,err) \
{
/* Use this macro for all non-API functions which don't issue errors */
#define FUNC_ENTER_NOAPI_NOFUNC(func_name) { \
FUNC_ENTER_COMMON_NOFUNC(func_name,!H5_IS_API(#func_name)); \
FUNC_ENTER_NOAPI_INIT(func_name,err) \
{
/*
* Use this macro for non-API functions which fall into these categories:
* - static functions, since they must be called from a function in the
* interface, the library and interface must already be
* initialized.
* - functions which are called during library shutdown, since we don't
* want to re-initialize the library.
*/
#define FUNC_ENTER_NOAPI_NOINIT(func_name) { \
FUNC_ENTER_COMMON(func_name,!H5_IS_API(#func_name)); \
H5_PUSH_FUNC(func_name); \
{
/*
* Use this macro for non-API functions which fall into these categories:
* - static functions, since they must be called from a function in the
* interface, the library and interface must already be
* initialized.
* - functions which are called during library shutdown, since we don't
* want to re-initialize the library.
*
* This macro is used for functions which fit the above categories _and_
* also don't use the 'FUNC' variable (i.e. don't push errors on the error stack)
*
*/
#define FUNC_ENTER_NOAPI_NOINIT_NOFUNC(func_name) { \
FUNC_ENTER_COMMON_NOFUNC(func_name,!H5_IS_API(#func_name)); \
H5_PUSH_FUNC(func_name); \
{
/*
* Use this macro for non-API functions which fall into these categories:
* - functions which shouldn't push their name on the function stack
* (so far, just the H5CS routines themselves)
*
* This macro is used for functions which fit the above categories _and_
* also don't use the 'FUNC' variable (i.e. don't push errors on the error stack)
*
*/
#define FUNC_ENTER_NOAPI_NOFUNC_NOFS(func_name) { \
FUNC_ENTER_COMMON_NOFUNC(func_name,!H5_IS_API(#func_name)); \
{
#define FUNC_ENTER_API_COMMON(func_name,err) \
/* Initialize the library */ \
if (!(H5_INIT_GLOBAL)) { \
H5_INIT_GLOBAL = TRUE; \
if (H5_init_library()<0) \
HGOTO_ERROR (H5E_FUNC, H5E_CANTINIT, err, \
"library initialization failed") \
} \
\
/* Initialize the interface, if appropriate */ \
H5_INTERFACE_INIT(err) \
\
/* Push the name of this function on the function stack */ \
H5_PUSH_FUNC(func_name); \
\
BEGIN_MPE_LOG(func_name)
/* Note: this macro only works when there's _no_ interface initialization routine for the module */
#define FUNC_ENTER_NOAPI_INIT(func_name,err) \
/* Initialize the interface, if appropriate */ \
H5_INTERFACE_INIT(err) \
\
/* Push the name of this function on the function stack */ \
H5_PUSH_FUNC(func_name);
/*-------------------------------------------------------------------------
* 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.
* PABLO was deleted on January 21, 2005 EIP
*
*-------------------------------------------------------------------------
*/
#define FUNC_LEAVE_API(ret_value) \
FINISH_MPE_LOG; \
H5TRACE_RETURN(ret_value); \
H5_POP_FUNC; \
FUNC_LEAVE_API_THREADSAFE \
return (ret_value); \
} /*end scope from end of FUNC_ENTER*/ \
}} /*end scope from beginning of FUNC_ENTER*/
#define FUNC_LEAVE_API_NOFS(ret_value) \
FINISH_MPE_LOG; \
H5TRACE_RETURN(ret_value); \
FUNC_LEAVE_API_THREADSAFE \
return (ret_value); \
} /*end scope from end of FUNC_ENTER*/ \
}} /*end scope from beginning of FUNC_ENTER*/
#define FUNC_LEAVE_NOAPI(ret_value) \
H5_POP_FUNC; \
return (ret_value); \
} /*end scope from end of FUNC_ENTER*/ \
} /*end scope from beginning of FUNC_ENTER*/
#define FUNC_LEAVE_NOAPI_VOID \
H5_POP_FUNC; \
return; \
} /*end scope from end of FUNC_ENTER*/ \
} /*end scope from beginning of FUNC_ENTER*/
/*
* Use this macro for non-API functions which fall into these categories:
* - functions which didn't push their name on the function stack
* (so far, just the H5CS routines themselves)
*/
#define FUNC_LEAVE_NOAPI_NOFS(ret_value) \
return (ret_value); \
} /*end scope from end of FUNC_ENTER*/ \
} /*end scope from beginning of FUNC_ENTER*/
/* Macro for "glueing" together items, for re-scanning macros */
#define H5_GLUE(x,y) x##y
#define H5_GLUE3(x,y,z) x##y##z
/* Private functions, not part of the publicly documented API */
H5_DLL herr_t H5_init_library(void);
H5_DLL void H5_term_library(void);
/* Functions to terminate interfaces */
H5_DLL int H5A_term_interface(void);
H5_DLL int H5AC_term_interface(void);
H5_DLL int H5D_term_interface(void);
H5_DLL int H5E_term_interface(void);
H5_DLL int H5F_term_interface(void);
H5_DLL int H5FS_term_interface(void);
H5_DLL int H5G_term_interface(void);
H5_DLL int H5I_term_interface(void);
H5_DLL int H5L_term_interface(void);
H5_DLL int H5P_term_interface(void);
H5_DLL int H5R_term_interface(void);
H5_DLL int H5S_term_interface(void);
H5_DLL int H5T_term_interface(void);
H5_DLL int H5Z_term_interface(void);
/* Checksum functions */
H5_DLL uint32_t H5_checksum_fletcher32(const void *data, size_t len);
H5_DLL uint32_t H5_checksum_crc(const void *data, size_t len);
H5_DLL uint32_t H5_checksum_lookup3(const void *data, size_t len, uint32_t initval);
H5_DLL uint32_t H5_checksum_metadata(const void *data, size_t len, uint32_t initval);
/* Functions for debugging */
H5_DLL herr_t H5_buffer_dump(FILE *stream, int indent, uint8_t *buf,
uint8_t *marker, size_t buf_offset, size_t buf_size);
#endif /* _H5private_H */
Reference in New Issue View Git Blame Copy Permalink