/**************************************************************************** * NCSA HDF * * Software Development Group * * National Center for Supercomputing Applications * * University of Illinois at Urbana-Champaign * * 605 E. Springfield, Champaign IL 61820 * * * * For conditions of distribution and use, see the accompanying * * hdf/COPYING file. * * * ****************************************************************************/ /* $Id$ */ /* * This file contains macros & private information for general HDF5 functions. * Every HDF5 source file will include this file immediately after any * system include files but before any other private include files. */ #ifndef _H5private_H #define _H5private_H #include /* Include Public Definitions */ /* Version #'s of the major components of the file format */ #define HDF5_BOOTBLOCK_VERSION 0 /* of the boot block format */ #define HDF5_FREESPACE_VERSION 0 /* of the Free-Space Info */ #define HDF5_OBJECTDIR_VERSION 0 /* of the Object Directory format */ #define HDF5_SHAREDHEADER_VERSION 0 /* of the Shared-Header Info */ /* * Include those things that almost all source files need. */ #ifdef STDC_HEADERS # include # include # include # include # include # include # include # include # include # include #endif /* * Pablo support files. */ #ifdef HAVE_PABLO # define IOTRACE # include "IOTrace.h" # include "ProcIDS.h" #endif /* Does the compiler support the __attribute__(()) syntax? */ #ifndef HAVE_ATTRIBUTE # define __attribute__(X) /*void*/ # define __unused__ /*void*/ #else # define __unused__ __attribute__((unused)) #endif /* Does the compiler expand __FUNCTION__? */ #ifndef HAVE_FUNCTION # define __FUNCTION__ "NoFuntionName" #endif /* number of members in an array */ #ifndef NELMTS # define NELMTS(X) (sizeof(X)/sizeof(X[0])) #endif /* minimum of two, three, or four values */ #ifndef 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)) #endif /* maximum of two, three, or four values */ #ifndef 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)) #endif /* 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 /* maximum value of various types */ #define MAX_SIZET ((hsize_t)(size_t)(ssize_t)(-1)) #define MAX_SSIZET ((hsize_t)(ssize_t)((size_t)1<<(8*sizeof(ssize_t)-1))) #define MAX_HSIZET ((hsize_t)(hssize_t)(-1)) #define MAX_HSSIZET ((hsize_t)1<<(8*sizeof(hssize_t)-1)) /* * HDF Boolean type. */ #ifndef FALSE # define FALSE 0 #endif #ifndef TRUE # define TRUE (!FALSE) #endif /* * Numeric data types */ typedef char char8; typedef signed char int8; typedef unsigned char uchar8, uint8; #if SIZEOF_SHORT==2 typedef short int16; typedef unsigned short uint16; #else typedef int int16; /*not really */ typedef unsigned uint16; /*not really */ #endif #if SIZEOF_INT==4 typedef int int32; typedef unsigned int uint32; #elif SIZEOF_LONG==4 typedef long int32; typedef unsigned long uint32; #else typedef int int32; /*not really */ typedef unsigned uint32; /*not really */ #endif #if SIZEOF_INT==8 typedef int int64; typedef unsigned uint64; #elif SIZEOF_LONG==8 typedef long int64; typedef unsigned long uint64; #elif SIZEOF_LONG_LONG==8 typedef long long int64; typedef unsigned long long uint64; #else # error "no 64-bit integer type" #endif #if SIZEOF_FLOAT==4 typedef float float32; #else typedef float float32; /*not really */ #endif #if SIZEOF_FLOAT==8 typedef float float64; #elif SIZEOF_DOUBLE==8 typedef double float64; #else # error "no 64-bit floating point type" #endif /* * Define a type for generic integers. Use this instead of `int' to * show that some thought went into the algorithm. */ typedef int intn; typedef unsigned uintn; /* * 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) /* * File addresses. */ typedef struct { uint64 offset; /*offset within an HDF5 file */ } haddr_t; #define H5F_ADDR_UNDEF {((uint64)(-1L))} /* * Some compilers have problems declaring auto variables that point * to string constants. Use the CONSTR() macro so it's easy to fix * those compilers. */ #ifndef CONSTR # define CONSTR(VAR,STR) static const char VAR[]=STR #endif /* * 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; void H5_timer_reset (H5_timer_t *timer); void H5_timer_begin (H5_timer_t *timer); void H5_timer_end (H5_timer_t *sum/*in,out*/, H5_timer_t *timer/*in,out*/); void H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds); /* * 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) #define HDalarm(N) alarm(N) #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 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 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) #define HD_exit(N) _exit(N) #define HDexp(X) exp(X) #define HDfabs(X) fabs(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) #define HDfileno(F) fileno(F) #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) 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) /* fscanf() variable arguments */ #define HDfseek(F,O,W) fseek(F,O,W) #define HDfsetpos(F,P) fsetpos(F,P) #define HDfstat(F,B) fstat(F,B) #define HDftell(F) ftell(F) #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 HDgets(S) gets(S) #define HDgetuid() getuid() #define HDgmtime(T) gmtime(T) #define HDisalnum(C) isalnum(C) #define HDisalpha(C) isalpha(C) #define HDisatty(F) isatty(F) #define HDiscntrl(C) iscntrl(C) #define HDisdigit(C) isdigit(C) #define HDisgraph(C) isgraph(C) #define HDislower(C) islower(C) #define HDisprint(C) isprint(C) #define HDispunct(C) ispunct(C) #define HDisspace(C) isspace(C) #define HDisupper(C) isupper(C) #define HDisxdigit(C) isxdigit(C) #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) #define HDlseek(F,O,W) lseek(F,O,W) #define HDmalloc(Z) malloc(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) #define HDmemcpy(X,Y,Z) memcpy(X,Y,Z) #define HDmemmove(X,Y,Z) memmove(X,Y,Z) #define HDmemset(X,C,Z) memset(X,C,Z) #define HDmkdir(S,M) mkdir(S,M) #define HDmkfifo(S,M) mkfifo(S,M) #define HDmktime(T) mktime(T) #define HDmodf(X,Y) modf(X,Y) /* open() variable arguments */ #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) #define HDrand() rand() #define HDread(F,M,Z) read(F,M,Z) #define HDreaddir(D) readdir(D) #define HDrealloc(M,Z) realloc(M,Z) #define HDremove(S) remove(S) #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) #define HDsetvbuf(F,S,M,Z) setvbuf(F,S,M,Z) #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) /* sprintf() variable arguments */ #define HDsqrt(X) sqrt(X) #define HDsrand(N) srand(N) /* sscanf() variable arguments */ #define HDstat(S,B) stat(S,B) #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) int64 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) #define HDunlink(S) unlink(S) #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 HDvfprintf(F,FMT,A) vfprintf(F,FMT,A) #define HDvprintf(FMT,A) vprintf(FMT,A) #define HDvsprintf(S,FMT,A) vsprintf(S,FMT,A) #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) #define HDwrite(F,M,Z) write(F,M,Z) /* * And now for a couple non-Posix functions... */ extern char *strdup(const char *s); #define HDstrdup(S) strdup(S) /* * 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 */ 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 #define H5TRACE0(R,T) RTYPE=R; \ H5_trace(0,FUNC,T) #define H5TRACE1(R,T,A0) RTYPE=R; \ H5_trace(0,FUNC,T,#A0,A0) #define H5TRACE2(R,T,A0,A1) RTYPE=R; \ H5_trace(0,FUNC,T,#A0,A0,#A1,A1) #define H5TRACE3(R,T,A0,A1,A2) RTYPE=R; \ H5_trace(0,FUNC,T,#A0,A0,#A1,A1, \ #A2,A2) #define H5TRACE4(R,T,A0,A1,A2,A3) RTYPE=R; \ H5_trace(0,FUNC,T,#A0,A0,#A1,A1, \ #A2,A2,#A3,A3) #define H5TRACE5(R,T,A0,A1,A2,A3,A4) RTYPE=R; \ H5_trace(0,FUNC,T,#A0,A0,#A1,A1, \ #A2,A2,#A3,A3,#A4,A4) #define H5TRACE6(R,T,A0,A1,A2,A3,A4,A5) RTYPE=R; \ H5_trace(0,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; \ H5_trace(0,FUNC,T,#A0,A0,#A1,A1, \ #A2,A2,#A3,A3,#A4,A4, \ #A5,A5,#A6,A6) #define H5TRACE_RETURN(V) if (RTYPE) { \ H5_trace(1,NULL,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 H5TRACE_RETURN(V) /*void*/ #endif void H5_trace (hbool_t returning, 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: * * Robb Matzke, 4 Aug 1997 * The `interface_init_func' can be the null pointer. Changed * HGOTO_ERROR() to HRETURN_ERROR() since no clean-up needs to occur * when an error is detected at this point since this must be the * first executable statement in a function. This allows functions * to omit the `done:' label when convenient to do so. * * Robb Matzke, 4 Aug 1997 * The pablo mask comes from the constant PABLO_MASK defined on * a per-file basis. The `pablo_func_id' is generated from the * `func_name' argument by prepending an `ID_' to the name. The * pablo function identifier should be saved in a local variable * so FUNC_LEAVE() can access it. * * Robb Matzke, 4 Aug 1997 * It is safe to call this function even inside various library * initializing functions. Infinite recursion is no longer a * danger. * * Robb Matzke, 3 Dec 1997 * The interface initialization function is no longer passed as an * argument unless the `FUNC_ENTER_INIT' form is called. Instead, the * function comes from the `INTERFACE_INIT' constant which must be * defined in every source file. * * Robb Matzke, 17 Jun 1998 * Added auto variable RTYPE which is initialized by the tracing macros. *------------------------------------------------------------------------- */ extern hbool_t library_initialize_g; /*good thing C's lazy about extern! */ extern hbool_t thread_initialize_g; /*don't decl interface_initialize_g */ /* Is `S' the name of an API function? */ #define H5_IS_API(S) ('_'!=S[2] && '_'!=S[3] && (!S[4] || '_'!=S[4])) #define FUNC_ENTER(func_name,err) FUNC_ENTER_INIT(func_name,INTERFACE_INIT,err) #define FUNC_ENTER_INIT(func_name,interface_init_func,err) { \ CONSTR (FUNC, #func_name); \ H5TRACE_DECL; \ PABLO_SAVE (ID_ ## func_name); \ \ PABLO_TRACE_ON (PABLO_MASK, pablo_func_id); \ \ /* Initialize the library */ \ if (!library_initialize_g) { \ library_initialize_g = TRUE; \ if (H5_init_library()<0) { \ HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err, \ "library initialization failed"); \ } \ } \ \ /* Initialize this thread */ \ if (!thread_initialize_g) { \ thread_initialize_g = TRUE; \ if (H5_init_thread()<0) { \ HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err, \ "thread initialization failed"); \ } \ } \ \ /* Initialize this interface */ \ if (!interface_initialize_g) { \ interface_initialize_g = TRUE; \ if (interface_init_func && \ ((herr_t(*)(void))interface_init_func)()<0) { \ HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err, \ "interface initialization failed"); \ } \ } \ \ /* Clear thread error stack entering public functions */ \ if (H5E_clearable_g && H5_IS_API (FUNC)) { \ H5E_clear (); \ } \ { /*------------------------------------------------------------------------- * Purpose: Register function exit for code profiling. This should be * the last statement executed by a function. * * Programmer: Quincey Koziol * * Modifications: * * Robb Matzke, 4 Aug 1997 * The pablo mask comes from the constant PABLO_MASK defined on a * per-file basis. The pablo_func_id comes from an auto variable * defined by FUNC_ENTER. * *------------------------------------------------------------------------- */ #define FUNC_LEAVE(return_value) HRETURN(return_value)}} /* * The FUNC_ENTER() and FUNC_LEAVE() macros make calls to Pablo functions * through one of these two sets of macros. */ #ifdef HAVE_PABLO # define PABLO_SAVE(func_id) intn pablo_func_id = func_id # define PABLO_TRACE_ON(m, f) TRACE_ON(m,f) # define PABLO_TRACE_OFF(m, f) TRACE_OFF(m,f) #else # define PABLO_SAVE(func_id) /*void */ # define PABLO_TRACE_ON(m, f) /*void */ # define PABLO_TRACE_OFF(m, f) /*void */ #endif /* Private functions, not part of the publicly documented API */ herr_t H5_init_library(void); void H5_term_library(void); herr_t H5_add_exit(void (*func) (void)); herr_t H5_init_thread(void); void H5_term_thread(void); #endif