HDF5  1.12.0
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
H5private.h File Reference
#include "H5public.h"
#include <time.h>
#include "H5win32defs.h"
#include "H5overflow.h"

Go to the source code of this file.

Data Structures

struct  H5_timer_t
 
struct  H5O_copy_file_ud_common_t
 
struct  H5_obj_t
 
struct  H5_debug_open_stream_t
 
struct  H5_debug_t
 

Macros

#define H5_DEFAULT_VFD   H5FD_SEC2
 
#define H5_DEFAULT_VOL   H5VL_NATIVE
 
#define H5_INLINE
 
#define F_OK   00
 
#define W_OK   02
 
#define R_OK   04
 
#define MPE_LOG_VARS   /* void */
 
#define BEGIN_MPE_LOG   /* void */
 
#define FINISH_MPE_LOG   /* void */
 
#define SIGBUS   SIGILL
 
#define H5_ATTR_FORMAT(X, Y, Z)   /*void*/
 
#define H5_ATTR_UNUSED   /*void*/
 
#define H5_ATTR_NDEBUG_UNUSED   /*void*/
 
#define H5_ATTR_NORETURN   /*void*/
 
#define H5_ATTR_CONST   /*void*/
 
#define H5_ATTR_PURE   /*void*/
 
#define H5_ATTR_FALLTHROUGH   /*void*/
 
#define SUCCEED   0
 
#define FAIL   (-1)
 
#define UFAIL   (unsigned)(-1)
 
#define NELMTS(X)   (sizeof(X)/sizeof(X[0]))
 
#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))
 
#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))
 
#define RANGE(LO, X, HI)   MAX(LO,MIN(X,HI))
 
#define ABS(a)   (((a)>=0) ? (a) : -(a))
 
#define SIGN(a)   ((a)>0 ? 1 : (a)<0 ? -1 : 0)
 
#define POWER_OF_TWO(n)   (!(n & (n - 1)) && n)
 
#define H5_EXP2(n)   (1 << (n))
 
#define FALSE   false
 
#define TRUE   true
 
#define H5_SIZEOF_INT8_T   H5_SIZEOF_CHAR
 
#define H5_SIZEOF_UINT8_T   H5_SIZEOF_CHAR
 
#define LLONG_MAX
 
#define LLONG_MIN   ((long long)(-LLONG_MAX)-1)
 
#define ULLONG_MAX   ((unsigned long long)((long long)(-1)))
 
#define SIZET_MAX   ((size_t)(ssize_t)(-1))
 
#define SSIZET_MAX   ((ssize_t)(((size_t)1<<(8*sizeof(ssize_t)-1))-1))
 
#define HSIZET_MAX   ((hsize_t)ULLONG_MAX)
 
#define HSSIZET_MAX   ((hssize_t)LLONG_MAX)
 
#define HSSIZET_MIN   (~(HSSIZET_MAX))
 
#define h5_posix_io_t   size_t
 
#define h5_posix_io_ret_t   ssize_t
 
#define H5_POSIX_MAX_IO_BYTES   SSIZET_MAX
 
#define H5_POSIX_CREATE_MODE_RW   0666
 
#define H5_REQUEST_NULL   NULL
 
#define H5_DEC_ENUM(TYPE, VAR)   (VAR)=((TYPE)((VAR)-1))
 
#define H5_DOUBLE(S)   ((double) S ## L)
 
#define H5_FLT_ABS_EQUAL(X, Y)   (HDfabsf((X)-(Y)) < FLT_EPSILON)
 
#define H5_DBL_ABS_EQUAL(X, Y)   (HDfabs ((X)-(Y)) < DBL_EPSILON)
 
#define H5_LDBL_ABS_EQUAL(X, Y)   (HDfabsl((X)-(Y)) < LDBL_EPSILON)
 
#define H5_FLT_REL_EQUAL(X, Y, M)   (HDfabsf(((Y)-(X)) / (X)) < (M))
 
#define H5_DBL_REL_EQUAL(X, Y, M)   (HDfabs (((Y)-(X)) / (X)) < (M))
 
#define H5_LDBL_REL_EQUAL(X, Y, M)   (HDfabsl(((Y)-(X)) / (X)) < (M))
 
#define H5_KB   (1024.0F)
 
#define H5_MB   (1024.0F * 1024.0F)
 
#define H5_GB   (1024.0F * 1024.0F * 1024.0F)
 
#define H5_TB   (1024.0F * 1024.0F * 1024.0F * 1024.0F)
 
#define H5_PB   (1024.0F * 1024.0F * 1024.0F * 1024.0F * 1024.0F)
 
#define H5_EB   (1024.0F * 1024.0F * 1024.0F * 1024.0F * 1024.0F * 1024.0F)
 
#define LOCK_SH   0x01
 
#define LOCK_EX   0x02
 
#define LOCK_NB   0x04
 
#define LOCK_UN   0x08
 
#define HDabort()   abort()
 
#define HDabs(X)   abs(X)
 
#define HDaccess(F, M)   access(F, M)
 
#define HDacos(X)   acos(X)
 
#define HDalarm(N)   (0)
 
#define HDasctime(T)   asctime(T)
 
#define HDasin(X)   asin(X)
 
#define HDasprintf   asprintf /*varargs*/
 
#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 HDatoll(S)   atoll(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)
 
#define HDdifftime(X, Y)   ((double)(X)-(double)(Y))
 
#define HDdiv(X, Y)   div(X,Y)
 
#define HDdup(F)   dup(F)
 
#define HDdup2(F, I)   dup2(F,I)
 
#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 HDexp2(X)   exp2(X)
 
#define HDfabs(X)   fabs(X)
 
#define HDfabsf(X)   ABS(X)
 
#define HDfabsl(X)   ABS(X)
 
#define HDfclose(F)   fclose(F)
 
#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 HDflock(F, L)   Nflock(F,L)
 
#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)
 
#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)
 
#define HDfrexpf(X, N)   frexp(X,N)
 
#define HDfrexpl(X, N)   frexp(X,N)
 
#define HDfseek(F, O, W)   fseeko(F,O,W)
 
#define HDfsetpos(F, P)   fsetpos(F,P)
 
#define HDfstat(F, B)   fstat(F,B)
 
#define HDlstat(S, B)   lstat(S,B)
 
#define HDstat(S, B)   stat(S,B)
 
#define HDoff_t   off_t
 
#define H5_SIZEOF_H5_STAT_SIZE_T   H5_SIZEOF_OFF_T
 
#define HDftell(F)   ftello(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 HDgetdcwd(D, S, Z)   getcwd(S,Z)
 
#define HDgetdrive()   0
 
#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 HDgethostname(N, L)   gethostname(N,L)
 
#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 HDisnan(X)   isnan(X)
 
#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 HDllround(V)   llround(V)
 
#define HDllroundf(V)   llroundf(V)
 
#define HDllroundl(V)   llroundl(V)
 
#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 HDlround(V)   lround(V)
 
#define HDlroundf(V)   lroundf(V)
 
#define HDlroundl(V)   lroundl(V)
 
#define HDlseek(F, O, W)   lseek(F,O,W)
 
#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)
 
#define HDmemcpy(X, Y, Z)   memcpy(X,Y,Z)
 
#define HDmemmove(X, Y, Z)   memmove((char*)(X),(const char*)(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)
 
#define HDnanosleep(N, O)   nanosleep(N, O)
 
#define HDopen(F, ...)   open(F,__VA_ARGS__)
 
#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)
 
#define HDpowf(X, Y)   powf(X,Y)
 
#define HDpread(F, B, C, O)   pread(F,B,C,O)
 
#define HDprintf(...)   HDfprintf(stdout, __VA_ARGS__)
 
#define HDputc(C, F)   putc(C,F)
 
#define HDputchar(C)   putchar(C)
 
#define HDputs(S)   puts(S)
 
#define HDpwrite(F, B, C, O)   pwrite(F,B,C,O)
 
#define HDqsort(M, N, Z, F)   qsort(M,N,Z,F)
 
#define HDraise(N)   raise(N)
 
#define HDrand()   rand()
 
#define HDrandom()   rand()
 
#define HDsrand(S)   srand(S)
 
#define HDsrandom(S)   srand(S)
 
#define HDread(F, M, Z)   read(F,M,Z)
 
#define HDreaddir(D)   readdir(D)
 
#define HDrealloc(M, Z)   realloc(M,Z)
 
#define HDrealpath(F1, F2)   realpath(F1,F2)
 
#define HDremove(S)   remove(S)
 
#define HDrename(OLD, NEW)   rename(OLD,NEW)
 
#define HDrewind(F)   rewind(F)
 
#define HDrewinddir(D)   rewinddir(D)
 
#define HDround(V)   round(V)
 
#define HDroundf(V)   roundf(V)
 
#define HDroundl(V)   roundl(V)
 
#define HDrmdir(S)   rmdir(S)
 
#define HDselect(N, RD, WR, ER, T)   select(N,RD,WR,ER,T)
 
#define HDsetbuf(F, S)   setbuf(F,S)
 
#define HDsetenv(N, V, O)   setenv(N,V,O)
 
#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 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)
 
#define HDsnprintf   snprintf /*varargs*/
 
#define HDsprintf   sprintf /*varargs*/
 
#define HDsqrt(X)   sqrt(X)
 
#define HDsscanf(S, FMT, ...)   sscanf(S,FMT,__VA_ARGS__)
 
#define HDstrcat(X, Y)   strcat(X,Y)
 
#define HDstrchr(S, C)   strchr(S,C)
 
#define HDstrcmp(X, Y)   strcmp(X,Y)
 
#define HDstrcasecmp(X, Y)   strcasecmp(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 HDstrtok_r(X, Y, Z)   strtok_r(X,Y,Z)
 
#define HDstrtol(S, R, N)   strtol(S,R,N)
 
#define HDstrtoul(S, R, N)   strtoul(S,R,N)
 
#define HDstrtoull(S, R, N)   strtoull(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_copy(D, S)   va_copy(D,S)
 
#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)
 
#define HDvsnprintf(S, N, FMT, A)   vsnprintf(S,N,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)
 
#define HDstrdup(S)   strdup(S)
 
#define HDpthread_self()   pthread_self()
 
#define HDpthread_self_ulong()   ((unsigned long)pthread_self())
 
#define H5_STRINGIZE(x)   #x
 
#define H5_TOSTRING(x)   H5_STRINGIZE(x)
 
#define H5_GLUE(x, y)   x##y
 
#define H5_GLUE3(x, y, z)   x##y##z
 
#define H5_GLUE4(w, x, y, z)   w##x##y##z
 
#define H5_CHECK_OVERFLOW(var, vartype, casttype)
 
#define ASSIGN_TO_SMALLER_SIZE(dst, dsttype, src, srctype)
 
#define ASSIGN_TO_LARGER_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)   (dst) = (dsttype)(src);
 
#define ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
 
#define ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)   (dst) = (dsttype)(src);
 
#define ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED(dst, dsttype, src, srctype)
 
#define ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED(dst, dsttype, src, srctype)
 
#define ASSIGN_TO_SAME_SIZE_SAME_SIGNED(dst, dsttype, src, srctype)   (dst) = (dsttype)(src);
 
#define H5_CHECKED_ASSIGN(dst, dsttype, src, srctype)   ASSIGN_##srctype##_TO_##dsttype(dst,dsttype,src,srctype)\
 
#define H5_DIR_SEPC   '/'
 
#define H5_DIR_SEPS   "/"
 
#define H5_CHECK_DELIMITER(SS)   (SS == H5_DIR_SEPC)
 
#define H5_CHECK_ABSOLUTE(NAME)   (H5_CHECK_DELIMITER(*NAME))
 
#define H5_CHECK_ABS_DRIVE(NAME)   (0)
 
#define H5_CHECK_ABS_PATH(NAME)   (0)
 
#define H5_GET_LAST_DELIMITER(NAME, ptr)   ptr = HDstrrchr(NAME, H5_DIR_SEPC);
 
#define H5_COLON_SEPC   ':'
 
#define H5DEBUG(X)   (H5_debug_g.pkg[H5_PKG_##X].stream)
 
#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 H5TRACE12(R, T, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)   /*void*/
 
#define H5TRACE_RETURN(V)   /*void*/
 
#define H5_IS_API(S)
 
#define H5_IS_PUB(S)
 
#define H5_IS_PRIV(S)
 
#define H5_IS_PKG(S)
 
#define H5_FIRST_THREAD_INIT
 
#define H5_API_LOCK
 
#define H5_API_UNLOCK
 
#define H5_API_UNSET_CANCEL
 
#define H5_API_SET_CANCEL
 
#define H5_INIT_GLOBAL   (H5_libinit_g)
 
#define H5_TERM_GLOBAL   (H5_libterm_g)
 
#define H5_PUSH_FUNC   /* void */
 
#define H5_POP_FUNC   /* void */
 
#define H5_PACKAGE_INIT_VAR(x)   H5_GLUE(x, _init_g)
 
#define H5_PACKAGE_INIT_FUNC(x)   H5_GLUE(x, __init_package)
 
#define H5_PKG_INIT_VAR   (TRUE)
 
#define H5_PACKAGE_INIT(pkg_init, err)
 
#define FUNC_ENTER_CHECK_NAME(asrt)
 
#define FUNC_ENTER_COMMON(asrt)
 
#define FUNC_ENTER_COMMON_NOERR(asrt)   FUNC_ENTER_CHECK_NAME(asrt);
 
#define FUNC_ENTER_API_THREADSAFE
 
#define FUNC_ENTER_API_VARS
 
#define FUNC_ENTER_API_COMMON
 
#define FUNC_ENTER_API_INIT(err)
 
#define FUNC_ENTER_API(err)
 
#define FUNC_ENTER_API_NOCLEAR(err)
 
#define FUNC_ENTER_API_NOINIT
 
#define FUNC_ENTER_API_NOINIT_NOERR_NOFS
 
#define FUNC_ENTER_NOAPI_INIT(err)
 
#define FUNC_ENTER_NOAPI(err)
 
#define FUNC_ENTER_NOAPI_NOERR
 
#define FUNC_ENTER_NOAPI_NOINIT
 
#define FUNC_ENTER_NOAPI_NOINIT_NOERR
 
#define FUNC_ENTER_NOAPI_NOFS
 
#define FUNC_ENTER_NOAPI_NOERR_NOFS
 
#define FUNC_ENTER_NOAPI_TAG(tag, err)
 
#define FUNC_ENTER_NOAPI_NOINIT_TAG(tag)
 
#define FUNC_ENTER_PACKAGE
 
#define FUNC_ENTER_PACKAGE_NOERR
 
#define FUNC_ENTER_PACKAGE_TAG(tag)
 
#define FUNC_ENTER_STATIC
 
#define FUNC_ENTER_STATIC_NOERR
 
#define FUNC_ENTER_STATIC_NOERR_NOFS
 
#define FUNC_ENTER_STATIC_TAG(tag)
 
#define FUNC_LEAVE_API_THREADSAFE
 
#define FUNC_LEAVE_API_COMMON(ret_value)
 
#define FUNC_LEAVE_API(ret_value)
 
#define FUNC_LEAVE_API_NOINIT(ret_value)
 
#define FUNC_LEAVE_API_NOFS(ret_value)
 
#define FUNC_LEAVE_NOAPI(ret_value)
 
#define FUNC_LEAVE_NOAPI_VOID
 
#define FUNC_LEAVE_NOAPI_NOFS(ret_value)
 
#define FUNC_LEAVE_NOAPI_TAG(ret_value)
 
#define H5_CHECK_PACKAGE_INIT_REG_YES(asrt)   HDassert(H5_PACKAGE_INIT_VAR(pkg));
 
#define H5_CHECK_PACKAGE_INIT_REG_NO(asrt)
 
#define H5_CHECK_PACKAGE_INIT_INIT_YES(asrt)
 
#define H5_CHECK_PACKAGE_INIT_INIT_NO(asrt)
 
#define H5_CHECK_PACKAGE_INIT(pkg, pkg_init, init)   H5_GLUE4(H5_CHECK_PACKAGE_INIT_, init, _, pkg_init)(pkg)
 
#define H5_PKG_YES_INIT(pkg)
 
#define H5_PKG_NO_INIT(pkg)
 
#define H5_PKG_INIT(pkg_init, pkg)   H5_GLUE3(H5_PKG_, pkg_init, _INIT)(pkg)
 
#define H5_PKG_DECLARE_YES_FUNC(pkg)   extern herr_t H5_PACKAGE_INIT_FUNC(pkg)(void);
 
#define H5_PKG_DECLARE_NO_FUNC(pkg)
 
#define H5_PKG_DECLARE_VAR(pkg)   extern hbool_t H5_PACKAGE_INIT_VAR(pkg);
 
#define H5_PKG_DECLARE_FUNC(pkg_init, pkg)   H5_GLUE3(H5_PKG_DECLARE_, pkg_init, _FUNC)(pkg)
 
#define H5_PACKAGE_ENTER(pkg, pkg_init, init)
 
#define H5_PRIVATE_ENTER(pkg, pkg_init)
 
#define H5_PUBLIC_ENTER(pkg, pkg_init)
 
#define FUNC_ENT_STATIC(pkg, pkg_init)   H5_PACKAGE_ENTER(pkg, pkg_init, REG)
 
#define FUNC_ENT_PKGINIT(pkg, pkg_init)   H5_PACKAGE_ENTER(pkg, pkg_init, INIT)
 
#define FUNC_ENT_PKG(pkg, pkg_init)   H5_PACKAGE_ENTER(pkg, pkg_init, REG)
 
#define FUNC_ENT_PRIV(pkg, pkg_init)   H5_PRIVATE_ENTER(pkg, pkg_init)
 
#define FUNC_ENT_PUB(pkg, pkg_init)   H5_PUBLIC_ENTER(pkg, pkg_init)
 
#define FUNC_PREFIX_STATIC   static
 
#define FUNC_PREFIX_PKGINIT
 
#define FUNC_PREFIX_PKG
 
#define FUNC_PREFIX_PRIV
 
#define FUNC_PREFIX_PUB
 
#define FUNC_ERR_VAR_ERR(ret_typ, err)
 
#define FUNC_ERR_VAR_ERRCATCH(ret_typ, err)   hbool_t past_catch = FALSE;
 
#define FUNC_ERR_VAR_NOERR(ret_typ, err)
 
#define BEGIN_FUNC(scope, use_err, ret_typ, ret_init, err, func)
 
#define BEGIN_FUNC_VOID(scope, use_err, func)
 
#define H5_PRIV_YES_FUNC_INIT_FAILED   func_init_failed:
 
#define H5_PRIV_NO_FUNC_INIT_FAILED
 
#define H5_PRIV_FUNC_INIT_FAILED(pkg_init)   H5_GLUE3(H5_PRIV_, pkg_init, _FUNC_INIT_FAILED)
 
#define FUNC_LEAVE_PKGINIT
 
#define FUNC_LEAVE_STATIC
 
#define FUNC_LEAVE_PKG
 
#define FUNC_LEAVE_PRIV
 
#define FUNC_LEAVE_PUB
 
#define END_FUNC(scope)
 
#define END_FUNC_VOID(scope)
 
#define H5_BEGIN_TAG(tag)
 
#define H5_END_TAG
 
#define HDcompile_assert(e)   ((void)sizeof(char[ !!(e) ? 1 : -1]))
 

Typedefs

typedef signed char int8_t
 
typedef unsigned char uint8_t
 
typedef struct H5O_copy_file_ud_common_t H5O_copy_file_ud_common_t
 
typedef struct stat h5_stat_t
 
typedef off_t h5_stat_size_t
 
typedef struct H5_debug_open_stream_t H5_debug_open_stream_t
 
typedef struct H5_debug_t H5_debug_t
 

Enumerations

enum  H5_copy_depth_t { H5_COPY_SHALLOW, H5_COPY_DEEP }
 
enum  H5_pkg_t {
  H5_PKG_A, H5_PKG_AC, H5_PKG_B, H5_PKG_D,
  H5_PKG_E, H5_PKG_F, H5_PKG_G, H5_PKG_HG,
  H5_PKG_HL, H5_PKG_I, H5_PKG_M, H5_PKG_MF,
  H5_PKG_MM, H5_PKG_O, H5_PKG_P, H5_PKG_S,
  H5_PKG_T, H5_PKG_V, H5_PKG_VL, H5_PKG_Z,
  H5_NPKGS
}
 

Functions

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, H5_timer_t *timer)
 
H5_DLL void H5_bandwidth (char *buf, double nbytes, double nseconds)
 
H5_DLL time_t H5_now (void)
 
H5_DLL H5_ATTR_CONST int Nflock (int fd, int operation)
 
H5_DLL int HDfprintf (FILE *stream, const char *fmt,...)
 
H5_DLL int64_t HDstrtoll (const char *s, const char **rest, int base)
 
char * strdup (const char *s)
 
H5_DLL double H5_trace (const double *calltime, const char *func, const char *type,...)
 
H5_DLL herr_t H5CX_push (void)
 
H5_DLL herr_t H5CX_pop (void)
 
H5_DLL herr_t H5_init_library (void)
 
H5_DLL void H5_term_library (void)
 
H5_DLL int H5A_term_package (void)
 
H5_DLL int H5A_top_term_package (void)
 
H5_DLL int H5AC_term_package (void)
 
H5_DLL int H5CX_term_package (void)
 
H5_DLL int H5D_term_package (void)
 
H5_DLL int H5D_top_term_package (void)
 
H5_DLL int H5E_term_package (void)
 
H5_DLL int H5F_term_package (void)
 
H5_DLL int H5FD_term_package (void)
 
H5_DLL int H5FL_term_package (void)
 
H5_DLL int H5FS_term_package (void)
 
H5_DLL int H5G_term_package (void)
 
H5_DLL int H5G_top_term_package (void)
 
H5_DLL int H5I_term_package (void)
 
H5_DLL int H5L_term_package (void)
 
H5_DLL int H5M_term_package (void)
 
H5_DLL int H5M_top_term_package (void)
 
H5_DLL int H5P_term_package (void)
 
H5_DLL int H5PL_term_package (void)
 
H5_DLL int H5R_term_package (void)
 
H5_DLL int H5R_top_term_package (void)
 
H5_DLL int H5S_term_package (void)
 
H5_DLL int H5S_top_term_package (void)
 
H5_DLL int H5SL_term_package (void)
 
H5_DLL int H5T_term_package (void)
 
H5_DLL int H5T_top_term_package (void)
 
H5_DLL int H5VL_term_package (void)
 
H5_DLL int H5Z_term_package (void)
 
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)
 
H5_DLL uint32_t H5_hash_string (const char *str)
 
H5_DLL time_t H5_make_time (struct tm *tm)
 
H5_DLL void H5_nanosleep (uint64_t nanosec)
 
H5_DLL double H5_get_time (void)
 
H5_DLL herr_t H5_build_extpath (const char *name, char **extpath)
 
H5_DLL herr_t H5_combine_path (const char *path1, const char *path2, char **full_name)
 
H5_DLL herr_t H5_buffer_dump (FILE *stream, int indent, const uint8_t *buf, const uint8_t *marker, size_t buf_offset, size_t buf_size)
 

Variables

H5_debug_t H5_debug_g
 
char H5libhdf5_settings []
 
char H5_lib_vers_info_g []
 
hbool_t H5_libinit_g
 
hbool_t H5_libterm_g
 
hbool_t H5_api_entered_g
 

Macro Definition Documentation

◆ ABS

#define ABS (   a)    (((a)>=0) ? (a) : -(a))

◆ ASSIGN_TO_LARGER_SIZE_SAME_SIGNED

#define ASSIGN_TO_LARGER_SIZE_SAME_SIGNED (   dst,
  dsttype,
  src,
  srctype 
)    (dst) = (dsttype)(src);

◆ ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED

#define ASSIGN_TO_LARGER_SIZE_SIGNED_TO_UNSIGNED (   dst,
  dsttype,
  src,
  srctype 
)
Value:
{ \
srctype _tmp_src = (srctype)(src); \
dsttype _tmp_dst = (dsttype)(_tmp_src); \
HDassert(_tmp_src >= 0); \
HDassert(_tmp_src == (srctype)_tmp_dst); \
(dst) = _tmp_dst; \
}

◆ ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED

#define ASSIGN_TO_LARGER_SIZE_UNSIGNED_TO_SIGNED (   dst,
  dsttype,
  src,
  srctype 
)    (dst) = (dsttype)(src);

◆ ASSIGN_TO_SAME_SIZE_SAME_SIGNED

#define ASSIGN_TO_SAME_SIZE_SAME_SIGNED (   dst,
  dsttype,
  src,
  srctype 
)    (dst) = (dsttype)(src);

◆ ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED

#define ASSIGN_TO_SAME_SIZE_SIGNED_TO_UNSIGNED (   dst,
  dsttype,
  src,
  srctype 
)
Value:
{ \
srctype _tmp_src = (srctype)(src); \
dsttype _tmp_dst = (dsttype)(_tmp_src); \
HDassert(_tmp_src >= 0); \
HDassert(_tmp_src == (srctype)_tmp_dst); \
(dst) = _tmp_dst; \
}

◆ ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED

#define ASSIGN_TO_SAME_SIZE_UNSIGNED_TO_SIGNED (   dst,
  dsttype,
  src,
  srctype 
)
Value:
{ \
srctype _tmp_src = (srctype)(src); \
dsttype _tmp_dst = (dsttype)(_tmp_src); \
HDassert(_tmp_dst >= 0); \
HDassert(_tmp_src == (srctype)_tmp_dst); \
(dst) = _tmp_dst; \
}

◆ ASSIGN_TO_SMALLER_SIZE

#define ASSIGN_TO_SMALLER_SIZE (   dst,
  dsttype,
  src,
  srctype 
)
Value:
{ \
srctype _tmp_src = (srctype)(src); \
dsttype _tmp_dst = (dsttype)(_tmp_src); \
HDassert(_tmp_src == (srctype)_tmp_dst); \
(dst) = _tmp_dst; \
}

◆ BEGIN_FUNC

#define BEGIN_FUNC (   scope,
  use_err,
  ret_typ,
  ret_init,
  err,
  func 
)
Value:
H5_GLUE(FUNC_PREFIX_, scope) \
ret_typ \
func \
/* Open function */ \
{ \
ret_typ ret_value = ret_init; \
H5_GLUE(FUNC_ERR_VAR_, use_err)(ret_typ, err) \
H5_GLUE(FUNC_ENT_, scope)(H5_MY_PKG, H5_MY_PKG_INIT)

◆ BEGIN_FUNC_VOID

#define BEGIN_FUNC_VOID (   scope,
  use_err,
  func 
)
Value:
H5_GLUE(FUNC_PREFIX_, scope) \
void \
func \
/* Open function */ \
{ \
H5_GLUE(FUNC_ERR_VAR_, use_err)(void, -, -) \
H5_GLUE(FUNC_ENT_, scope)

◆ BEGIN_MPE_LOG

#define BEGIN_MPE_LOG   /* void */

◆ END_FUNC

#define END_FUNC (   scope)
Value:
/* Scope-specific function conclusion */ \
H5_GLUE(FUNC_LEAVE_, scope) \
\
/* Leave routine */ \
return(ret_value); \
\
/* Close Function */ \
}

◆ END_FUNC_VOID

#define END_FUNC_VOID (   scope)
Value:
/* Scope-specific function conclusion */ \
H5_GLUE(FUNC_LEAVE_, scope) \
\
/* Leave routine */ \
return; \
\
/* Close Function */ \
}

◆ F_OK

#define F_OK   00

◆ FAIL

CATCH FAIL   (-1)

◆ FALSE

#define FALSE   false

◆ FINISH_MPE_LOG

#define FINISH_MPE_LOG   /* void */

◆ FUNC_ENT_PKG

#define FUNC_ENT_PKG (   pkg,
  pkg_init 
)    H5_PACKAGE_ENTER(pkg, pkg_init, REG)

◆ FUNC_ENT_PKGINIT

#define FUNC_ENT_PKGINIT (   pkg,
  pkg_init 
)    H5_PACKAGE_ENTER(pkg, pkg_init, INIT)

◆ FUNC_ENT_PRIV

#define FUNC_ENT_PRIV (   pkg,
  pkg_init 
)    H5_PRIVATE_ENTER(pkg, pkg_init)

◆ FUNC_ENT_PUB

#define FUNC_ENT_PUB (   pkg,
  pkg_init 
)    H5_PUBLIC_ENTER(pkg, pkg_init)

◆ FUNC_ENT_STATIC

#define FUNC_ENT_STATIC (   pkg,
  pkg_init 
)    H5_PACKAGE_ENTER(pkg, pkg_init, REG)

◆ FUNC_ENTER_API

#define FUNC_ENTER_API (   err)
Value:
{{ \
FUNC_ENTER_API_COMMON \
FUNC_ENTER_API_INIT(err); \
/* Clear thread error stack entering public functions */ \
H5E_clear_stack(NULL); \
{

◆ FUNC_ENTER_API_COMMON

#define FUNC_ENTER_API_COMMON
Value:
FUNC_ENTER_API_VARS \
FUNC_ENTER_COMMON(H5_IS_API(FUNC)); \
FUNC_ENTER_API_THREADSAFE;

◆ FUNC_ENTER_API_INIT

#define FUNC_ENTER_API_INIT (   err)
Value:
/* Initialize the library */ \
if(!H5_INIT_GLOBAL && !H5_TERM_GLOBAL) { \
H5_INIT_GLOBAL = TRUE; \
if(H5_init_library() < 0) \
HGOTO_ERROR(H5E_FUNC, H5E_CANTINIT, err, "library initialization failed") \
} /* end if */ \
\
/* Initialize the package, if appropriate */ \
H5_PACKAGE_INIT(H5_MY_PKG_INIT, err) \
\
/* Push the name of this function on the function stack */ \
H5_PUSH_FUNC \
\
/* Push the API context */ \
if(H5CX_push() < 0) \
HGOTO_ERROR(H5E_FUNC, H5E_CANTSET, err, "can't set API context") \
\
BEGIN_MPE_LOG

◆ FUNC_ENTER_API_NOCLEAR

#define FUNC_ENTER_API_NOCLEAR (   err)
Value:
{{ \
FUNC_ENTER_API_COMMON \
FUNC_ENTER_API_INIT(err); \
{

◆ FUNC_ENTER_API_NOINIT

#define FUNC_ENTER_API_NOINIT
Value:
{{{ \
FUNC_ENTER_API_COMMON \
H5_PUSH_FUNC \
BEGIN_MPE_LOG \
{

◆ FUNC_ENTER_API_NOINIT_NOERR_NOFS

#define FUNC_ENTER_API_NOINIT_NOERR_NOFS
Value:
{{{{ \
FUNC_ENTER_API_VARS \
FUNC_ENTER_COMMON_NOERR(H5_IS_API(FUNC)); \
FUNC_ENTER_API_THREADSAFE; \
BEGIN_MPE_LOG \
{

◆ FUNC_ENTER_API_THREADSAFE

#define FUNC_ENTER_API_THREADSAFE
Value:
/* Initialize the thread-safe code */ \
H5_FIRST_THREAD_INIT \
\
/* Grab the mutex for the library */ \
H5_API_UNSET_CANCEL \
H5_API_LOCK

◆ FUNC_ENTER_API_VARS

#define FUNC_ENTER_API_VARS
Value:
MPE_LOG_VARS \
H5TRACE_DECL

◆ FUNC_ENTER_CHECK_NAME

#define FUNC_ENTER_CHECK_NAME (   asrt)
Value:
{ \
static hbool_t func_check = FALSE; \
\
if(!func_check) { \
/* Check function naming status */ \
HDassert(asrt && "Function naming conventions are incorrect - check H5_IS_API|PUB|PRIV|PKG macros in H5private.h (this is usually due to an incorrect number of underscores)"); \
\
/* Don't check again */ \
func_check = TRUE; \
} /* end if */ \
} /* end scope */

◆ FUNC_ENTER_COMMON

#define FUNC_ENTER_COMMON (   asrt)
Value:
hbool_t err_occurred = FALSE; \
\
FUNC_ENTER_CHECK_NAME(asrt);

◆ FUNC_ENTER_COMMON_NOERR

#define FUNC_ENTER_COMMON_NOERR (   asrt)    FUNC_ENTER_CHECK_NAME(asrt);

◆ FUNC_ENTER_NOAPI

#define FUNC_ENTER_NOAPI (   err)
Value:
{ \
FUNC_ENTER_COMMON(!H5_IS_API(FUNC)); \
FUNC_ENTER_NOAPI_INIT(err) \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_NOAPI_INIT

#define FUNC_ENTER_NOAPI_INIT (   err)
Value:
/* Initialize the package, if appropriate */ \
H5_PACKAGE_INIT(H5_MY_PKG_INIT, err) \
\
/* Push the name of this function on the function stack */ \
H5_PUSH_FUNC

◆ FUNC_ENTER_NOAPI_NOERR

#define FUNC_ENTER_NOAPI_NOERR
Value:
{ \
FUNC_ENTER_COMMON_NOERR(!H5_IS_API(FUNC)); \
FUNC_ENTER_NOAPI_INIT(-) \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_NOAPI_NOERR_NOFS

#define FUNC_ENTER_NOAPI_NOERR_NOFS
Value:
{ \
FUNC_ENTER_COMMON_NOERR(!H5_IS_API(FUNC)); \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_NOAPI_NOFS

#define FUNC_ENTER_NOAPI_NOFS
Value:
{ \
FUNC_ENTER_COMMON(!H5_IS_API(FUNC)); \
\
/* Initialize the package, if appropriate */ \
H5_PACKAGE_INIT(H5_MY_PKG_INIT, err) \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_NOAPI_NOINIT

#define FUNC_ENTER_NOAPI_NOINIT
Value:
{ \
FUNC_ENTER_COMMON(!H5_IS_API(FUNC)); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_NOAPI_NOINIT_NOERR

#define FUNC_ENTER_NOAPI_NOINIT_NOERR
Value:
{ \
FUNC_ENTER_COMMON_NOERR(!H5_IS_API(FUNC)); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_NOAPI_NOINIT_TAG

#define FUNC_ENTER_NOAPI_NOINIT_TAG (   tag)
Value:
{ \
haddr_t prev_tag = HADDR_UNDEF; \
\
FUNC_ENTER_COMMON(!H5_IS_API(FUNC)); \
H5AC_tag(tag, &prev_tag); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_NOAPI_TAG

#define FUNC_ENTER_NOAPI_TAG (   tag,
  err 
)
Value:
{ \
haddr_t prev_tag = HADDR_UNDEF; \
\
FUNC_ENTER_COMMON(!H5_IS_API(FUNC)); \
H5AC_tag(tag, &prev_tag); \
FUNC_ENTER_NOAPI_INIT(err) \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_PACKAGE

#define FUNC_ENTER_PACKAGE
Value:
{ \
FUNC_ENTER_COMMON(H5_IS_PKG(FUNC)); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_PACKAGE_NOERR

#define FUNC_ENTER_PACKAGE_NOERR
Value:
{ \
FUNC_ENTER_COMMON_NOERR(H5_IS_PKG(FUNC)); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_PACKAGE_TAG

#define FUNC_ENTER_PACKAGE_TAG (   tag)
Value:
{ \
haddr_t prev_tag = HADDR_UNDEF; \
\
FUNC_ENTER_COMMON(H5_IS_PKG(FUNC)); \
H5AC_tag(tag, &prev_tag); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_STATIC

#define FUNC_ENTER_STATIC
Value:
{ \
FUNC_ENTER_COMMON(H5_IS_PKG(FUNC)); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_STATIC_NOERR

#define FUNC_ENTER_STATIC_NOERR
Value:
{ \
FUNC_ENTER_COMMON_NOERR(H5_IS_PKG(FUNC)); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_STATIC_NOERR_NOFS

#define FUNC_ENTER_STATIC_NOERR_NOFS
Value:
{ \
FUNC_ENTER_COMMON_NOERR(H5_IS_PKG(FUNC)); \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ENTER_STATIC_TAG

#define FUNC_ENTER_STATIC_TAG (   tag)
Value:
{ \
haddr_t prev_tag = HADDR_UNDEF; \
\
FUNC_ENTER_COMMON(H5_IS_PKG(FUNC)); \
H5AC_tag(tag, &prev_tag); \
H5_PUSH_FUNC \
if(H5_PKG_INIT_VAR || !H5_TERM_GLOBAL) {

◆ FUNC_ERR_VAR_ERR

#define FUNC_ERR_VAR_ERR (   ret_typ,
  err 
)
Value:
hbool_t past_catch = FALSE; \
ret_typ fail_value = err;

◆ FUNC_ERR_VAR_ERRCATCH

#define FUNC_ERR_VAR_ERRCATCH (   ret_typ,
  err 
)    hbool_t past_catch = FALSE;

◆ FUNC_ERR_VAR_NOERR

#define FUNC_ERR_VAR_NOERR (   ret_typ,
  err 
)

◆ FUNC_LEAVE_API

#define FUNC_LEAVE_API (   ret_value)
Value:
FUNC_LEAVE_API_COMMON(ret_value); \
(void)H5CX_pop(); \
H5_POP_FUNC \
if(err_occurred) \
(void)H5E_dump_api_stack(TRUE); \
FUNC_LEAVE_API_THREADSAFE \
return(ret_value); \
}} /*end scope from beginning of FUNC_ENTER*/

◆ FUNC_LEAVE_API_COMMON

#define FUNC_LEAVE_API_COMMON (   ret_value)
Value:
; \
} /*end scope from end of FUNC_ENTER*/ \
FINISH_MPE_LOG \
H5TRACE_RETURN(ret_value);

◆ FUNC_LEAVE_API_NOFS

#define FUNC_LEAVE_API_NOFS (   ret_value)
Value:
FUNC_LEAVE_API_COMMON(ret_value); \
FUNC_LEAVE_API_THREADSAFE \
return(ret_value); \
}}}} /*end scope from beginning of FUNC_ENTER*/

◆ FUNC_LEAVE_API_NOINIT

#define FUNC_LEAVE_API_NOINIT (   ret_value)
Value:
FUNC_LEAVE_API_COMMON(ret_value); \
H5_POP_FUNC \
if(err_occurred) \
(void)H5E_dump_api_stack(TRUE); \
FUNC_LEAVE_API_THREADSAFE \
return(ret_value); \
}}} /*end scope from beginning of FUNC_ENTER*/

◆ FUNC_LEAVE_API_THREADSAFE

#define FUNC_LEAVE_API_THREADSAFE
Value:
H5_API_UNLOCK \
H5_API_SET_CANCEL

◆ FUNC_LEAVE_NOAPI

#define FUNC_LEAVE_NOAPI (   ret_value)
Value:
; \
} /*end scope from end of FUNC_ENTER*/ \
H5_POP_FUNC \
return(ret_value); \
} /*end scope from beginning of FUNC_ENTER*/

◆ FUNC_LEAVE_NOAPI_NOFS

#define FUNC_LEAVE_NOAPI_NOFS (   ret_value)
Value:
; \
} /*end scope from end of FUNC_ENTER*/ \
return(ret_value); \
} /*end scope from beginning of FUNC_ENTER*/

◆ FUNC_LEAVE_NOAPI_TAG

#define FUNC_LEAVE_NOAPI_TAG (   ret_value)
Value:
; \
} /*end scope from end of FUNC_ENTER*/ \
H5AC_tag(prev_tag, NULL); \
H5_POP_FUNC \
return(ret_value); \
} /*end scope from beginning of FUNC_ENTER*/

◆ FUNC_LEAVE_NOAPI_VOID

#define FUNC_LEAVE_NOAPI_VOID
Value:
; \
} /*end scope from end of FUNC_ENTER*/ \
H5_POP_FUNC \
return; \
} /*end scope from beginning of FUNC_ENTER*/

◆ FUNC_LEAVE_PKG

#define FUNC_LEAVE_PKG
Value:
/* Leave scope for this type of function */ \
} \
\
/* Pop the name of this function off the function stack */ \
H5_POP_FUNC

◆ FUNC_LEAVE_PKGINIT

#define FUNC_LEAVE_PKGINIT
Value:
/* Leave scope for this type of function */ \
} \
\
/* Pop the name of this function off the function stack */ \
H5_POP_FUNC

◆ FUNC_LEAVE_PRIV

#define FUNC_LEAVE_PRIV
Value:
/* Leave scope for this type of function */ \
}} \
\
/* Label for errors during FUNC_ENTER */ \
H5_PRIV_FUNC_INIT_FAILED(H5_MY_PKG_INIT) \
\
/* Pop the name of this function off the function stack */ \
H5_POP_FUNC

◆ FUNC_LEAVE_PUB

#define FUNC_LEAVE_PUB
Value:
/* Leave scope for this type of function */ \
}}} \
\
/* Label for errors during FUNC_ENTER */ \
func_init_failed: \
\
/* Dump error stack if an error occurred during API routine */ \
if(ret_value == fail_value) \
(void)H5E_dump_api_stack(TRUE); \
\
/* Finish the API tracing info */ \
H5TRACE_RETURN(ret_value); \
\
/* Pop the name of this function off the function stack */ \
H5_POP_FUNC \
\
/* Finish the MPE tracing info */ \
FINISH_MPE_LOG \
\
/* Check for leaving API routine */ \
HDassert(H5_api_entered_g); \
H5_api_entered_g = FALSE; \
\
/* Release thread-safety semaphore */ \
FUNC_LEAVE_API_THREADSAFE

◆ FUNC_LEAVE_STATIC

#define FUNC_LEAVE_STATIC
Value:
/* Leave scope for this type of function */ \
} \
\
/* Pop the name of this function off the function stack */ \
H5_POP_FUNC

◆ FUNC_PREFIX_PKG

#define FUNC_PREFIX_PKG

◆ FUNC_PREFIX_PKGINIT

#define FUNC_PREFIX_PKGINIT

◆ FUNC_PREFIX_PRIV

#define FUNC_PREFIX_PRIV

◆ FUNC_PREFIX_PUB

#define FUNC_PREFIX_PUB

◆ FUNC_PREFIX_STATIC

#define FUNC_PREFIX_STATIC   static

◆ H5_API_LOCK

#define H5_API_LOCK

◆ H5_API_SET_CANCEL

#define H5_API_SET_CANCEL

◆ H5_API_UNLOCK

#define H5_API_UNLOCK

◆ H5_API_UNSET_CANCEL

#define H5_API_UNSET_CANCEL

◆ H5_ATTR_CONST

#define H5_ATTR_CONST   /*void*/

◆ H5_ATTR_FALLTHROUGH

#define H5_ATTR_FALLTHROUGH   /*void*/

◆ H5_ATTR_FORMAT

#define H5_ATTR_FORMAT (   X,
  Y,
  Z 
)    /*void*/

◆ H5_ATTR_NDEBUG_UNUSED

#define H5_ATTR_NDEBUG_UNUSED   /*void*/

◆ H5_ATTR_NORETURN

#define H5_ATTR_NORETURN   /*void*/

◆ H5_ATTR_PURE

#define H5_ATTR_PURE   /*void*/

◆ H5_ATTR_UNUSED

#define H5_ATTR_UNUSED   /*void*/

◆ H5_BEGIN_TAG

#define H5_BEGIN_TAG (   tag)
Value:
{ \
haddr_t prv_tag = HADDR_UNDEF; \
H5AC_tag(tag, &prv_tag); \

◆ H5_CHECK_ABS_DRIVE

#define H5_CHECK_ABS_DRIVE (   NAME)    (0)

◆ H5_CHECK_ABS_PATH

#define H5_CHECK_ABS_PATH (   NAME)    (0)

◆ H5_CHECK_ABSOLUTE

#define H5_CHECK_ABSOLUTE (   NAME)    (H5_CHECK_DELIMITER(*NAME))

◆ H5_CHECK_DELIMITER

#define H5_CHECK_DELIMITER (   SS)    (SS == H5_DIR_SEPC)

◆ H5_CHECK_OVERFLOW

#define H5_CHECK_OVERFLOW (   var,
  vartype,
  casttype 
)
Value:
{ \
casttype _tmp_overflow = (casttype)(var); \
HDassert((var) == (vartype)_tmp_overflow); \
}

◆ H5_CHECK_PACKAGE_INIT

#define H5_CHECK_PACKAGE_INIT (   pkg,
  pkg_init,
  init 
)    H5_GLUE4(H5_CHECK_PACKAGE_INIT_, init, _, pkg_init)(pkg)

◆ H5_CHECK_PACKAGE_INIT_INIT_NO

#define H5_CHECK_PACKAGE_INIT_INIT_NO (   asrt)

◆ H5_CHECK_PACKAGE_INIT_INIT_YES

#define H5_CHECK_PACKAGE_INIT_INIT_YES (   asrt)

◆ H5_CHECK_PACKAGE_INIT_REG_NO

#define H5_CHECK_PACKAGE_INIT_REG_NO (   asrt)

◆ H5_CHECK_PACKAGE_INIT_REG_YES

#define H5_CHECK_PACKAGE_INIT_REG_YES (   asrt)    HDassert(H5_PACKAGE_INIT_VAR(pkg));

◆ H5_CHECKED_ASSIGN

#define H5_CHECKED_ASSIGN (   dst,
  dsttype,
  src,
  srctype 
)    ASSIGN_##srctype##_TO_##dsttype(dst,dsttype,src,srctype)\

◆ H5_COLON_SEPC

#define H5_COLON_SEPC   ':'

◆ H5_DBL_ABS_EQUAL

#define H5_DBL_ABS_EQUAL (   X,
  Y 
)    (HDfabs ((X)-(Y)) < DBL_EPSILON)

◆ H5_DBL_REL_EQUAL

#define H5_DBL_REL_EQUAL (   X,
  Y,
  M 
)    (HDfabs (((Y)-(X)) / (X)) < (M))

◆ H5_DEC_ENUM

#define H5_DEC_ENUM (   TYPE,
  VAR 
)    (VAR)=((TYPE)((VAR)-1))

◆ H5_DEFAULT_VFD

#define H5_DEFAULT_VFD   H5FD_SEC2

◆ H5_DEFAULT_VOL

#define H5_DEFAULT_VOL   H5VL_NATIVE

◆ H5_DIR_SEPC

#define H5_DIR_SEPC   '/'

◆ H5_DIR_SEPS

#define H5_DIR_SEPS   "/"

◆ H5_DOUBLE

#define H5_DOUBLE (   S)    ((double) S ## L)

◆ H5_EB

#define H5_EB   (1024.0F * 1024.0F * 1024.0F * 1024.0F * 1024.0F * 1024.0F)

◆ H5_END_TAG

#define H5_END_TAG
Value:
H5AC_tag(prv_tag, NULL); \
}

◆ H5_EXP2

#define H5_EXP2 (   n)    (1 << (n))

◆ H5_FIRST_THREAD_INIT

#define H5_FIRST_THREAD_INIT

◆ H5_FLT_ABS_EQUAL

#define H5_FLT_ABS_EQUAL (   X,
  Y 
)    (HDfabsf((X)-(Y)) < FLT_EPSILON)

◆ H5_FLT_REL_EQUAL

#define H5_FLT_REL_EQUAL (   X,
  Y,
  M 
)    (HDfabsf(((Y)-(X)) / (X)) < (M))

◆ H5_GB

#define H5_GB   (1024.0F * 1024.0F * 1024.0F)

◆ H5_GET_LAST_DELIMITER

#define H5_GET_LAST_DELIMITER (   NAME,
  ptr 
)    ptr = HDstrrchr(NAME, H5_DIR_SEPC);

◆ H5_GLUE

#define H5_GLUE (   x,
  y 
)    x##y

◆ H5_GLUE3

#define H5_GLUE3 (   x,
  y,
  z 
)    x##y##z

◆ H5_GLUE4

#define H5_GLUE4 (   w,
  x,
  y,
  z 
)    w##x##y##z

◆ H5_INIT_GLOBAL

#define H5_INIT_GLOBAL   (H5_libinit_g)

◆ H5_INLINE

#define H5_INLINE

◆ H5_IS_API

#define H5_IS_API (   S)
Value:
(\
'_'!=((const char *)S)[2] /* underscore at position 2 */ \
&& '_'!=((const char *)S)[3] /* underscore at position 3 */ \
&& !( /* NOT */ \
((const char *)S)[4] /* pos 4 exists */ \
&& (HDisupper(S[3]) || HDisdigit(S[3])) /* pos 3 dig | uc */ \
&& '_'==((const char *)S)[4] /* pos 4 underscore */ \
)\
)

◆ H5_IS_PKG

#define H5_IS_PKG (   S)
Value:
(((HDisdigit(S[1]) || HDisupper(S[1])) && '_' == S[2] && '_' == S[3] && HDislower(S[4])) || \
((HDisdigit(S[2]) || HDisupper(S[2])) && '_' == S[3] && '_' == S[4] && HDislower(S[5])) || \
((HDisdigit(S[3]) || HDisupper(S[3])) && '_' == S[4] && '_' == S[5] && HDislower(S[6])))

◆ H5_IS_PRIV

#define H5_IS_PRIV (   S)
Value:
(((HDisdigit(S[1]) || HDisupper(S[1])) && '_' == S[2] && HDislower(S[3])) || \
((HDisdigit(S[2]) || HDisupper(S[2])) && '_' == S[3] && HDislower(S[4])) || \
((HDisdigit(S[3]) || HDisupper(S[3])) && '_' == S[4] && HDislower(S[5])))

◆ H5_IS_PUB

#define H5_IS_PUB (   S)
Value:
(((HDisdigit(S[1]) || HDisupper(S[1])) && HDislower(S[2])) || \
((HDisdigit(S[2]) || HDisupper(S[2])) && HDislower(S[3])) || \
(!S[4] || ((HDisdigit(S[3]) || HDisupper(S[3])) && HDislower(S[4]))))

◆ H5_KB

#define H5_KB   (1024.0F)

◆ H5_LDBL_ABS_EQUAL

#define H5_LDBL_ABS_EQUAL (   X,
  Y 
)    (HDfabsl((X)-(Y)) < LDBL_EPSILON)

◆ H5_LDBL_REL_EQUAL

#define H5_LDBL_REL_EQUAL (   X,
  Y,
  M 
)    (HDfabsl(((Y)-(X)) / (X)) < (M))

◆ H5_MB

#define H5_MB   (1024.0F * 1024.0F)

◆ H5_PACKAGE_ENTER

#define H5_PACKAGE_ENTER (   pkg,
  pkg_init,
  init 
)
Value:
FUNC_ENTER_CHECK_NAME(H5_IS_PKG(FUNC)) \
\
/* The library should be initialized already */ \
HDassert(H5_INIT_GLOBAL); \
\
/* This interface should be initialized already */ \
/* (except for package initialization routines :-) */ \
H5_CHECK_PACKAGE_INIT(pkg, pkg_init, init) \
\
/* Push the name of this function on the function stack */ \
H5_PUSH_FUNC \
\
/* Enter scope for this type of function */ \
{

◆ H5_PACKAGE_INIT

#define H5_PACKAGE_INIT (   pkg_init,
  err 
)

◆ H5_PACKAGE_INIT_FUNC

#define H5_PACKAGE_INIT_FUNC (   x)    H5_GLUE(x, __init_package)

◆ H5_PACKAGE_INIT_VAR

#define H5_PACKAGE_INIT_VAR (   x)    H5_GLUE(x, _init_g)

◆ H5_PB

#define H5_PB   (1024.0F * 1024.0F * 1024.0F * 1024.0F * 1024.0F)

◆ H5_PKG_DECLARE_FUNC

#define H5_PKG_DECLARE_FUNC (   pkg_init,
  pkg 
)    H5_GLUE3(H5_PKG_DECLARE_, pkg_init, _FUNC)(pkg)

◆ H5_PKG_DECLARE_NO_FUNC

#define H5_PKG_DECLARE_NO_FUNC (   pkg)

◆ H5_PKG_DECLARE_VAR

#define H5_PKG_DECLARE_VAR (   pkg)    extern hbool_t H5_PACKAGE_INIT_VAR(pkg);

◆ H5_PKG_DECLARE_YES_FUNC

#define H5_PKG_DECLARE_YES_FUNC (   pkg)    extern herr_t H5_PACKAGE_INIT_FUNC(pkg)(void);

◆ H5_PKG_INIT

#define H5_PKG_INIT (   pkg_init,
  pkg 
)    H5_GLUE3(H5_PKG_, pkg_init, _INIT)(pkg)

◆ H5_PKG_INIT_VAR

#define H5_PKG_INIT_VAR   (TRUE)

◆ H5_PKG_NO_INIT

#define H5_PKG_NO_INIT (   pkg)
Value:
if(!H5_PACKAGE_INIT_VAR(pkg) && !H5_TERM_GLOBAL) \
H5_PACKAGE_INIT_VAR(pkg) = TRUE;

◆ H5_PKG_YES_INIT

#define H5_PKG_YES_INIT (   pkg)
Value:
if(!H5_PACKAGE_INIT_VAR(pkg) && !H5_TERM_GLOBAL) { \
H5_PACKAGE_INIT_VAR(pkg) = TRUE; \
if(H5_PACKAGE_INIT_FUNC(pkg)() < 0) { \
H5_PACKAGE_INIT_VAR(pkg) = FALSE; \
/* (Can't use H5E_THROW here) */ \
H5E_PRINTF(H5E_CANTINIT, "interface initialization failed"); \
ret_value = fail_value; \
goto func_init_failed; \
} /* end if */ \
} /* end if */

◆ H5_POP_FUNC

#define H5_POP_FUNC   /* void */

◆ H5_POSIX_CREATE_MODE_RW

#define H5_POSIX_CREATE_MODE_RW   0666

◆ h5_posix_io_ret_t

#define h5_posix_io_ret_t   ssize_t

◆ h5_posix_io_t

#define h5_posix_io_t   size_t

◆ H5_POSIX_MAX_IO_BYTES

#define H5_POSIX_MAX_IO_BYTES   SSIZET_MAX

◆ H5_PRIV_FUNC_INIT_FAILED

#define H5_PRIV_FUNC_INIT_FAILED (   pkg_init)    H5_GLUE3(H5_PRIV_, pkg_init, _FUNC_INIT_FAILED)

◆ H5_PRIV_NO_FUNC_INIT_FAILED

#define H5_PRIV_NO_FUNC_INIT_FAILED

◆ H5_PRIV_YES_FUNC_INIT_FAILED

#define H5_PRIV_YES_FUNC_INIT_FAILED   func_init_failed:

◆ H5_PRIVATE_ENTER

#define H5_PRIVATE_ENTER (   pkg,
  pkg_init 
)
Value:
FUNC_ENTER_CHECK_NAME(H5_IS_PRIV(FUNC)) \
\
/* The library should be initialized already */ \
HDassert(H5_INIT_GLOBAL); \
\
/* Initialize this interface if desired */ \
H5_PKG_INIT(pkg_init, pkg) \
\
/* Push the name of this function on the function stack */ \
H5_PUSH_FUNC \
\
/* Enter scope for this type of function */ \
{{

◆ H5_PUBLIC_ENTER

#define H5_PUBLIC_ENTER (   pkg,
  pkg_init 
)

◆ H5_PUSH_FUNC

#define H5_PUSH_FUNC   /* void */

◆ H5_REQUEST_NULL

#define H5_REQUEST_NULL   NULL

◆ H5_SIZEOF_H5_STAT_SIZE_T

#define H5_SIZEOF_H5_STAT_SIZE_T   H5_SIZEOF_OFF_T

◆ H5_SIZEOF_INT8_T

#define H5_SIZEOF_INT8_T   H5_SIZEOF_CHAR

◆ H5_SIZEOF_UINT8_T

#define H5_SIZEOF_UINT8_T   H5_SIZEOF_CHAR

◆ H5_STRINGIZE

#define H5_STRINGIZE (   x)    #x

◆ H5_TB

#define H5_TB   (1024.0F * 1024.0F * 1024.0F * 1024.0F)

◆ H5_TERM_GLOBAL

#define H5_TERM_GLOBAL   (H5_libterm_g)

◆ H5_TOSTRING

#define H5_TOSTRING (   x)    H5_STRINGIZE(x)

◆ H5DEBUG

#define H5DEBUG (   X)    (H5_debug_g.pkg[H5_PKG_##X].stream)

◆ H5TRACE0

#define H5TRACE0 (   R,
  T 
)    /*void*/

◆ H5TRACE1

#define H5TRACE1 (   R,
  T,
  A0 
)    /*void*/

◆ H5TRACE10

#define H5TRACE10 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4,
  A5,
  A6,
  A7,
  A8,
  A9 
)    /*void*/

◆ H5TRACE11

#define H5TRACE11 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4,
  A5,
  A6,
  A7,
  A8,
  A9,
  A10 
)    /*void*/

◆ H5TRACE12

#define H5TRACE12 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4,
  A5,
  A6,
  A7,
  A8,
  A9,
  A10,
  A11 
)    /*void*/

◆ H5TRACE2

#define H5TRACE2 (   R,
  T,
  A0,
  A1 
)    /*void*/

◆ H5TRACE3

#define H5TRACE3 (   R,
  T,
  A0,
  A1,
  A2 
)    /*void*/

◆ H5TRACE4

#define H5TRACE4 (   R,
  T,
  A0,
  A1,
  A2,
  A3 
)    /*void*/

◆ H5TRACE5

#define H5TRACE5 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4 
)    /*void*/

◆ H5TRACE6

#define H5TRACE6 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4,
  A5 
)    /*void*/

◆ H5TRACE7

#define H5TRACE7 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4,
  A5,
  A6 
)    /*void*/

◆ H5TRACE8

#define H5TRACE8 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4,
  A5,
  A6,
  A7 
)    /*void*/

◆ H5TRACE9

#define H5TRACE9 (   R,
  T,
  A0,
  A1,
  A2,
  A3,
  A4,
  A5,
  A6,
  A7,
  A8 
)    /*void*/

◆ H5TRACE_DECL

#define H5TRACE_DECL   /*void*/

◆ H5TRACE_RETURN

#define H5TRACE_RETURN (   V)    /*void*/

◆ HD_exit

#define HD_exit (   N)    _exit(N)

◆ HDabort

#define HDabort ( )    abort()

◆ HDabs

#define HDabs (   X)    abs(X)

◆ HDaccess

#define HDaccess (   F,
  M 
)    access(F, M)

◆ HDacos

#define HDacos (   X)    acos(X)

◆ HDalarm

#define HDalarm (   N)    (0)

◆ HDasctime

#define HDasctime (   T)    asctime(T)

◆ HDasin

#define HDasin (   X)    asin(X)

◆ HDasprintf

#define HDasprintf   asprintf /*varargs*/

◆ HDassert

#define HDassert (   X)    assert(X)

◆ HDatan

#define HDatan (   X)    atan(X)

◆ HDatan2

#define HDatan2 (   X,
  Y 
)    atan2(X,Y)

◆ HDatexit

#define HDatexit (   F)    atexit(F)

◆ HDatof

#define HDatof (   S)    atof(S)

◆ HDatoi

#define HDatoi (   S)    atoi(S)

◆ HDatol

#define HDatol (   S)    atol(S)

◆ HDatoll

#define HDatoll (   S)    atoll(S)

◆ HDbsearch

#define HDbsearch (   K,
  B,
  N,
  Z,
  F 
)    bsearch(K,B,N,Z,F)

◆ HDcalloc

#define HDcalloc (   N,
  Z 
)    calloc(N,Z)

◆ HDceil

#define HDceil (   X)    ceil(X)

◆ HDcfgetispeed

#define HDcfgetispeed (   T)    cfgetispeed(T)

◆ HDcfgetospeed

#define HDcfgetospeed (   T)    cfgetospeed(T)

◆ HDcfsetispeed

#define HDcfsetispeed (   T,
  S 
)    cfsetispeed(T,S)

◆ HDcfsetospeed

#define HDcfsetospeed (   T,
  S 
)    cfsetospeed(T,S)

◆ HDchdir

#define HDchdir (   S)    chdir(S)

◆ HDchmod

#define HDchmod (   S,
  M 
)    chmod(S,M)

◆ HDchown

#define HDchown (   S,
  O,
  G 
)    chown(S,O,G)

◆ HDclearerr

#define HDclearerr (   F)    clearerr(F)

◆ HDclock

#define HDclock ( )    clock()

◆ HDclose

#define HDclose (   F)    close(F)

◆ HDclosedir

#define HDclosedir (   D)    closedir(D)

◆ HDcompile_assert

#define HDcompile_assert (   e)    ((void)sizeof(char[ !!(e) ? 1 : -1]))

◆ HDcos

#define HDcos (   X)    cos(X)

◆ HDcosh

#define HDcosh (   X)    cosh(X)

◆ HDcreat

#define HDcreat (   S,
  M 
)    creat(S,M)

◆ HDctermid

#define HDctermid (   S)    ctermid(S)

◆ HDctime

#define HDctime (   T)    ctime(T)

◆ HDcuserid

#define HDcuserid (   S)    cuserid(S)

◆ HDdifftime

#define HDdifftime (   X,
  Y 
)    ((double)(X)-(double)(Y))

◆ HDdiv

#define HDdiv (   X,
  Y 
)    div(X,Y)

◆ HDdup

#define HDdup (   F)    dup(F)

◆ HDdup2

#define HDdup2 (   F,
  I 
)    dup2(F,I)

◆ HDexecv

#define HDexecv (   S,
  AV 
)    execv(S,AV)

◆ HDexecve

#define HDexecve (   S,
  AV,
  E 
)    execve(S,AV,E)

◆ HDexecvp

#define HDexecvp (   S,
  AV 
)    execvp(S,AV)

◆ HDexit

#define HDexit (   N)    exit(N)

◆ HDexp

#define HDexp (   X)    exp(X)

◆ HDexp2

#define HDexp2 (   X)    exp2(X)

◆ HDfabs

#define HDfabs (   X)    fabs(X)

◆ HDfabsf

#define HDfabsf (   X)    ABS(X)

◆ HDfabsl

#define HDfabsl (   X)    ABS(X)

◆ HDfclose

#define HDfclose (   F)    fclose(F)

◆ HDfdopen

#define HDfdopen (   N,
  S 
)    fdopen(N,S)

◆ HDfeof

#define HDfeof (   F)    feof(F)

◆ HDferror

#define HDferror (   F)    ferror(F)

◆ HDfflush

#define HDfflush (   F)    fflush(F)

◆ HDfgetc

#define HDfgetc (   F)    fgetc(F)

◆ HDfgetpos

#define HDfgetpos (   F,
  P 
)    fgetpos(F,P)

◆ HDfgets

#define HDfgets (   S,
  N,
  F 
)    fgets(S,N,F)

◆ HDfileno

#define HDfileno (   F)    fileno(F)

◆ HDflock

#define HDflock (   F,
  L 
)    Nflock(F,L)

◆ HDfloor

#define HDfloor (   X)    floor(X)

◆ HDfmod

#define HDfmod (   X,
  Y 
)    fmod(X,Y)

◆ HDfopen

#define HDfopen (   S,
  M 
)    fopen(S,M)

◆ HDfork

#define HDfork ( )    fork()

◆ HDfpathconf

#define HDfpathconf (   F,
  N 
)    fpathconf(F,N)

◆ HDfputc

#define HDfputc (   C,
  F 
)    fputc(C,F)

◆ HDfputs

#define HDfputs (   S,
  F 
)    fputs(S,F)

◆ HDfread

#define HDfread (   M,
  Z,
  N,
  F 
)    fread(M,Z,N,F)

◆ HDfree

#define HDfree (   M)    free(M)

◆ HDfreopen

#define HDfreopen (   S,
  M,
  F 
)    freopen(S,M,F)

◆ HDfrexp

#define HDfrexp (   X,
  N 
)    frexp(X,N)

◆ HDfrexpf

#define HDfrexpf (   X,
  N 
)    frexp(X,N)

◆ HDfrexpl

#define HDfrexpl (   X,
  N 
)    frexp(X,N)

◆ HDfseek

#define HDfseek (   F,
  O,
  W 
)    fseeko(F,O,W)

◆ HDfsetpos

#define HDfsetpos (   F,
  P 
)    fsetpos(F,P)

◆ HDfstat

#define HDfstat (   F,
  B 
)    fstat(F,B)

◆ HDftell

#define HDftell (   F)    ftello(F)

◆ HDftruncate

#define HDftruncate (   F,
  L 
)    ftruncate(F,L)

◆ HDfwrite

#define HDfwrite (   M,
  Z,
  N,
  F 
)    fwrite(M,Z,N,F)

◆ HDgetc

#define HDgetc (   F)    getc(F)

◆ HDgetchar

#define HDgetchar ( )    getchar()

◆ HDgetcwd

#define HDgetcwd (   S,
  Z 
)    getcwd(S,Z)

◆ HDgetdcwd

#define HDgetdcwd (   D,
  S,
  Z 
)    getcwd(S,Z)

◆ HDgetdrive

#define HDgetdrive ( )    0

◆ HDgetegid

#define HDgetegid ( )    getegid()

◆ HDgetenv

#define HDgetenv (   S)    getenv(S)

◆ HDgeteuid

#define HDgeteuid ( )    geteuid()

◆ HDgetgid

#define HDgetgid ( )    getgid()

◆ HDgetgrgid

#define HDgetgrgid (   G)    getgrgid(G)

◆ HDgetgrnam

#define HDgetgrnam (   S)    getgrnam(S)

◆ HDgetgroups

#define HDgetgroups (   Z,
  G 
)    getgroups(Z,G)

◆ HDgethostname

#define HDgethostname (   N,
  L 
)    gethostname(N,L)

◆ HDgetlogin

#define HDgetlogin ( )    getlogin()

◆ HDgetpgrp

#define HDgetpgrp ( )    getpgrp()

◆ HDgetpid

#define HDgetpid ( )    getpid()

◆ HDgetppid

#define HDgetppid ( )    getppid()

◆ HDgetpwnam

#define HDgetpwnam (   S)    getpwnam(S)

◆ HDgetpwuid

#define HDgetpwuid (   U)    getpwuid(U)

◆ HDgetrusage

#define HDgetrusage (   X,
  S 
)    getrusage(X,S)

◆ HDgets

#define HDgets (   S)    gets(S)

◆ HDgettimeofday

#define HDgettimeofday (   S,
  P 
)    gettimeofday(S,P)

◆ HDgetuid

#define HDgetuid ( )    getuid()

◆ HDgmtime

#define HDgmtime (   T)    gmtime(T)

◆ HDisalnum

#define HDisalnum (   C)    isalnum((int)(C)) /*cast for solaris warning*/

◆ HDisalpha

#define HDisalpha (   C)    isalpha((int)(C)) /*cast for solaris warning*/

◆ HDisatty

#define HDisatty (   F)    isatty(F)

◆ HDiscntrl

#define HDiscntrl (   C)    iscntrl((int)(C)) /*cast for solaris warning*/

◆ HDisdigit

#define HDisdigit (   C)    isdigit((int)(C)) /*cast for solaris warning*/

◆ HDisgraph

#define HDisgraph (   C)    isgraph((int)(C)) /*cast for solaris warning*/

◆ HDislower

#define HDislower (   C)    islower((int)(C)) /*cast for solaris warning*/

◆ HDisnan

#define HDisnan (   X)    isnan(X)

◆ HDisprint

#define HDisprint (   C)    isprint((int)(C)) /*cast for solaris warning*/

◆ HDispunct

#define HDispunct (   C)    ispunct((int)(C)) /*cast for solaris warning*/

◆ HDisspace

#define HDisspace (   C)    isspace((int)(C)) /*cast for solaris warning*/

◆ HDisupper

#define HDisupper (   C)    isupper((int)(C)) /*cast for solaris warning*/

◆ HDisxdigit

#define HDisxdigit (   C)    isxdigit((int)(C)) /*cast for solaris warning*/

◆ HDkill

#define HDkill (   P,
  S 
)    kill(P,S)

◆ HDlabs

#define HDlabs (   X)    labs(X)

◆ HDldexp

#define HDldexp (   X,
  N 
)    ldexp(X,N)

◆ HDldiv

#define HDldiv (   X,
  Y 
)    ldiv(X,Y)

◆ HDlink

#define HDlink (   OLD,
  NEW 
)    link(OLD,NEW)

◆ HDllround

#define HDllround (   V)    llround(V)

◆ HDllroundf

#define HDllroundf (   V)    llroundf(V)

◆ HDllroundl

#define HDllroundl (   V)    llroundl(V)

◆ HDlocaleconv

#define HDlocaleconv ( )    localeconv()

◆ HDlocaltime

#define HDlocaltime (   T)    localtime(T)

◆ HDlog

#define HDlog (   X)    log(X)

◆ HDlog10

#define HDlog10 (   X)    log10(X)

◆ HDlongjmp

#define HDlongjmp (   J,
  N 
)    longjmp(J,N)

◆ HDlround

#define HDlround (   V)    lround(V)

◆ HDlroundf

#define HDlroundf (   V)    lroundf(V)

◆ HDlroundl

#define HDlroundl (   V)    lroundl(V)

◆ HDlseek

#define HDlseek (   F,
  O,
  W 
)    lseek(F,O,W)

◆ HDlstat

#define HDlstat (   S,
  B 
)    lstat(S,B)

◆ HDmalloc

#define HDmalloc (   Z)    malloc(Z)

◆ HDmblen

#define HDmblen (   S,
  N 
)    mblen(S,N)

◆ HDmbstowcs

#define HDmbstowcs (   P,
  S,
  Z 
)    mbstowcs(P,S,Z)

◆ HDmbtowc

#define HDmbtowc (   P,
  S,
  Z 
)    mbtowc(P,S,Z)

◆ HDmemchr

#define HDmemchr (   S,
  C,
  Z 
)    memchr(S,C,Z)

◆ HDmemcmp

#define HDmemcmp (   X,
  Y,
  Z 
)    memcmp(X,Y,Z)

◆ HDmemcpy

#define HDmemcpy (   X,
  Y,
  Z 
)    memcpy(X,Y,Z)

◆ HDmemmove

#define HDmemmove (   X,
  Y,
  Z 
)    memmove((char*)(X),(const char*)(Y),Z)

◆ HDmemset

#define HDmemset (   X,
  C,
  Z 
)    memset(X,C,Z)

◆ HDmkdir

#define HDmkdir (   S,
  M 
)    mkdir(S,M)

◆ HDmkfifo

#define HDmkfifo (   S,
  M 
)    mkfifo(S,M)

◆ HDmktime

#define HDmktime (   T)    mktime(T)

◆ HDmodf

#define HDmodf (   X,
  Y 
)    modf(X,Y)

◆ HDnanosleep

#define HDnanosleep (   N,
  O 
)    nanosleep(N, O)

◆ HDoff_t

#define HDoff_t   off_t

◆ HDopen

#define HDopen (   F,
  ... 
)    open(F,__VA_ARGS__)

◆ HDopendir

#define HDopendir (   S)    opendir(S)

◆ HDpathconf

#define HDpathconf (   S,
  N 
)    pathconf(S,N)

◆ HDpause

#define HDpause ( )    pause()

◆ HDperror

#define HDperror (   S)    perror(S)

◆ HDpipe

#define HDpipe (   F)    pipe(F)

◆ HDposix_memalign

#define HDposix_memalign (   P,
  A,
  Z 
)    posix_memalign(P,A,Z)

◆ HDpow

#define HDpow (   X,
  Y 
)    pow(X,Y)

◆ HDpowf

#define HDpowf (   X,
  Y 
)    powf(X,Y)

◆ HDpread

#define HDpread (   F,
  B,
  C,
  O 
)    pread(F,B,C,O)

◆ HDprintf

#define HDprintf (   ...)    HDfprintf(stdout, __VA_ARGS__)

◆ HDpthread_self

#define HDpthread_self ( )    pthread_self()

◆ HDpthread_self_ulong

#define HDpthread_self_ulong ( )    ((unsigned long)pthread_self())

◆ HDputc

#define HDputc (   C,
  F 
)    putc(C,F)

◆ HDputchar

#define HDputchar (   C)    putchar(C)

◆ HDputs

#define HDputs (   S)    puts(S)

◆ HDpwrite

#define HDpwrite (   F,
  B,
  C,
  O 
)    pwrite(F,B,C,O)

◆ HDqsort

#define HDqsort (   M,
  N,
  Z,
  F 
)    qsort(M,N,Z,F)

◆ HDraise

#define HDraise (   N)    raise(N)

◆ HDrand

#define HDrand ( )    rand()

◆ HDrandom

#define HDrandom ( )    rand()

◆ HDread

#define HDread (   F,
  M,
  Z 
)    read(F,M,Z)

◆ HDreaddir

#define HDreaddir (   D)    readdir(D)

◆ HDrealloc

#define HDrealloc (   M,
  Z 
)    realloc(M,Z)

◆ HDrealpath

#define HDrealpath (   F1,
  F2 
)    realpath(F1,F2)

◆ HDremove

#define HDremove (   S)    remove(S)

◆ HDrename

#define HDrename (   OLD,
  NEW 
)    rename(OLD,NEW)

◆ HDrewind

#define HDrewind (   F)    rewind(F)

◆ HDrewinddir

#define HDrewinddir (   D)    rewinddir(D)

◆ HDrmdir

#define HDrmdir (   S)    rmdir(S)

◆ HDround

#define HDround (   V)    round(V)

◆ HDroundf

#define HDroundf (   V)    roundf(V)

◆ HDroundl

#define HDroundl (   V)    roundl(V)

◆ HDselect

#define HDselect (   N,
  RD,
  WR,
  ER,
  T 
)    select(N,RD,WR,ER,T)

◆ HDsetbuf

#define HDsetbuf (   F,
  S 
)    setbuf(F,S)

◆ HDsetenv

#define HDsetenv (   N,
  V,
  O 
)    setenv(N,V,O)

◆ HDsetgid

#define HDsetgid (   G)    setgid(G)

◆ HDsetjmp

#define HDsetjmp (   J)    setjmp(J)

◆ HDsetlocale

#define HDsetlocale (   N,
  S 
)    setlocale(N,S)

◆ HDsetpgid

#define HDsetpgid (   P,
  PG 
)    setpgid(P,PG)

◆ HDsetsid

#define HDsetsid ( )    setsid()

◆ HDsetuid

#define HDsetuid (   U)    setuid(U)

◆ HDsetvbuf

#define HDsetvbuf (   F,
  S,
  M,
  Z 
)    setvbuf(F,S,M,Z)

◆ HDsigaddset

#define HDsigaddset (   S,
  N 
)    sigaddset(S,N)

◆ HDsigdelset

#define HDsigdelset (   S,
  N 
)    sigdelset(S,N)

◆ HDsigemptyset

#define HDsigemptyset (   S)    sigemptyset(S)

◆ HDsigfillset

#define HDsigfillset (   S)    sigfillset(S)

◆ HDsigismember

#define HDsigismember (   S,
  N 
)    sigismember(S,N)

◆ HDsiglongjmp

#define HDsiglongjmp (   J,
  N 
)    siglongjmp(J,N)

◆ HDsignal

#define HDsignal (   N,
  F 
)    signal(N,F)

◆ HDsigpending

#define HDsigpending (   S)    sigpending(S)

◆ HDsigprocmask

#define HDsigprocmask (   H,
  S,
  O 
)    sigprocmask(H,S,O)

◆ HDsigsetjmp

#define HDsigsetjmp (   J,
  N 
)    sigsetjmp(J,N)

◆ HDsigsuspend

#define HDsigsuspend (   S)    sigsuspend(S)

◆ HDsin

#define HDsin (   X)    sin(X)

◆ HDsinh

#define HDsinh (   X)    sinh(X)

◆ HDsleep

#define HDsleep (   N)    sleep(N)

◆ HDsnprintf

#define HDsnprintf   snprintf /*varargs*/

◆ HDsprintf

#define HDsprintf   sprintf /*varargs*/

◆ HDsqrt

#define HDsqrt (   X)    sqrt(X)

◆ HDsrand

#define HDsrand (   S)    srand(S)

◆ HDsrandom

#define HDsrandom (   S)    srand(S)

◆ HDsscanf

#define HDsscanf (   S,
  FMT,
  ... 
)    sscanf(S,FMT,__VA_ARGS__)

◆ HDstat

#define HDstat (   S,
  B 
)    stat(S,B)

◆ HDstrcasecmp

#define HDstrcasecmp (   X,
  Y 
)    strcasecmp(X,Y)

◆ HDstrcat

#define HDstrcat (   X,
  Y 
)    strcat(X,Y)

◆ HDstrchr

#define HDstrchr (   S,
  C 
)    strchr(S,C)

◆ HDstrcmp

#define HDstrcmp (   X,
  Y 
)    strcmp(X,Y)

◆ HDstrcoll

#define HDstrcoll (   X,
  Y 
)    strcoll(X,Y)

◆ HDstrcpy

#define HDstrcpy (   X,
  Y 
)    strcpy(X,Y)

◆ HDstrcspn

#define HDstrcspn (   X,
  Y 
)    strcspn(X,Y)

◆ HDstrdup

#define HDstrdup (   S)    strdup(S)

◆ HDstrerror

#define HDstrerror (   N)    strerror(N)

◆ HDstrftime

#define HDstrftime (   S,
  Z,
  F,
  T 
)    strftime(S,Z,F,T)

◆ HDstrlen

#define HDstrlen (   S)    strlen(S)

◆ HDstrncat

#define HDstrncat (   X,
  Y,
  Z 
)    strncat(X,Y,Z)

◆ HDstrncmp

#define HDstrncmp (   X,
  Y,
  Z 
)    strncmp(X,Y,Z)

◆ HDstrncpy

#define HDstrncpy (   X,
  Y,
  Z 
)    strncpy(X,Y,Z)

◆ HDstrpbrk

#define HDstrpbrk (   X,
  Y 
)    strpbrk(X,Y)

◆ HDstrrchr

#define HDstrrchr (   S,
  C 
)    strrchr(S,C)

◆ HDstrspn

#define HDstrspn (   X,
  Y 
)    strspn(X,Y)

◆ HDstrstr

#define HDstrstr (   X,
  Y 
)    strstr(X,Y)

◆ HDstrtod

#define HDstrtod (   S,
  R 
)    strtod(S,R)

◆ HDstrtok

#define HDstrtok (   X,
  Y 
)    strtok(X,Y)

◆ HDstrtok_r

#define HDstrtok_r (   X,
  Y,
  Z 
)    strtok_r(X,Y,Z)

◆ HDstrtol

#define HDstrtol (   S,
  R,
  N 
)    strtol(S,R,N)

◆ HDstrtoul

#define HDstrtoul (   S,
  R,
  N 
)    strtoul(S,R,N)

◆ HDstrtoull

#define HDstrtoull (   S,
  R,
  N 
)    strtoull(S,R,N)

◆ HDstrxfrm

#define HDstrxfrm (   X,
  Y,
  Z 
)    strxfrm(X,Y,Z)

◆ HDsysconf

#define HDsysconf (   N)    sysconf(N)

◆ HDsystem

#define HDsystem (   S)    system(S)

◆ HDtan

#define HDtan (   X)    tan(X)

◆ HDtanh

#define HDtanh (   X)    tanh(X)

◆ HDtcdrain

#define HDtcdrain (   F)    tcdrain(F)

◆ HDtcflow

#define HDtcflow (   F,
  A 
)    tcflow(F,A)

◆ HDtcflush

#define HDtcflush (   F,
  N 
)    tcflush(F,N)

◆ HDtcgetattr

#define HDtcgetattr (   F,
  T 
)    tcgetattr(F,T)

◆ HDtcgetpgrp

#define HDtcgetpgrp (   F)    tcgetpgrp(F)

◆ HDtcsendbreak

#define HDtcsendbreak (   F,
  N 
)    tcsendbreak(F,N)

◆ HDtcsetattr

#define HDtcsetattr (   F,
  O,
  T 
)    tcsetattr(F,O,T)

◆ HDtcsetpgrp

#define HDtcsetpgrp (   F,
  N 
)    tcsetpgrp(F,N)

◆ HDtime

#define HDtime (   T)    time(T)

◆ HDtimes

#define HDtimes (   T)    times(T)

◆ HDtmpfile

#define HDtmpfile ( )    tmpfile()

◆ HDtmpnam

#define HDtmpnam (   S)    tmpnam(S)

◆ HDtolower

#define HDtolower (   C)    tolower(C)

◆ HDtoupper

#define HDtoupper (   C)    toupper(C)

◆ HDttyname

#define HDttyname (   F)    ttyname(F)

◆ HDtzset

#define HDtzset ( )    tzset()

◆ HDumask

#define HDumask (   N)    umask(N)

◆ HDuname

#define HDuname (   S)    uname(S)

◆ HDungetc

#define HDungetc (   C,
  F 
)    ungetc(C,F)

◆ HDunlink

#define HDunlink (   S)    unlink(S)

◆ HDutime

#define HDutime (   S,
  T 
)    utime(S,T)

◆ HDva_arg

#define HDva_arg (   A,
  T 
)    va_arg(A,T)

◆ HDva_copy

#define HDva_copy (   D,
  S 
)    va_copy(D,S)

◆ HDva_end

#define HDva_end (   A)    va_end(A)

◆ HDva_start

#define HDva_start (   A,
  P 
)    va_start(A,P)

◆ HDvasprintf

#define HDvasprintf (   RET,
  FMT,
  A 
)    vasprintf(RET,FMT,A)

◆ HDvfprintf

#define HDvfprintf (   F,
  FMT,
  A 
)    vfprintf(F,FMT,A)

◆ HDvprintf

#define HDvprintf (   FMT,
  A 
)    vprintf(FMT,A)

◆ HDvsnprintf

#define HDvsnprintf (   S,
  N,
  FMT,
  A 
)    vsnprintf(S,N,FMT,A)

◆ HDvsprintf

#define HDvsprintf (   S,
  FMT,
  A 
)    vsprintf(S,FMT,A)

◆ HDwait

#define HDwait (   W)    wait(W)

◆ HDwaitpid

#define HDwaitpid (   P,
  W,
  O 
)    waitpid(P,W,O)

◆ HDwcstombs

#define HDwcstombs (   S,
  P,
  Z 
)    wcstombs(S,P,Z)

◆ HDwctomb

#define HDwctomb (   S,
  C 
)    wctomb(S,C)

◆ HDwrite

#define HDwrite (   F,
  M,
  Z 
)    write(F,M,Z)

◆ HSIZET_MAX

#define HSIZET_MAX   ((hsize_t)ULLONG_MAX)

◆ HSSIZET_MAX

#define HSSIZET_MAX   ((hssize_t)LLONG_MAX)

◆ HSSIZET_MIN

#define HSSIZET_MIN   (~(HSSIZET_MAX))

◆ LLONG_MAX

#define LLONG_MAX
Value:
((long long)(((unsigned long long)1 \
<<(8*sizeof(long long)-1))-1))

◆ LLONG_MIN

#define LLONG_MIN   ((long long)(-LLONG_MAX)-1)

◆ LOCK_EX

#define LOCK_EX   0x02

◆ LOCK_NB

#define LOCK_NB   0x04

◆ LOCK_SH

#define LOCK_SH   0x01

◆ LOCK_UN

#define LOCK_UN   0x08

◆ MAX

#define MAX (   a,
  b 
)    (((a)>(b)) ? (a) : (b))

◆ MAX2

#define MAX2 (   a,
  b 
)    MAX(a,b)

◆ MAX3

#define MAX3 (   a,
  b,
  c 
)    MAX(a,MAX(b,c))

◆ MAX4

#define MAX4 (   a,
  b,
  c,
  d 
)    MAX(MAX(a,b),MAX(c,d))

◆ MIN

#define MIN (   a,
  b 
)    (((a)<(b)) ? (a) : (b))

◆ MIN2

#define MIN2 (   a,
  b 
)    MIN(a,b)

◆ MIN3

#define MIN3 (   a,
  b,
  c 
)    MIN(a,MIN(b,c))

◆ MIN4

#define MIN4 (   a,
  b,
  c,
  d 
)    MIN(MIN(a,b),MIN(c,d))

◆ MPE_LOG_VARS

#define MPE_LOG_VARS   /* void */

◆ NELMTS

#define NELMTS (   X)    (sizeof(X)/sizeof(X[0]))

◆ POWER_OF_TWO

#define POWER_OF_TWO (   n)    (!(n & (n - 1)) && n)

◆ R_OK

#define R_OK   04

◆ RANGE

#define RANGE (   LO,
  X,
  HI 
)    MAX(LO,MIN(X,HI))

◆ SIGBUS

#define SIGBUS   SIGILL

◆ SIGN

#define SIGN (   a)    ((a)>0 ? 1 : (a)<0 ? -1 : 0)

◆ SIZET_MAX

#define SIZET_MAX   ((size_t)(ssize_t)(-1))

◆ SSIZET_MAX

#define SSIZET_MAX   ((ssize_t)(((size_t)1<<(8*sizeof(ssize_t)-1))-1))

◆ SUCCEED

CATCH SUCCEED   0

◆ TRUE

#define TRUE   true

◆ UFAIL

#define UFAIL   (unsigned)(-1)

◆ ULLONG_MAX

#define ULLONG_MAX   ((unsigned long long)((long long)(-1)))

◆ W_OK

#define W_OK   02

Typedef Documentation

◆ H5_debug_open_stream_t

typedef struct H5_debug_open_stream_t H5_debug_open_stream_t

◆ H5_debug_t

typedef struct H5_debug_t H5_debug_t

◆ h5_stat_size_t

typedef off_t h5_stat_size_t

◆ h5_stat_t

typedef struct stat h5_stat_t

◆ H5O_copy_file_ud_common_t

typedef struct H5O_copy_file_ud_common_t H5O_copy_file_ud_common_t

◆ int8_t

typedef signed char int8_t

◆ uint8_t

typedef unsigned char uint8_t

Enumeration Type Documentation

◆ H5_copy_depth_t

enum H5_copy_depth_t
Enumerator
H5_COPY_SHALLOW 
H5_COPY_DEEP 

◆ H5_pkg_t

enum H5_pkg_t
Enumerator
H5_PKG_A 
H5_PKG_AC 
H5_PKG_B 
H5_PKG_D 
H5_PKG_E 
H5_PKG_F 
H5_PKG_G 
H5_PKG_HG 
H5_PKG_HL 
H5_PKG_I 
H5_PKG_M 
H5_PKG_MF 
H5_PKG_MM 
H5_PKG_O 
H5_PKG_P 
H5_PKG_S 
H5_PKG_T 
H5_PKG_V 
H5_PKG_VL 
H5_PKG_Z 
H5_NPKGS 

Function Documentation

◆ H5_bandwidth()

H5_DLL void H5_bandwidth ( char *  buf,
double  nbytes,
double  nseconds 
)

◆ H5_buffer_dump()

H5_DLL herr_t H5_buffer_dump ( FILE *  stream,
int  indent,
const uint8_t *  buf,
const uint8_t *  marker,
size_t  buf_offset,
size_t  buf_size 
)

◆ H5_build_extpath()

H5_DLL herr_t H5_build_extpath ( const char *  name,
char **  extpath 
)

◆ H5_checksum_crc()

H5_DLL uint32_t H5_checksum_crc ( const void *  data,
size_t  len 
)

◆ H5_checksum_fletcher32()

H5_DLL uint32_t H5_checksum_fletcher32 ( const void *  data,
size_t  len 
)

◆ H5_checksum_lookup3()

H5_DLL uint32_t H5_checksum_lookup3 ( const void *  data,
size_t  len,
uint32_t  initval 
)

◆ H5_checksum_metadata()

H5_DLL uint32_t H5_checksum_metadata ( const void *  data,
size_t  len,
uint32_t  initval 
)

◆ H5_combine_path()

H5_DLL herr_t H5_combine_path ( const char *  path1,
const char *  path2,
char **  full_name 
)

◆ H5_get_time()

H5_DLL double H5_get_time ( void  )

◆ H5_hash_string()

H5_DLL uint32_t H5_hash_string ( const char *  str)

◆ H5_init_library()

H5_DLL herr_t H5_init_library ( void  )

◆ H5_make_time()

H5_DLL time_t H5_make_time ( struct tm *  tm)

◆ H5_nanosleep()

H5_DLL void H5_nanosleep ( uint64_t  nanosec)

◆ H5_now()

H5_DLL time_t H5_now ( void  )

◆ H5_term_library()

H5_DLL void H5_term_library ( void  )

◆ H5_timer_begin()

H5_DLL void H5_timer_begin ( H5_timer_t *  timer)

◆ H5_timer_end()

H5_DLL void H5_timer_end ( H5_timer_t *  sum,
H5_timer_t *  timer 
)

◆ H5_timer_reset()

H5_DLL void H5_timer_reset ( H5_timer_t *  timer)

◆ H5_trace()

H5_DLL double H5_trace ( const double *  calltime,
const char *  func,
const char *  type,
  ... 
)

◆ H5A_term_package()

H5_DLL int H5A_term_package ( void  )

◆ H5A_top_term_package()

H5_DLL int H5A_top_term_package ( void  )

◆ H5AC_term_package()

H5_DLL int H5AC_term_package ( void  )

◆ H5CX_pop()

H5_DLL herr_t H5CX_pop ( void  )

◆ H5CX_push()

H5_DLL herr_t H5CX_push ( void  )

◆ H5CX_term_package()

H5_DLL int H5CX_term_package ( void  )

◆ H5D_term_package()

H5_DLL int H5D_term_package ( void  )

◆ H5D_top_term_package()

H5_DLL int H5D_top_term_package ( void  )

◆ H5E_term_package()

H5_DLL int H5E_term_package ( void  )

◆ H5F_term_package()

H5_DLL int H5F_term_package ( void  )

◆ H5FD_term_package()

H5_DLL int H5FD_term_package ( void  )

◆ H5FL_term_package()

H5_DLL int H5FL_term_package ( void  )

◆ H5FS_term_package()

H5_DLL int H5FS_term_package ( void  )

◆ H5G_term_package()

H5_DLL int H5G_term_package ( void  )

◆ H5G_top_term_package()

H5_DLL int H5G_top_term_package ( void  )

◆ H5I_term_package()

H5_DLL int H5I_term_package ( void  )

◆ H5L_term_package()

H5_DLL int H5L_term_package ( void  )

◆ H5M_term_package()

H5_DLL int H5M_term_package ( void  )

◆ H5M_top_term_package()

H5_DLL int H5M_top_term_package ( void  )

◆ H5P_term_package()

H5_DLL int H5P_term_package ( void  )

◆ H5PL_term_package()

H5_DLL int H5PL_term_package ( void  )

◆ H5R_term_package()

H5_DLL int H5R_term_package ( void  )

◆ H5R_top_term_package()

H5_DLL int H5R_top_term_package ( void  )

◆ H5S_term_package()

H5_DLL int H5S_term_package ( void  )

◆ H5S_top_term_package()

H5_DLL int H5S_top_term_package ( void  )

◆ H5SL_term_package()

H5_DLL int H5SL_term_package ( void  )

◆ H5T_term_package()

H5_DLL int H5T_term_package ( void  )

◆ H5T_top_term_package()

H5_DLL int H5T_top_term_package ( void  )

◆ H5VL_term_package()

H5_DLL int H5VL_term_package ( void  )

◆ H5Z_term_package()

H5_DLL int H5Z_term_package ( void  )

◆ HDfprintf()

H5_DLL int HDfprintf ( FILE *  stream,
const char *  fmt,
  ... 
)

◆ HDstrtoll()

H5_DLL int64_t HDstrtoll ( const char *  s,
const char **  rest,
int  base 
)

◆ Nflock()

H5_DLL H5_ATTR_CONST int Nflock ( int  fd,
int  operation 
)

◆ strdup()

char* strdup ( const char *  s)

Variable Documentation

◆ H5_api_entered_g

hbool_t H5_api_entered_g

◆ H5_debug_g

H5_debug_t H5_debug_g

◆ H5_lib_vers_info_g

char H5_lib_vers_info_g[]

◆ H5_libinit_g

hbool_t H5_libinit_g

◆ H5_libterm_g

hbool_t H5_libterm_g

◆ H5libhdf5_settings

char H5libhdf5_settings[]
FALSE
#define FALSE
Definition: H5private.h:406
HDislower
#define HDislower(C)
Definition: H5private.h:1033
TRUE
#define TRUE
Definition: H5private.h:409
H5_TERM_GLOBAL
#define H5_TERM_GLOBAL
Definition: H5private.h:1985
H5_IS_PKG
#define H5_IS_PKG(S)
Definition: H5private.h:1920
H5_MY_PKG
#define H5_MY_PKG
Definition: H5ACmodule.h:28
H5E_CANTSET
Invalid arguments to routine Resource unavailable Internal File accessibility Low level I O Function entry exit Object atom Object cache Links B Tree node Symbol table Heap Object header Datatype Dataspace Dataset Data storage Property lists Attribute Data filters External file list References Virtual File Layer Virtual Object Layer Ternary Search Trees Reference Counted Strings Error API Skip Lists Free Space Manager Shared Object Header Messages Extensible Array Fixed Array Plugin for dynamically loaded library Page Buffering API Context Map No error Argument errors Resource errors File accessibility errors Generic low level file I O errors Function entry exit interface errors Object atom related errors Cache related errors Link related errors B tree related errors Object header related errors Group related errors Datatype conversion errors Dataspace errors Property list errors Parallel MPI errors Heap errors Free space errors I O pipeline errors System level errors Plugin errors No error Information is uinitialized Feature is unsupported Inappropriate type Out of range Bad value No space available for allocation Can t allocate space Unable to copy object Unable to free object Object already exists Unable to lock object Unable to unlock object Unable to garbage collect Unable to compute size Object is already open File already exists File already open Unable to create file Unable to open file Unable to close file Not an HDF5 file Bad file ID accessed File has been truncated File mount error Unable to delete file Seek failed Read failed Write failed Close failed Address overflowed File Unable to initialize object Object already initialized Unable to release object Unable to find atom Unable to find ID group information Unable to register new atom Unable to increment reference count Unable to decrement reference count Out of IDs for group Unable to flush data from cache Unable to mark metadata as unserialized Unable to serialize data from cache Unable to tag metadata in the cache Unable to load metadata into cache Protected metadata error Metadata not currently cached Internal error detected Unable to insert metadata into cache Unable to protect metadata Unable to unprotect metadata Unable to pin cache entry Unable to un pin cache entry Unable to mark a pinned entry as dirty Unable to mark a pinned entry as clean Unable to mark an entry as unserialized Unable to mark an entry as serialized Unable to mark metadata as dirty Unable to mark metadata as clean Unable to expunge a metadata cache entry Unable to resize a metadata cache entry Unable to create a flush dependency Unable to destroy a flush dependency Unable to notify object about action Failure in the cache logging framework Unable to cork an object Unable to uncork an object Object not found Object already exists Unable to encode value Unable to decode value Unable to split node Unable to redistribute records Unable to swap records Unable to insert object Unable to list node Unable to modify record Unable to remove object Bad object header link count Wrong version number Alignment error Unrecognized message Can t delete message Iteration failed Can t pack messages Can t reset object Unable to rename object Can t open object Can t close object Name component is too long Problem with path to object Can t convert datatypes Bad size for object Can t clip hyperslab region Can t count elements Can t select hyperslab Can t move to next iterator location Invalid selection Can t compare objects Internal states are inconsistent Can t append object Can t get value H5E_CANTSET
Definition: H5err.txt:236
H5E_CANTINIT
Invalid arguments to routine Resource unavailable Internal File accessibility Low level I O Function entry exit Object atom Object cache Links B Tree node Symbol table Heap Object header Datatype Dataspace Dataset Data storage Property lists Attribute Data filters External file list References Virtual File Layer Virtual Object Layer Ternary Search Trees Reference Counted Strings Error API Skip Lists Free Space Manager Shared Object Header Messages Extensible Array Fixed Array Plugin for dynamically loaded library Page Buffering API Context Map No error Argument errors Resource errors File accessibility errors Generic low level file I O errors Function entry exit interface errors Object atom related errors Cache related errors Link related errors B tree related errors Object header related errors Group related errors Datatype conversion errors Dataspace errors Property list errors Parallel MPI errors Heap errors Free space errors I O pipeline errors System level errors Plugin errors No error Information is uinitialized Feature is unsupported Inappropriate type Out of range Bad value No space available for allocation Can t allocate space Unable to copy object Unable to free object Object already exists Unable to lock object Unable to unlock object Unable to garbage collect Unable to compute size Object is already open File already exists File already open Unable to create file Unable to open file Unable to close file Not an HDF5 file Bad file ID accessed File has been truncated File mount error Unable to delete file Seek failed Read failed Write failed Close failed Address overflowed File H5E_CANTINIT
Definition: H5err.txt:149
FUNC
Invalid arguments to routine Resource unavailable Internal File accessibility Low level I O Function entry exit Object atom Object cache Links B Tree node Symbol table Heap Object header Datatype Dataspace Dataset Data storage Property lists Attribute Data filters External file list References Virtual File Layer Virtual Object Layer Ternary Search Trees Reference Counted Strings Error API Skip Lists Free Space Manager Shared Object Header Messages Extensible Array Fixed Array Plugin for dynamically loaded library Page Buffering API Context Map No error Argument errors Resource errors File accessibility errors Generic low level file I O errors FUNC
Definition: H5err.txt:89
HADDR_UNDEF
CATCH HADDR_UNDEF
Definition: H5EAdblock.c:162
FUNC_ENTER_COMMON_NOERR
#define FUNC_ENTER_COMMON_NOERR(asrt)
Definition: H5private.h:2060
FUNC_ENTER_CHECK_NAME
#define FUNC_ENTER_CHECK_NAME(asrt)
Definition: H5private.h:2038
ret_value
ret_value
Definition: H5EAcache.c:412
FUNC_ENTER_COMMON
#define FUNC_ENTER_COMMON(asrt)
Definition: H5private.h:2055
H5_GLUE
#define H5_GLUE(x, y)
Definition: H5private.h:1585
H5_IS_API
#define H5_IS_API(S)
Definition: H5private.h:1896
long
long
Definition: H5overflow.txt:34
HDisupper
#define HDisupper(C)
Definition: H5private.h:1048
H5_api_entered_g
hbool_t H5_api_entered_g
Definition: H5.c:69
H5E_FUNC
Invalid arguments to routine Resource unavailable Internal File accessibility Low level I O H5E_FUNC
Definition: H5err.txt:51
H5_PACKAGE_INIT_VAR
#define H5_PACKAGE_INIT_VAR(x)
Definition: H5private.h:2006
H5_PACKAGE_INIT_FUNC
#define H5_PACKAGE_INIT_FUNC(x)
Definition: H5private.h:2007
H5CX_pop
H5_DLL herr_t H5CX_pop(void)
Definition: H5CX.c:3578
H5AC_tag
void H5AC_tag(haddr_t metadata_tag, haddr_t *prev_tag)
Definition: H5AC.c:2181
H5_init_library
H5_DLL herr_t H5_init_library(void)
Definition: H5.c:109
H5CX_push
H5_DLL herr_t H5CX_push(void)
Definition: H5CX.c:787
HDisdigit
#define HDisdigit(C)
Definition: H5private.h:1027
H5E_dump_api_stack
herr_t H5E_dump_api_stack(hbool_t is_api)
Definition: H5Eint.c:985
H5_PKG_INIT_VAR
#define H5_PKG_INIT_VAR
Definition: H5private.h:2028
H5TRACE_RETURN
#define H5TRACE_RETURN(V)
Definition: H5private.h:1861
H5_INIT_GLOBAL
#define H5_INIT_GLOBAL
Definition: H5private.h:1984
hbool_t
bool hbool_t
Definition: H5public.h:159
FUNC_LEAVE_API_COMMON
#define FUNC_LEAVE_API_COMMON(ret_value)
Definition: H5private.h:2302
FUNC_ENTER_API_INIT
#define FUNC_ENTER_API_INIT(err)
Definition: H5private.h:2082
if
if(NULL==(iblock=H5EA__iblock_protect(hdr, thing_acc)))
Definition: H5EA.c:408
H5_MY_PKG_INIT
#define H5_MY_PKG_INIT
Definition: H5ACmodule.h:30
H5_IS_PRIV
#define H5_IS_PRIV(S)
Definition: H5private.h:1914
Generated by   doxygen 1.8.18