From e0c6872cf40896c7be36b11dcc744620f10adf1d Mon Sep 17 00:00:00 2001 From: Norbert Preining Date: Mon, 2 Sep 2019 13:46:59 +0900 Subject: Initial commit --- support/dktools/dk4conf.cross | 3410 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3410 insertions(+) create mode 100644 support/dktools/dk4conf.cross (limited to 'support/dktools/dk4conf.cross') diff --git a/support/dktools/dk4conf.cross b/support/dktools/dk4conf.cross new file mode 100644 index 0000000000..019f4d96c8 --- /dev/null +++ b/support/dktools/dk4conf.cross @@ -0,0 +1,3410 @@ +#ifndef DK4CONF_H_INCLUDED + +/** Protection against multiple inclusions. */ +#define DK4CONF_H_INCLUDED 1 + +#include "config.h" + +#ifndef DK4_ON_WINDOWS +#ifdef _WIN32 +#define DK4_ON_WINDOWS 1 +#ifndef HAVE_BACKSLASH_AS_SEP +#define HAVE_BACKSLASH_AS_SEPŧ1 +#endif +#else +#define DK4_ON_WINDOWS 0 +#endif +#endif + +#ifndef DK4_HAVE_ALLOC_H +#if HAVE_ALLOC_H +/** DK4 version of HAVE_ALLOC_H, available. +*/ +#define DK4_HAVE_ALLOC_H 1 +#else +/** DK4 version of HAVE_ALLOC_H, not available. +*/ +#define DK4_HAVE_ALLOC_H 0 +#endif +#endif + +#ifndef DK4_HAVE_ARPA_INET_H +#if HAVE_ARPA_INET_H +/** DK4 version of HAVE_ARPA_INET_H, available. +*/ +#define DK4_HAVE_ARPA_INET_H 1 +#else +/** DK4 version of HAVE_ARPA_INET_H, not available. +*/ +#define DK4_HAVE_ARPA_INET_H 0 +#endif +#endif + +#ifndef DK4_HAVE_ASSERT_H +#if HAVE_ASSERT_H +/** DK4 version of HAVE_ASSERT_H, available. +*/ +#define DK4_HAVE_ASSERT_H 1 +#else +/** DK4 version of HAVE_ASSERT_H, not available. +*/ +#define DK4_HAVE_ASSERT_H 0 +#endif +#endif + +#ifndef DK4_HAVE_BACKSLASH_AS_SEP +#if HAVE_BACKSLASH_AS_SEP +/** DK4 version of HAVE_BACKSLASH_AS_SEP, available. +*/ +#define DK4_HAVE_BACKSLASH_AS_SEP 1 +#else +/** DK4 version of HAVE_BACKSLASH_AS_SEP, not available. +*/ +#define DK4_HAVE_BACKSLASH_AS_SEP 0 +#endif +#endif + +#ifndef DK4_HAVE_BCMP +#if HAVE_BCMP +/** DK4 version of HAVE_BCMP, available. +*/ +#define DK4_HAVE_BCMP 1 +#else +/** DK4 version of HAVE_BCMP, not available. +*/ +#define DK4_HAVE_BCMP 0 +#endif +#endif + +#ifndef DK4_HAVE_BCOPY +#if HAVE_BCOPY +/** DK4 version of HAVE_BCOPY, available. +*/ +#define DK4_HAVE_BCOPY 1 +#else +/** DK4 version of HAVE_BCOPY, not available. +*/ +#define DK4_HAVE_BCOPY 0 +#endif +#endif + +#ifndef DK4_HAVE_BIOS_H +#if HAVE_BIOS_H +/** DK4 version of HAVE_BIOS_H, available. +*/ +#define DK4_HAVE_BIOS_H 1 +#else +/** DK4 version of HAVE_BIOS_H, not available. +*/ +#define DK4_HAVE_BIOS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_BLKCNT_T +#if HAVE_BLKCNT_T +/** DK4 version of HAVE_BLKCNT_T, available. +*/ +#define DK4_HAVE_BLKCNT_T 1 +#else +/** DK4 version of HAVE_BLKCNT_T, not available. +*/ +#define DK4_HAVE_BLKCNT_T 0 +#endif +#endif + +#ifndef DK4_HAVE_BLKSIZE_T +#if HAVE_BLKSIZE_T +/** DK4 version of HAVE_BLKSIZE_T, available. +*/ +#define DK4_HAVE_BLKSIZE_T 1 +#else +/** DK4 version of HAVE_BLKSIZE_T, not available. +*/ +#define DK4_HAVE_BLKSIZE_T 0 +#endif +#endif + +#ifndef DK4_HAVE_BZERO +#if HAVE_BZERO +/** DK4 version of HAVE_BZERO, available. +*/ +#define DK4_HAVE_BZERO 1 +#else +/** DK4 version of HAVE_BZERO, not available. +*/ +#define DK4_HAVE_BZERO 0 +#endif +#endif + +#ifndef DK4_HAVE_BZLIB_H +#if HAVE_BZLIB_H +/** DK4 version of HAVE_BZLIB_H, available. +*/ +#define DK4_HAVE_BZLIB_H 1 +#else +/** DK4 version of HAVE_BZLIB_H, not available. +*/ +#define DK4_HAVE_BZLIB_H 0 +#endif +#endif + +#ifndef DK4_HAVE_CALLOC +#if HAVE_CALLOC +/** DK4 version of HAVE_CALLOC, available. +*/ +#define DK4_HAVE_CALLOC 1 +#else +/** DK4 version of HAVE_CALLOC, not available. +*/ +#define DK4_HAVE_CALLOC 0 +#endif +#endif + +#ifndef DK4_HAVE_CASE_INSENSITIVE_PATHNAMES +#if HAVE_CASE_INSENSITIVE_PATHNAMES +/** DK4 version of HAVE_CASE_INSENSITIVE_PATHNAMES, available. +*/ +#define DK4_HAVE_CASE_INSENSITIVE_PATHNAMES 1 +#else +/** DK4 version of HAVE_CASE_INSENSITIVE_PATHNAMES, not available. +*/ +#define DK4_HAVE_CASE_INSENSITIVE_PATHNAMES 0 +#endif +#endif + +#ifndef DK4_HAVE_CASE_INSENSITIVE_USERNAMES +#if HAVE_CASE_INSENSITIVE_USERNAMES +/** DK4 version of HAVE_CASE_INSENSITIVE_USERNAMES, available. +*/ +#define DK4_HAVE_CASE_INSENSITIVE_USERNAMES 1 +#else +/** DK4 version of HAVE_CASE_INSENSITIVE_USERNAMES, not available. +*/ +#define DK4_HAVE_CASE_INSENSITIVE_USERNAMES 0 +#endif +#endif + +#ifndef DK4_HAVE_CHMOD +#if HAVE_CHMOD +/** DK4 version of HAVE_CHMOD, available. +*/ +#define DK4_HAVE_CHMOD 1 +#else +/** DK4 version of HAVE_CHMOD, not available. +*/ +#define DK4_HAVE_CHMOD 0 +#endif +#endif + +#ifndef DK4_HAVE_CHOWN +#if HAVE_CHOWN +/** DK4 version of HAVE_CHOWN, available. +*/ +#define DK4_HAVE_CHOWN 1 +#else +/** DK4 version of HAVE_CHOWN, not available. +*/ +#define DK4_HAVE_CHOWN 0 +#endif +#endif + +#ifndef DK4_HAVE_COMPATDKTOOLS3 +#if HAVE_COMPATDKTOOLS3 +/** DK4 version of HAVE_COMPATDKTOOLS3, available. +*/ +#define DK4_HAVE_COMPATDKTOOLS3 1 +#else +/** DK4 version of HAVE_COMPATDKTOOLS3, not available. +*/ +#define DK4_HAVE_COMPATDKTOOLS3 0 +#endif +#endif + +#ifndef DK4_HAVE_COMPLEX_H +#if HAVE_COMPLEX_H +/** DK4 version of HAVE_COMPLEX_H, available. +*/ +#define DK4_HAVE_COMPLEX_H 1 +#else +/** DK4 version of HAVE_COMPLEX_H, not available. +*/ +#define DK4_HAVE_COMPLEX_H 0 +#endif +#endif + +#ifndef DK4_HAVE_CTYPE_H +#if HAVE_CTYPE_H +/** DK4 version of HAVE_CTYPE_H, available. +*/ +#define DK4_HAVE_CTYPE_H 1 +#else +/** DK4 version of HAVE_CTYPE_H, not available. +*/ +#define DK4_HAVE_CTYPE_H 0 +#endif +#endif + +#ifndef DK4_HAVE_DB_CURSOR_C_GET +#if HAVE_DB_CURSOR_C_GET +/** DK4 version of HAVE_DB_CURSOR_C_GET, available. +*/ +#define DK4_HAVE_DB_CURSOR_C_GET 1 +#else +/** DK4 version of HAVE_DB_CURSOR_C_GET, not available. +*/ +#define DK4_HAVE_DB_CURSOR_C_GET 0 +#endif +#endif + +#ifndef DK4_HAVE_DB_H +#if HAVE_DB_H +/** DK4 version of HAVE_DB_H, available. +*/ +#define DK4_HAVE_DB_H 1 +#else +/** DK4 version of HAVE_DB_H, not available. +*/ +#define DK4_HAVE_DB_H 0 +#endif +#endif + +#ifndef DK4_HAVE_DEV_T +#if HAVE_DEV_T +/** DK4 version of HAVE_DEV_T, available. +*/ +#define DK4_HAVE_DEV_T 1 +#else +/** DK4 version of HAVE_DEV_T, not available. +*/ +#define DK4_HAVE_DEV_T 0 +#endif +#endif + +#ifndef DK4_HAVE_DIRECT_H +#if HAVE_DIRECT_H +/** DK4 version of HAVE_DIRECT_H, available. +*/ +#define DK4_HAVE_DIRECT_H 1 +#else +/** DK4 version of HAVE_DIRECT_H, not available. +*/ +#define DK4_HAVE_DIRECT_H 0 +#endif +#endif + +#ifndef DK4_HAVE_DIRENT_H +#if HAVE_DIRENT_H +/** DK4 version of HAVE_DIRENT_H, available. +*/ +#define DK4_HAVE_DIRENT_H 1 +#else +/** DK4 version of HAVE_DIRENT_H, not available. +*/ +#define DK4_HAVE_DIRENT_H 0 +#endif +#endif + +#ifndef DK4_HAVE_DOS_H +#if HAVE_DOS_H +/** DK4 version of HAVE_DOS_H, available. +*/ +#define DK4_HAVE_DOS_H 1 +#else +/** DK4 version of HAVE_DOS_H, not available. +*/ +#define DK4_HAVE_DOS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_ENDGRENT +#if HAVE_ENDGRENT +/** DK4 version of HAVE_ENDGRENT, available. +*/ +#define DK4_HAVE_ENDGRENT 1 +#else +/** DK4 version of HAVE_ENDGRENT, not available. +*/ +#define DK4_HAVE_ENDGRENT 0 +#endif +#endif + +#ifndef DK4_HAVE_ENDPWENT +#if HAVE_ENDPWENT +/** DK4 version of HAVE_ENDPWENT, available. +*/ +#define DK4_HAVE_ENDPWENT 1 +#else +/** DK4 version of HAVE_ENDPWENT, not available. +*/ +#define DK4_HAVE_ENDPWENT 0 +#endif +#endif + +#ifndef DK4_HAVE_ERRNO_H +#if HAVE_ERRNO_H +/** DK4 version of HAVE_ERRNO_H, available. +*/ +#define DK4_HAVE_ERRNO_H 1 +#else +/** DK4 version of HAVE_ERRNO_H, not available. +*/ +#define DK4_HAVE_ERRNO_H 0 +#endif +#endif + +#ifndef DK4_HAVE_FCNTL_H +#if HAVE_FCNTL_H +/** DK4 version of HAVE_FCNTL_H, available. +*/ +#define DK4_HAVE_FCNTL_H 1 +#else +/** DK4 version of HAVE_FCNTL_H, not available. +*/ +#define DK4_HAVE_FCNTL_H 0 +#endif +#endif + +#ifndef DK4_HAVE_FENV_H +#if HAVE_FENV_H +/** DK4 version of HAVE_FENV_H, available. +*/ +#define DK4_HAVE_FENV_H 1 +#else +/** DK4 version of HAVE_FENV_H, not available. +*/ +#define DK4_HAVE_FENV_H 0 +#endif +#endif + +#ifndef DK4_HAVE_FILEMODE_BINARY +#if HAVE_FILEMODE_BINARY +/** DK4 version of HAVE_FILEMODE_BINARY, available. +*/ +#define DK4_HAVE_FILEMODE_BINARY 1 +#else +/** DK4 version of HAVE_FILEMODE_BINARY, not available. +*/ +#define DK4_HAVE_FILEMODE_BINARY 0 +#endif +#endif + +#ifndef DK4_HAVE_FILENO +#if HAVE_FILENO +/** DK4 version of HAVE_FILENO, available. +*/ +#define DK4_HAVE_FILENO 1 +#else +/** DK4 version of HAVE_FILENO, not available. +*/ +#define DK4_HAVE_FILENO 0 +#endif +#endif + +#ifndef DK4_HAVE_FILE_ATIMECTIME +#if HAVE_FILE_ATIMECTIME +/** DK4 version of HAVE_FILE_ATIMECTIME, available. +*/ +#define DK4_HAVE_FILE_ATIMECTIME 1 +#else +/** DK4 version of HAVE_FILE_ATIMECTIME, not available. +*/ +#define DK4_HAVE_FILE_ATIMECTIME 0 +#endif +#endif + +#ifndef DK4_HAVE_FILE_BLKSIZECNT +#if HAVE_FILE_BLKSIZECNT +/** DK4 version of HAVE_FILE_BLKSIZECNT, available. +*/ +#define DK4_HAVE_FILE_BLKSIZECNT 1 +#else +/** DK4 version of HAVE_FILE_BLKSIZECNT, not available. +*/ +#define DK4_HAVE_FILE_BLKSIZECNT 0 +#endif +#endif + +#ifndef DK4_HAVE_FILE_DEVINO +#if HAVE_FILE_DEVINO +/** DK4 version of HAVE_FILE_DEVINO, available. +*/ +#define DK4_HAVE_FILE_DEVINO 1 +#else +/** DK4 version of HAVE_FILE_DEVINO, not available. +*/ +#define DK4_HAVE_FILE_DEVINO 0 +#endif +#endif + +#ifndef DK4_HAVE_FILE_UIDGID +#if HAVE_FILE_UIDGID +/** DK4 version of HAVE_FILE_UIDGID, available. +*/ +#define DK4_HAVE_FILE_UIDGID 1 +#else +/** DK4 version of HAVE_FILE_UIDGID, not available. +*/ +#define DK4_HAVE_FILE_UIDGID 0 +#endif +#endif + +#ifndef DK4_HAVE_FLOAT_H +#if HAVE_FLOAT_H +/** DK4 version of HAVE_FLOAT_H, available. +*/ +#define DK4_HAVE_FLOAT_H 1 +#else +/** DK4 version of HAVE_FLOAT_H, not available. +*/ +#define DK4_HAVE_FLOAT_H 0 +#endif +#endif + +#ifndef DK4_HAVE_FOPEN64 +#if HAVE_FOPEN64 +/** DK4 version of HAVE_FOPEN64, available. +*/ +#define DK4_HAVE_FOPEN64 1 +#else +/** DK4 version of HAVE_FOPEN64, not available. +*/ +#define DK4_HAVE_FOPEN64 0 +#endif +#endif + +#ifndef DK4_HAVE_FOPEN_S +#if HAVE_FOPEN_S +/** DK4 version of HAVE_FOPEN_S, available. +*/ +#define DK4_HAVE_FOPEN_S 1 +#else +/** DK4 version of HAVE_FOPEN_S, not available. +*/ +#define DK4_HAVE_FOPEN_S 0 +#endif +#endif + +#ifndef DK4_HAVE_FPOS_T +#if HAVE_FPOS_T +/** DK4 version of HAVE_FPOS_T, available. +*/ +#define DK4_HAVE_FPOS_T 1 +#else +/** DK4 version of HAVE_FPOS_T, not available. +*/ +#define DK4_HAVE_FPOS_T 0 +#endif +#endif + +#ifndef DK4_HAVE_FPUTWC +#if HAVE_FPUTWC +/** DK4 version of HAVE_FPUTWC, available. +*/ +#define DK4_HAVE_FPUTWC 1 +#else +/** DK4 version of HAVE_FPUTWC, not available. +*/ +#define DK4_HAVE_FPUTWC 0 +#endif +#endif + +#ifndef DK4_HAVE_FPUTWS +#if HAVE_FPUTWS +/** DK4 version of HAVE_FPUTWS, available. +*/ +#define DK4_HAVE_FPUTWS 1 +#else +/** DK4 version of HAVE_FPUTWS, not available. +*/ +#define DK4_HAVE_FPUTWS 0 +#endif +#endif + +#ifndef DK4_HAVE_FREE +#if HAVE_FREE +/** DK4 version of HAVE_FREE, available. +*/ +#define DK4_HAVE_FREE 1 +#else +/** DK4 version of HAVE_FREE, not available. +*/ +#define DK4_HAVE_FREE 0 +#endif +#endif + +#ifndef DK4_HAVE_GETADDRINFO +#if HAVE_GETADDRINFO +/** DK4 version of HAVE_GETADDRINFO, available. +*/ +#define DK4_HAVE_GETADDRINFO 1 +#else +/** DK4 version of HAVE_GETADDRINFO, not available. +*/ +#define DK4_HAVE_GETADDRINFO 0 +#endif +#endif + +#ifndef DK4_HAVE_GETCWD +#if HAVE_GETCWD +/** DK4 version of HAVE_GETCWD, available. +*/ +#define DK4_HAVE_GETCWD 1 +#else +/** DK4 version of HAVE_GETCWD, not available. +*/ +#define DK4_HAVE_GETCWD 0 +#endif +#endif + +#ifndef DK4_HAVE_GETENV +#if HAVE_GETENV +/** DK4 version of HAVE_GETENV, available. +*/ +#define DK4_HAVE_GETENV 1 +#else +/** DK4 version of HAVE_GETENV, not available. +*/ +#define DK4_HAVE_GETENV 0 +#endif +#endif + +#ifndef DK4_HAVE_GETENV_S +#if HAVE_GETENV_S +/** DK4 version of HAVE_GETENV_S, available. +*/ +#define DK4_HAVE_GETENV_S 1 +#else +/** DK4 version of HAVE_GETENV_S, not available. +*/ +#define DK4_HAVE_GETENV_S 0 +#endif +#endif + +#ifndef DK4_HAVE_GETEUID +#if HAVE_GETEUID +/** DK4 version of HAVE_GETEUID, available. +*/ +#define DK4_HAVE_GETEUID 1 +#else +/** DK4 version of HAVE_GETEUID, not available. +*/ +#define DK4_HAVE_GETEUID 0 +#endif +#endif + +#ifndef DK4_HAVE_GETEXECNAME +#if HAVE_GETEXECNAME +/** DK4 version of HAVE_GETEXECNAME, available. +*/ +#define DK4_HAVE_GETEXECNAME 1 +#else +/** DK4 version of HAVE_GETEXECNAME, not available. +*/ +#define DK4_HAVE_GETEXECNAME 0 +#endif +#endif + +#ifndef DK4_HAVE_GETFINALPATHNAMEBYHANDLE +#if HAVE_GETFINALPATHNAMEBYHANDLE +/** DK4 version of HAVE_GETFINALPATHNAMEBYHANDLE, available. +*/ +#define DK4_HAVE_GETFINALPATHNAMEBYHANDLE 1 +#else +/** DK4 version of HAVE_GETFINALPATHNAMEBYHANDLE, not available. +*/ +#define DK4_HAVE_GETFINALPATHNAMEBYHANDLE 0 +#endif +#endif + +#ifndef DK4_HAVE_GETGRENT +#if HAVE_GETGRENT +/** DK4 version of HAVE_GETGRENT, available. +*/ +#define DK4_HAVE_GETGRENT 1 +#else +/** DK4 version of HAVE_GETGRENT, not available. +*/ +#define DK4_HAVE_GETGRENT 0 +#endif +#endif + +#ifndef DK4_HAVE_GETGRGID +#if HAVE_GETGRGID +/** DK4 version of HAVE_GETGRGID, available. +*/ +#define DK4_HAVE_GETGRGID 1 +#else +/** DK4 version of HAVE_GETGRGID, not available. +*/ +#define DK4_HAVE_GETGRGID 0 +#endif +#endif + +#ifndef DK4_HAVE_GETGRNAM +#if HAVE_GETGRNAM +/** DK4 version of HAVE_GETGRNAM, available. +*/ +#define DK4_HAVE_GETGRNAM 1 +#else +/** DK4 version of HAVE_GETGRNAM, not available. +*/ +#define DK4_HAVE_GETGRNAM 0 +#endif +#endif + +#ifndef DK4_HAVE_GETHOSTBYNAME +#if HAVE_GETHOSTBYNAME +/** DK4 version of HAVE_GETHOSTBYNAME, available. +*/ +#define DK4_HAVE_GETHOSTBYNAME 1 +#else +/** DK4 version of HAVE_GETHOSTBYNAME, not available. +*/ +#define DK4_HAVE_GETHOSTBYNAME 0 +#endif +#endif + +#ifndef DK4_HAVE_GETNAMEINFO +#if HAVE_GETNAMEINFO +/** DK4 version of HAVE_GETNAMEINFO, available. +*/ +#define DK4_HAVE_GETNAMEINFO 1 +#else +/** DK4 version of HAVE_GETNAMEINFO, not available. +*/ +#define DK4_HAVE_GETNAMEINFO 0 +#endif +#endif + +#ifndef DK4_HAVE_GETPID +#if HAVE_GETPID +/** DK4 version of HAVE_GETPID, available. +*/ +#define DK4_HAVE_GETPID 1 +#else +/** DK4 version of HAVE_GETPID, not available. +*/ +#define DK4_HAVE_GETPID 0 +#endif +#endif + +#ifndef DK4_HAVE_GETPWENT +#if HAVE_GETPWENT +/** DK4 version of HAVE_GETPWENT, available. +*/ +#define DK4_HAVE_GETPWENT 1 +#else +/** DK4 version of HAVE_GETPWENT, not available. +*/ +#define DK4_HAVE_GETPWENT 0 +#endif +#endif + +#ifndef DK4_HAVE_GETPWNAM +#if HAVE_GETPWNAM +/** DK4 version of HAVE_GETPWNAM, available. +*/ +#define DK4_HAVE_GETPWNAM 1 +#else +/** DK4 version of HAVE_GETPWNAM, not available. +*/ +#define DK4_HAVE_GETPWNAM 0 +#endif +#endif + +#ifndef DK4_HAVE_GETPWUID +#if HAVE_GETPWUID +/** DK4 version of HAVE_GETPWUID, available. +*/ +#define DK4_HAVE_GETPWUID 1 +#else +/** DK4 version of HAVE_GETPWUID, not available. +*/ +#define DK4_HAVE_GETPWUID 0 +#endif +#endif + +#ifndef DK4_HAVE_GETRLIMIT +#if HAVE_GETRLIMIT +/** DK4 version of HAVE_GETRLIMIT, available. +*/ +#define DK4_HAVE_GETRLIMIT 1 +#else +/** DK4 version of HAVE_GETRLIMIT, not available. +*/ +#define DK4_HAVE_GETRLIMIT 0 +#endif +#endif + +#ifndef DK4_HAVE_GID_T +#if HAVE_GID_T +/** DK4 version of HAVE_GID_T, available. +*/ +#define DK4_HAVE_GID_T 1 +#else +/** DK4 version of HAVE_GID_T, not available. +*/ +#define DK4_HAVE_GID_T 0 +#endif +#endif + +#ifndef DK4_HAVE_GRP_H +#if HAVE_GRP_H +/** DK4 version of HAVE_GRP_H, available. +*/ +#define DK4_HAVE_GRP_H 1 +#else +/** DK4 version of HAVE_GRP_H, not available. +*/ +#define DK4_HAVE_GRP_H 0 +#endif +#endif + +#ifndef DK4_HAVE_HTONL +#if HAVE_HTONL +/** DK4 version of HAVE_HTONL, available. +*/ +#define DK4_HAVE_HTONL 1 +#else +/** DK4 version of HAVE_HTONL, not available. +*/ +#define DK4_HAVE_HTONL 0 +#endif +#endif + +#ifndef DK4_HAVE_HTONS +#if HAVE_HTONS +/** DK4 version of HAVE_HTONS, available. +*/ +#define DK4_HAVE_HTONS 1 +#else +/** DK4 version of HAVE_HTONS, not available. +*/ +#define DK4_HAVE_HTONS 0 +#endif +#endif + +#ifndef DK4_HAVE_IN6_ADDR +#if HAVE_IN6_ADDR +/** DK4 version of HAVE_IN6_ADDR, available. +*/ +#define DK4_HAVE_IN6_ADDR 1 +#else +/** DK4 version of HAVE_IN6_ADDR, not available. +*/ +#define DK4_HAVE_IN6_ADDR 0 +#endif +#endif + +#ifndef DK4_HAVE_INET_ADDR +#if HAVE_INET_ADDR +/** DK4 version of HAVE_INET_ADDR, available. +*/ +#define DK4_HAVE_INET_ADDR 1 +#else +/** DK4 version of HAVE_INET_ADDR, not available. +*/ +#define DK4_HAVE_INET_ADDR 0 +#endif +#endif + +#ifndef DK4_HAVE_INET_ATON +#if HAVE_INET_ATON +/** DK4 version of HAVE_INET_ATON, available. +*/ +#define DK4_HAVE_INET_ATON 1 +#else +/** DK4 version of HAVE_INET_ATON, not available. +*/ +#define DK4_HAVE_INET_ATON 0 +#endif +#endif + +#ifndef DK4_HAVE_INET_NTOP +#if HAVE_INET_NTOP +/** DK4 version of HAVE_INET_NTOP, available. +*/ +#define DK4_HAVE_INET_NTOP 1 +#else +/** DK4 version of HAVE_INET_NTOP, not available. +*/ +#define DK4_HAVE_INET_NTOP 0 +#endif +#endif + +#ifndef DK4_HAVE_INET_PTON +#if HAVE_INET_PTON +/** DK4 version of HAVE_INET_PTON, available. +*/ +#define DK4_HAVE_INET_PTON 1 +#else +/** DK4 version of HAVE_INET_PTON, not available. +*/ +#define DK4_HAVE_INET_PTON 0 +#endif +#endif + +#ifndef DK4_HAVE_INITSTATE +#if HAVE_INITSTATE +/** DK4 version of HAVE_INITSTATE, available. +*/ +#define DK4_HAVE_INITSTATE 1 +#else +/** DK4 version of HAVE_INITSTATE, not available. +*/ +#define DK4_HAVE_INITSTATE 0 +#endif +#endif + +#ifndef DK4_HAVE_INLINE +#if HAVE_INLINE +/** DK4 version of HAVE_INLINE, available. +*/ +#define DK4_HAVE_INLINE 1 +#else +/** DK4 version of HAVE_INLINE, not available. +*/ +#define DK4_HAVE_INLINE 0 +#endif +#endif + +#ifndef DK4_HAVE_INO64_T +#if HAVE_INO64_T +/** DK4 version of HAVE_INO64_T, available. +*/ +#define DK4_HAVE_INO64_T 1 +#else +/** DK4 version of HAVE_INO64_T, not available. +*/ +#define DK4_HAVE_INO64_T 0 +#endif +#endif + +#ifndef DK4_HAVE_INO_T +#if HAVE_INO_T +/** DK4 version of HAVE_INO_T, available. +*/ +#define DK4_HAVE_INO_T 1 +#else +/** DK4 version of HAVE_INO_T, not available. +*/ +#define DK4_HAVE_INO_T 0 +#endif +#endif + +#ifndef DK4_HAVE_INT16_T +#if HAVE_INT16_T +/** DK4 version of HAVE_INT16_T, available. +*/ +#define DK4_HAVE_INT16_T 1 +#else +/** DK4 version of HAVE_INT16_T, not available. +*/ +#define DK4_HAVE_INT16_T 0 +#endif +#endif + +#ifndef DK4_HAVE_INT32_T +#if HAVE_INT32_T +/** DK4 version of HAVE_INT32_T, available. +*/ +#define DK4_HAVE_INT32_T 1 +#else +/** DK4 version of HAVE_INT32_T, not available. +*/ +#define DK4_HAVE_INT32_T 0 +#endif +#endif + +#ifndef DK4_HAVE_INT8_T +#if HAVE_INT8_T +/** DK4 version of HAVE_INT8_T, available. +*/ +#define DK4_HAVE_INT8_T 1 +#else +/** DK4 version of HAVE_INT8_T, not available. +*/ +#define DK4_HAVE_INT8_T 0 +#endif +#endif + +#ifndef DK4_HAVE_INTMAX_T +#if HAVE_INTMAX_T +/** DK4 version of HAVE_INTMAX_T, available. +*/ +#define DK4_HAVE_INTMAX_T 1 +#else +/** DK4 version of HAVE_INTMAX_T, not available. +*/ +#define DK4_HAVE_INTMAX_T 0 +#endif +#endif + +#ifndef DK4_HAVE_INTTYPES_H +#if HAVE_INTTYPES_H +/** DK4 version of HAVE_INTTYPES_H, available. +*/ +#define DK4_HAVE_INTTYPES_H 1 +#else +/** DK4 version of HAVE_INTTYPES_H, not available. +*/ +#define DK4_HAVE_INTTYPES_H 0 +#endif +#endif + +#ifndef DK4_HAVE_IN_ADDR +#if HAVE_IN_ADDR +/** DK4 version of HAVE_IN_ADDR, available. +*/ +#define DK4_HAVE_IN_ADDR 1 +#else +/** DK4 version of HAVE_IN_ADDR, not available. +*/ +#define DK4_HAVE_IN_ADDR 0 +#endif +#endif + +#ifndef DK4_HAVE_IO_H +#if HAVE_IO_H +/** DK4 version of HAVE_IO_H, available. +*/ +#define DK4_HAVE_IO_H 1 +#else +/** DK4 version of HAVE_IO_H, not available. +*/ +#define DK4_HAVE_IO_H 0 +#endif +#endif + +#ifndef DK4_HAVE_ISATTY +#if HAVE_ISATTY +/** DK4 version of HAVE_ISATTY, available. +*/ +#define DK4_HAVE_ISATTY 1 +#else +/** DK4 version of HAVE_ISATTY, not available. +*/ +#define DK4_HAVE_ISATTY 0 +#endif +#endif + +#ifndef DK4_HAVE_ISFINITE +#if HAVE_ISFINITE +/** DK4 version of HAVE_ISFINITE, available. +*/ +#define DK4_HAVE_ISFINITE 1 +#else +/** DK4 version of HAVE_ISFINITE, not available. +*/ +#define DK4_HAVE_ISFINITE 0 +#endif +#endif + +#ifndef DK4_HAVE_ISNORMAL +#if HAVE_ISNORMAL +/** DK4 version of HAVE_ISNORMAL, available. +*/ +#define DK4_HAVE_ISNORMAL 1 +#else +/** DK4 version of HAVE_ISNORMAL, not available. +*/ +#define DK4_HAVE_ISNORMAL 0 +#endif +#endif + +#ifndef DK4_HAVE_ISO646_H +#if HAVE_ISO646_H +/** DK4 version of HAVE_ISO646_H, available. +*/ +#define DK4_HAVE_ISO646_H 1 +#else +/** DK4 version of HAVE_ISO646_H, not available. +*/ +#define DK4_HAVE_ISO646_H 0 +#endif +#endif + +#ifndef DK4_HAVE_JPEGLIB_H +#if HAVE_JPEGLIB_H +/** DK4 version of HAVE_JPEGLIB_H, available. +*/ +#define DK4_HAVE_JPEGLIB_H 1 +#else +/** DK4 version of HAVE_JPEGLIB_H, not available. +*/ +#define DK4_HAVE_JPEGLIB_H 0 +#endif +#endif + +#ifndef DK4_HAVE_LARGEFILE64_SOURCE +#if HAVE_LARGEFILE64_SOURCE +/** DK4 version of HAVE_LARGEFILE64_SOURCE, available. +*/ +#define DK4_HAVE_LARGEFILE64_SOURCE 1 +#else +/** DK4 version of HAVE_LARGEFILE64_SOURCE, not available. +*/ +#define DK4_HAVE_LARGEFILE64_SOURCE 0 +#endif +#endif + +#ifndef DK4_HAVE_LIBNETSNMP +#if HAVE_LIBNETSNMP +/** DK4 version of HAVE_LIBNETSNMP, available. +*/ +#define DK4_HAVE_LIBNETSNMP 1 +#else +/** DK4 version of HAVE_LIBNETSNMP, not available. +*/ +#define DK4_HAVE_LIBNETSNMP 0 +#endif +#endif + +#ifndef DK4_HAVE_LIMITS_H +#if HAVE_LIMITS_H +/** DK4 version of HAVE_LIMITS_H, available. +*/ +#define DK4_HAVE_LIMITS_H 1 +#else +/** DK4 version of HAVE_LIMITS_H, not available. +*/ +#define DK4_HAVE_LIMITS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_LINE_END_CR_NL +#if HAVE_LINE_END_CR_NL +/** DK4 version of HAVE_LINE_END_CR_NL, available. +*/ +#define DK4_HAVE_LINE_END_CR_NL 1 +#else +/** DK4 version of HAVE_LINE_END_CR_NL, not available. +*/ +#define DK4_HAVE_LINE_END_CR_NL 0 +#endif +#endif + +#ifndef DK4_HAVE_LOCALE_H +#if HAVE_LOCALE_H +/** DK4 version of HAVE_LOCALE_H, available. +*/ +#define DK4_HAVE_LOCALE_H 1 +#else +/** DK4 version of HAVE_LOCALE_H, not available. +*/ +#define DK4_HAVE_LOCALE_H 0 +#endif +#endif + +#ifndef DK4_HAVE_LOCALTIME_R +#if HAVE_LOCALTIME_R +/** DK4 version of HAVE_LOCALTIME_R, available. +*/ +#define DK4_HAVE_LOCALTIME_R 1 +#else +/** DK4 version of HAVE_LOCALTIME_R, not available. +*/ +#define DK4_HAVE_LOCALTIME_R 0 +#endif +#endif + +#ifndef DK4_HAVE_LONG_DOUBLE +#if HAVE_LONG_DOUBLE +/** DK4 version of HAVE_LONG_DOUBLE, available. +*/ +#define DK4_HAVE_LONG_DOUBLE 1 +#else +/** DK4 version of HAVE_LONG_DOUBLE, not available. +*/ +#define DK4_HAVE_LONG_DOUBLE 0 +#endif +#endif + +#ifndef DK4_HAVE_LONG_LONG +#if HAVE_LONG_LONG +/** DK4 version of HAVE_LONG_LONG, available. +*/ +#define DK4_HAVE_LONG_LONG 1 +#else +/** DK4 version of HAVE_LONG_LONG, not available. +*/ +#define DK4_HAVE_LONG_LONG 0 +#endif +#endif + +#ifndef DK4_HAVE_LRAND48 +#if HAVE_LRAND48 +/** DK4 version of HAVE_LRAND48, available. +*/ +#define DK4_HAVE_LRAND48 1 +#else +/** DK4 version of HAVE_LRAND48, not available. +*/ +#define DK4_HAVE_LRAND48 0 +#endif +#endif + +#ifndef DK4_HAVE_LSTAT +#if HAVE_LSTAT +/** DK4 version of HAVE_LSTAT, available. +*/ +#define DK4_HAVE_LSTAT 1 +#else +/** DK4 version of HAVE_LSTAT, not available. +*/ +#define DK4_HAVE_LSTAT 0 +#endif +#endif + +#ifndef DK4_HAVE_LSTAT64 +#if HAVE_LSTAT64 +/** DK4 version of HAVE_LSTAT64, available. +*/ +#define DK4_HAVE_LSTAT64 1 +#else +/** DK4 version of HAVE_LSTAT64, not available. +*/ +#define DK4_HAVE_LSTAT64 0 +#endif +#endif + +#ifndef DK4_HAVE_MALLOC +#if HAVE_MALLOC +/** DK4 version of HAVE_MALLOC, available. +*/ +#define DK4_HAVE_MALLOC 1 +#else +/** DK4 version of HAVE_MALLOC, not available. +*/ +#define DK4_HAVE_MALLOC 0 +#endif +#endif + +#ifndef DK4_HAVE_MALLOC_H +#if HAVE_MALLOC_H +/** DK4 version of HAVE_MALLOC_H, available. +*/ +#define DK4_HAVE_MALLOC_H 1 +#else +/** DK4 version of HAVE_MALLOC_H, not available. +*/ +#define DK4_HAVE_MALLOC_H 0 +#endif +#endif + +#ifndef DK4_HAVE_MATH_H +#if HAVE_MATH_H +/** DK4 version of HAVE_MATH_H, available. +*/ +#define DK4_HAVE_MATH_H 1 +#else +/** DK4 version of HAVE_MATH_H, not available. +*/ +#define DK4_HAVE_MATH_H 0 +#endif +#endif + +#ifndef DK4_HAVE_MEMCMP +#if HAVE_MEMCMP +/** DK4 version of HAVE_MEMCMP, available. +*/ +#define DK4_HAVE_MEMCMP 1 +#else +/** DK4 version of HAVE_MEMCMP, not available. +*/ +#define DK4_HAVE_MEMCMP 0 +#endif +#endif + +#ifndef DK4_HAVE_MEMCPY +#if HAVE_MEMCPY +/** DK4 version of HAVE_MEMCPY, available. +*/ +#define DK4_HAVE_MEMCPY 1 +#else +/** DK4 version of HAVE_MEMCPY, not available. +*/ +#define DK4_HAVE_MEMCPY 0 +#endif +#endif + +#ifndef DK4_HAVE_MEMSET +#if HAVE_MEMSET +/** DK4 version of HAVE_MEMSET, available. +*/ +#define DK4_HAVE_MEMSET 1 +#else +/** DK4 version of HAVE_MEMSET, not available. +*/ +#define DK4_HAVE_MEMSET 0 +#endif +#endif + +#ifndef DK4_HAVE_MKDIR +#if HAVE_MKDIR +/** DK4 version of HAVE_MKDIR, available. +*/ +#define DK4_HAVE_MKDIR 1 +#else +/** DK4 version of HAVE_MKDIR, not available. +*/ +#define DK4_HAVE_MKDIR 0 +#endif +#endif + +#ifndef DK4_HAVE_MODE_T +#if HAVE_MODE_T +/** DK4 version of HAVE_MODE_T, available. +*/ +#define DK4_HAVE_MODE_T 1 +#else +/** DK4 version of HAVE_MODE_T, not available. +*/ +#define DK4_HAVE_MODE_T 0 +#endif +#endif + +#ifndef DK4_HAVE_NDBM_H +#if HAVE_NDBM_H +/** DK4 version of HAVE_NDBM_H, available. +*/ +#define DK4_HAVE_NDBM_H 1 +#else +/** DK4 version of HAVE_NDBM_H, not available. +*/ +#define DK4_HAVE_NDBM_H 0 +#endif +#endif + +#ifndef DK4_HAVE_NETDB_H +#if HAVE_NETDB_H +/** DK4 version of HAVE_NETDB_H, available. +*/ +#define DK4_HAVE_NETDB_H 1 +#else +/** DK4 version of HAVE_NETDB_H, not available. +*/ +#define DK4_HAVE_NETDB_H 0 +#endif +#endif + +#ifndef DK4_HAVE_NETINET_IN6_H +#if HAVE_NETINET_IN6_H +/** DK4 version of HAVE_NETINET_IN6_H, available. +*/ +#define DK4_HAVE_NETINET_IN6_H 1 +#else +/** DK4 version of HAVE_NETINET_IN6_H, not available. +*/ +#define DK4_HAVE_NETINET_IN6_H 0 +#endif +#endif + +#ifndef DK4_HAVE_NETINET_IN_H +#if HAVE_NETINET_IN_H +/** DK4 version of HAVE_NETINET_IN_H, available. +*/ +#define DK4_HAVE_NETINET_IN_H 1 +#else +/** DK4 version of HAVE_NETINET_IN_H, not available. +*/ +#define DK4_HAVE_NETINET_IN_H 0 +#endif +#endif + +#ifndef DK4_HAVE_NLINK_T +#if HAVE_NLINK_T +/** DK4 version of HAVE_NLINK_T, available. +*/ +#define DK4_HAVE_NLINK_T 1 +#else +/** DK4 version of HAVE_NLINK_T, not available. +*/ +#define DK4_HAVE_NLINK_T 0 +#endif +#endif + +#ifndef DK4_HAVE_NRAND48 +#if HAVE_NRAND48 +/** DK4 version of HAVE_NRAND48, available. +*/ +#define DK4_HAVE_NRAND48 1 +#else +/** DK4 version of HAVE_NRAND48, not available. +*/ +#define DK4_HAVE_NRAND48 0 +#endif +#endif + +#ifndef DK4_HAVE_NTIFS_H +#if HAVE_NTIFS_H +/** DK4 version of HAVE_NTIFS_H, available. +*/ +#define DK4_HAVE_NTIFS_H 1 +#else +/** DK4 version of HAVE_NTIFS_H, not available. +*/ +#define DK4_HAVE_NTIFS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_NTOHL +#if HAVE_NTOHL +/** DK4 version of HAVE_NTOHL, available. +*/ +#define DK4_HAVE_NTOHL 1 +#else +/** DK4 version of HAVE_NTOHL, not available. +*/ +#define DK4_HAVE_NTOHL 0 +#endif +#endif + +#ifndef DK4_HAVE_NTOHS +#if HAVE_NTOHS +/** DK4 version of HAVE_NTOHS, available. +*/ +#define DK4_HAVE_NTOHS 1 +#else +/** DK4 version of HAVE_NTOHS, not available. +*/ +#define DK4_HAVE_NTOHS 0 +#endif +#endif + +#ifndef DK4_HAVE_OFF64_T +#if HAVE_OFF64_T +/** DK4 version of HAVE_OFF64_T, available. +*/ +#define DK4_HAVE_OFF64_T 1 +#else +/** DK4 version of HAVE_OFF64_T, not available. +*/ +#define DK4_HAVE_OFF64_T 0 +#endif +#endif + +#ifndef DK4_HAVE_OFF_T +#if HAVE_OFF_T +/** DK4 version of HAVE_OFF_T, available. +*/ +#define DK4_HAVE_OFF_T 1 +#else +/** DK4 version of HAVE_OFF_T, not available. +*/ +#define DK4_HAVE_OFF_T 0 +#endif +#endif + +#ifndef DK4_HAVE_OPENSSL_MD5_H +#if HAVE_OPENSSL_MD5_H +/** DK4 version of HAVE_OPENSSL_MD5_H, available. +*/ +#define DK4_HAVE_OPENSSL_MD5_H 1 +#else +/** DK4 version of HAVE_OPENSSL_MD5_H, not available. +*/ +#define DK4_HAVE_OPENSSL_MD5_H 0 +#endif +#endif + +#ifndef DK4_HAVE_OPENSSL_RAND_H +#if HAVE_OPENSSL_RAND_H +/** DK4 version of HAVE_OPENSSL_RAND_H, available. +*/ +#define DK4_HAVE_OPENSSL_RAND_H 1 +#else +/** DK4 version of HAVE_OPENSSL_RAND_H, not available. +*/ +#define DK4_HAVE_OPENSSL_RAND_H 0 +#endif +#endif + +#ifndef DK4_HAVE_OPENSSL_RIPEMD_H +#if HAVE_OPENSSL_RIPEMD_H +/** DK4 version of HAVE_OPENSSL_RIPEMD_H, available. +*/ +#define DK4_HAVE_OPENSSL_RIPEMD_H 1 +#else +/** DK4 version of HAVE_OPENSSL_RIPEMD_H, not available. +*/ +#define DK4_HAVE_OPENSSL_RIPEMD_H 0 +#endif +#endif + +#ifndef DK4_HAVE_OPENSSL_SHA_H +#if HAVE_OPENSSL_SHA_H +/** DK4 version of HAVE_OPENSSL_SHA_H, available. +*/ +#define DK4_HAVE_OPENSSL_SHA_H 1 +#else +/** DK4 version of HAVE_OPENSSL_SHA_H, not available. +*/ +#define DK4_HAVE_OPENSSL_SHA_H 0 +#endif +#endif + +#ifndef DK4_HAVE_PNG_GET_PIXELS_PER_INCH +#if HAVE_PNG_GET_PIXELS_PER_INCH +/** DK4 version of HAVE_PNG_GET_PIXELS_PER_INCH, available. +*/ +#define DK4_HAVE_PNG_GET_PIXELS_PER_INCH 1 +#else +/** DK4 version of HAVE_PNG_GET_PIXELS_PER_INCH, not available. +*/ +#define DK4_HAVE_PNG_GET_PIXELS_PER_INCH 0 +#endif +#endif + +#ifndef DK4_HAVE_PNG_H +#if HAVE_PNG_H +/** DK4 version of HAVE_PNG_H, available. +*/ +#define DK4_HAVE_PNG_H 1 +#else +/** DK4 version of HAVE_PNG_H, not available. +*/ +#define DK4_HAVE_PNG_H 0 +#endif +#endif + +#ifndef DK4_HAVE_PROCESS_H +#if HAVE_PROCESS_H +/** DK4 version of HAVE_PROCESS_H, available. +*/ +#define DK4_HAVE_PROCESS_H 1 +#else +/** DK4 version of HAVE_PROCESS_H, not available. +*/ +#define DK4_HAVE_PROCESS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_PROC_PID_EXE +#if HAVE_PROC_PID_EXE +/** DK4 version of HAVE_PROC_PID_EXE, available. +*/ +#define DK4_HAVE_PROC_PID_EXE 1 +#else +/** DK4 version of HAVE_PROC_PID_EXE, not available. +*/ +#define DK4_HAVE_PROC_PID_EXE 0 +#endif +#endif + +#ifndef DK4_HAVE_PWD_H +#if HAVE_PWD_H +/** DK4 version of HAVE_PWD_H, available. +*/ +#define DK4_HAVE_PWD_H 1 +#else +/** DK4 version of HAVE_PWD_H, not available. +*/ +#define DK4_HAVE_PWD_H 0 +#endif +#endif + +#ifndef DK4_HAVE_RAND +#if HAVE_RAND +/** DK4 version of HAVE_RAND, available. +*/ +#define DK4_HAVE_RAND 1 +#else +/** DK4 version of HAVE_RAND, not available. +*/ +#define DK4_HAVE_RAND 0 +#endif +#endif + +#ifndef DK4_HAVE_RANDOM +#if HAVE_RANDOM +/** DK4 version of HAVE_RANDOM, available. +*/ +#define DK4_HAVE_RANDOM 1 +#else +/** DK4 version of HAVE_RANDOM, not available. +*/ +#define DK4_HAVE_RANDOM 0 +#endif +#endif + +#ifndef DK4_HAVE_RAND_EGD +#if HAVE_RAND_EGD +/** DK4 version of HAVE_RAND_EGD, available. +*/ +#define DK4_HAVE_RAND_EGD 1 +#else +/** DK4 version of HAVE_RAND_EGD, not available. +*/ +#define DK4_HAVE_RAND_EGD 0 +#endif +#endif + +#ifndef DK4_HAVE_READ +#if HAVE_READ +/** DK4 version of HAVE_READ, available. +*/ +#define DK4_HAVE_READ 1 +#else +/** DK4 version of HAVE_READ, not available. +*/ +#define DK4_HAVE_READ 0 +#endif +#endif + +#ifndef DK4_HAVE_READLINK +#if HAVE_READLINK +/** DK4 version of HAVE_READLINK, available. +*/ +#define DK4_HAVE_READLINK 1 +#else +/** DK4 version of HAVE_READLINK, not available. +*/ +#define DK4_HAVE_READLINK 0 +#endif +#endif + +#ifndef DK4_HAVE_RMDIR +#if HAVE_RMDIR +/** DK4 version of HAVE_RMDIR, available. +*/ +#define DK4_HAVE_RMDIR 1 +#else +/** DK4 version of HAVE_RMDIR, not available. +*/ +#define DK4_HAVE_RMDIR 0 +#endif +#endif + +#ifndef DK4_HAVE_SELECT +#if HAVE_SELECT +/** DK4 version of HAVE_SELECT, available. +*/ +#define DK4_HAVE_SELECT 1 +#else +/** DK4 version of HAVE_SELECT, not available. +*/ +#define DK4_HAVE_SELECT 0 +#endif +#endif + +#ifndef DK4_HAVE_SETBUF +#if HAVE_SETBUF +/** DK4 version of HAVE_SETBUF, available. +*/ +#define DK4_HAVE_SETBUF 1 +#else +/** DK4 version of HAVE_SETBUF, not available. +*/ +#define DK4_HAVE_SETBUF 0 +#endif +#endif + +#ifndef DK4_HAVE_SETBUFFER +#if HAVE_SETBUFFER +/** DK4 version of HAVE_SETBUFFER, available. +*/ +#define DK4_HAVE_SETBUFFER 1 +#else +/** DK4 version of HAVE_SETBUFFER, not available. +*/ +#define DK4_HAVE_SETBUFFER 0 +#endif +#endif + +#ifndef DK4_HAVE_SETGID +#if HAVE_SETGID +/** DK4 version of HAVE_SETGID, available. +*/ +#define DK4_HAVE_SETGID 1 +#else +/** DK4 version of HAVE_SETGID, not available. +*/ +#define DK4_HAVE_SETGID 0 +#endif +#endif + +#ifndef DK4_HAVE_SETGRENT +#if HAVE_SETGRENT +/** DK4 version of HAVE_SETGRENT, available. +*/ +#define DK4_HAVE_SETGRENT 1 +#else +/** DK4 version of HAVE_SETGRENT, not available. +*/ +#define DK4_HAVE_SETGRENT 0 +#endif +#endif + +#ifndef DK4_HAVE_SETJMP_H +#if HAVE_SETJMP_H +/** DK4 version of HAVE_SETJMP_H, available. +*/ +#define DK4_HAVE_SETJMP_H 1 +#else +/** DK4 version of HAVE_SETJMP_H, not available. +*/ +#define DK4_HAVE_SETJMP_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SETLOCALE +#if HAVE_SETLOCALE +/** DK4 version of HAVE_SETLOCALE, available. +*/ +#define DK4_HAVE_SETLOCALE 1 +#else +/** DK4 version of HAVE_SETLOCALE, not available. +*/ +#define DK4_HAVE_SETLOCALE 0 +#endif +#endif + +#ifndef DK4_HAVE_SETMODE +#if HAVE_SETMODE +/** DK4 version of HAVE_SETMODE, available. +*/ +#define DK4_HAVE_SETMODE 1 +#else +/** DK4 version of HAVE_SETMODE, not available. +*/ +#define DK4_HAVE_SETMODE 0 +#endif +#endif + +#ifndef DK4_HAVE_SETPGRP +#if HAVE_SETPGRP +/** DK4 version of HAVE_SETPGRP, available. +*/ +#define DK4_HAVE_SETPGRP 1 +#else +/** DK4 version of HAVE_SETPGRP, not available. +*/ +#define DK4_HAVE_SETPGRP 0 +#endif +#endif + +#ifndef DK4_HAVE_SETPWENT +#if HAVE_SETPWENT +/** DK4 version of HAVE_SETPWENT, available. +*/ +#define DK4_HAVE_SETPWENT 1 +#else +/** DK4 version of HAVE_SETPWENT, not available. +*/ +#define DK4_HAVE_SETPWENT 0 +#endif +#endif + +#ifndef DK4_HAVE_SETSID +#if HAVE_SETSID +/** DK4 version of HAVE_SETSID, available. +*/ +#define DK4_HAVE_SETSID 1 +#else +/** DK4 version of HAVE_SETSID, not available. +*/ +#define DK4_HAVE_SETSID 0 +#endif +#endif + +#ifndef DK4_HAVE_SETSOCKOPT +#if HAVE_SETSOCKOPT +/** DK4 version of HAVE_SETSOCKOPT, available. +*/ +#define DK4_HAVE_SETSOCKOPT 1 +#else +/** DK4 version of HAVE_SETSOCKOPT, not available. +*/ +#define DK4_HAVE_SETSOCKOPT 0 +#endif +#endif + +#ifndef DK4_HAVE_SETSTATE +#if HAVE_SETSTATE +/** DK4 version of HAVE_SETSTATE, available. +*/ +#define DK4_HAVE_SETSTATE 1 +#else +/** DK4 version of HAVE_SETSTATE, not available. +*/ +#define DK4_HAVE_SETSTATE 0 +#endif +#endif + +#ifndef DK4_HAVE_SETUID +#if HAVE_SETUID +/** DK4 version of HAVE_SETUID, available. +*/ +#define DK4_HAVE_SETUID 1 +#else +/** DK4 version of HAVE_SETUID, not available. +*/ +#define DK4_HAVE_SETUID 0 +#endif +#endif + +#ifndef DK4_HAVE_SETVBUF +#if HAVE_SETVBUF +/** DK4 version of HAVE_SETVBUF, available. +*/ +#define DK4_HAVE_SETVBUF 1 +#else +/** DK4 version of HAVE_SETVBUF, not available. +*/ +#define DK4_HAVE_SETVBUF 0 +#endif +#endif + +#ifndef DK4_HAVE_SHA224 +#if HAVE_SHA224 +/** DK4 version of HAVE_SHA224, available. +*/ +#define DK4_HAVE_SHA224 1 +#else +/** DK4 version of HAVE_SHA224, not available. +*/ +#define DK4_HAVE_SHA224 0 +#endif +#endif + +#ifndef DK4_HAVE_SHA256 +#if HAVE_SHA256 +/** DK4 version of HAVE_SHA256, available. +*/ +#define DK4_HAVE_SHA256 1 +#else +/** DK4 version of HAVE_SHA256, not available. +*/ +#define DK4_HAVE_SHA256 0 +#endif +#endif + +#ifndef DK4_HAVE_SHA384 +#if HAVE_SHA384 +/** DK4 version of HAVE_SHA384, available. +*/ +#define DK4_HAVE_SHA384 1 +#else +/** DK4 version of HAVE_SHA384, not available. +*/ +#define DK4_HAVE_SHA384 0 +#endif +#endif + +#ifndef DK4_HAVE_SHA512 +#if HAVE_SHA512 +/** DK4 version of HAVE_SHA512, available. +*/ +#define DK4_HAVE_SHA512 1 +#else +/** DK4 version of HAVE_SHA512, not available. +*/ +#define DK4_HAVE_SHA512 0 +#endif +#endif + +#ifndef DK4_HAVE_SHARE_H +#if HAVE_SHARE_H +/** DK4 version of HAVE_SHARE_H, available. +*/ +#define DK4_HAVE_SHARE_H 1 +#else +/** DK4 version of HAVE_SHARE_H, not available. +*/ +#define DK4_HAVE_SHARE_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SIGACTION +#if HAVE_SIGACTION +/** DK4 version of HAVE_SIGACTION, available. +*/ +#define DK4_HAVE_SIGACTION 1 +#else +/** DK4 version of HAVE_SIGACTION, not available. +*/ +#define DK4_HAVE_SIGACTION 0 +#endif +#endif + +#ifndef DK4_HAVE_SIGEMPTYSET +#if HAVE_SIGEMPTYSET +/** DK4 version of HAVE_SIGEMPTYSET, available. +*/ +#define DK4_HAVE_SIGEMPTYSET 1 +#else +/** DK4 version of HAVE_SIGEMPTYSET, not available. +*/ +#define DK4_HAVE_SIGEMPTYSET 0 +#endif +#endif + +#ifndef DK4_HAVE_SIGNAL +#if HAVE_SIGNAL +/** DK4 version of HAVE_SIGNAL, available. +*/ +#define DK4_HAVE_SIGNAL 1 +#else +/** DK4 version of HAVE_SIGNAL, not available. +*/ +#define DK4_HAVE_SIGNAL 0 +#endif +#endif + +#ifndef DK4_HAVE_SIGNAL_H +#if HAVE_SIGNAL_H +/** DK4 version of HAVE_SIGNAL_H, available. +*/ +#define DK4_HAVE_SIGNAL_H 1 +#else +/** DK4 version of HAVE_SIGNAL_H, not available. +*/ +#define DK4_HAVE_SIGNAL_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SIGPROCMASK +#if HAVE_SIGPROCMASK +/** DK4 version of HAVE_SIGPROCMASK, available. +*/ +#define DK4_HAVE_SIGPROCMASK 1 +#else +/** DK4 version of HAVE_SIGPROCMASK, not available. +*/ +#define DK4_HAVE_SIGPROCMASK 0 +#endif +#endif + +#ifndef DK4_HAVE_SIGSET +#if HAVE_SIGSET +/** DK4 version of HAVE_SIGSET, available. +*/ +#define DK4_HAVE_SIGSET 1 +#else +/** DK4 version of HAVE_SIGSET, not available. +*/ +#define DK4_HAVE_SIGSET 0 +#endif +#endif + +#ifndef DK4_HAVE_SIG_ATOMIC_T +#if HAVE_SIG_ATOMIC_T +/** DK4 version of HAVE_SIG_ATOMIC_T, available. +*/ +#define DK4_HAVE_SIG_ATOMIC_T 1 +#else +/** DK4 version of HAVE_SIG_ATOMIC_T, not available. +*/ +#define DK4_HAVE_SIG_ATOMIC_T 0 +#endif +#endif + +#ifndef DK4_HAVE_SNMP_DISABLE_FILELOG +#if HAVE_SNMP_DISABLE_FILELOG +/** DK4 version of HAVE_SNMP_DISABLE_FILELOG, available. +*/ +#define DK4_HAVE_SNMP_DISABLE_FILELOG 1 +#else +/** DK4 version of HAVE_SNMP_DISABLE_FILELOG, not available. +*/ +#define DK4_HAVE_SNMP_DISABLE_FILELOG 0 +#endif +#endif + +#ifndef DK4_HAVE_SNMP_DISABLE_STDERRLOG +#if HAVE_SNMP_DISABLE_STDERRLOG +/** DK4 version of HAVE_SNMP_DISABLE_STDERRLOG, available. +*/ +#define DK4_HAVE_SNMP_DISABLE_STDERRLOG 1 +#else +/** DK4 version of HAVE_SNMP_DISABLE_STDERRLOG, not available. +*/ +#define DK4_HAVE_SNMP_DISABLE_STDERRLOG 0 +#endif +#endif + +#ifndef DK4_HAVE_SNMP_DISABLE_SYSLOG +#if HAVE_SNMP_DISABLE_SYSLOG +/** DK4 version of HAVE_SNMP_DISABLE_SYSLOG, available. +*/ +#define DK4_HAVE_SNMP_DISABLE_SYSLOG 1 +#else +/** DK4 version of HAVE_SNMP_DISABLE_SYSLOG, not available. +*/ +#define DK4_HAVE_SNMP_DISABLE_SYSLOG 0 +#endif +#endif + +#ifndef DK4_HAVE_SNMP_ENABLE_FILELOG +#if HAVE_SNMP_ENABLE_FILELOG +/** DK4 version of HAVE_SNMP_ENABLE_FILELOG, available. +*/ +#define DK4_HAVE_SNMP_ENABLE_FILELOG 1 +#else +/** DK4 version of HAVE_SNMP_ENABLE_FILELOG, not available. +*/ +#define DK4_HAVE_SNMP_ENABLE_FILELOG 0 +#endif +#endif + +#ifndef DK4_HAVE_SNPRINTF +#if HAVE_SNPRINTF +/** DK4 version of HAVE_SNPRINTF, available. +*/ +#define DK4_HAVE_SNPRINTF 1 +#else +/** DK4 version of HAVE_SNPRINTF, not available. +*/ +#define DK4_HAVE_SNPRINTF 0 +#endif +#endif + +#ifndef DK4_HAVE_SNWPRINTF +#if HAVE_SNWPRINTF +/** DK4 version of HAVE_SNWPRINTF, available. +*/ +#define DK4_HAVE_SNWPRINTF 1 +#else +/** DK4 version of HAVE_SNWPRINTF, not available. +*/ +#define DK4_HAVE_SNWPRINTF 0 +#endif +#endif + +#ifndef DK4_HAVE_SOCKET +#if HAVE_SOCKET +/** DK4 version of HAVE_SOCKET, available. +*/ +#define DK4_HAVE_SOCKET 1 +#else +/** DK4 version of HAVE_SOCKET, not available. +*/ +#define DK4_HAVE_SOCKET 0 +#endif +#endif + +#ifndef DK4_HAVE_SOCKLEN_T +#if HAVE_SOCKLEN_T +/** DK4 version of HAVE_SOCKLEN_T, available. +*/ +#define DK4_HAVE_SOCKLEN_T 1 +#else +/** DK4 version of HAVE_SOCKLEN_T, not available. +*/ +#define DK4_HAVE_SOCKLEN_T 0 +#endif +#endif + +#ifndef DK4_HAVE_SRAND +#if HAVE_SRAND +/** DK4 version of HAVE_SRAND, available. +*/ +#define DK4_HAVE_SRAND 1 +#else +/** DK4 version of HAVE_SRAND, not available. +*/ +#define DK4_HAVE_SRAND 0 +#endif +#endif + +#ifndef DK4_HAVE_SSIZE_T +#if HAVE_SSIZE_T +/** DK4 version of HAVE_SSIZE_T, available. +*/ +#define DK4_HAVE_SSIZE_T 1 +#else +/** DK4 version of HAVE_SSIZE_T, not available. +*/ +#define DK4_HAVE_SSIZE_T 0 +#endif +#endif + +#ifndef DK4_HAVE_STAT64 +#if HAVE_STAT64 +/** DK4 version of HAVE_STAT64, available. +*/ +#define DK4_HAVE_STAT64 1 +#else +/** DK4 version of HAVE_STAT64, not available. +*/ +#define DK4_HAVE_STAT64 0 +#endif +#endif + +#ifndef DK4_HAVE_STDALIGN_H +#if HAVE_STDALIGN_H +/** DK4 version of HAVE_STDALIGN_H, available. +*/ +#define DK4_HAVE_STDALIGN_H 1 +#else +/** DK4 version of HAVE_STDALIGN_H, not available. +*/ +#define DK4_HAVE_STDALIGN_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STDARG_H +#if HAVE_STDARG_H +/** DK4 version of HAVE_STDARG_H, available. +*/ +#define DK4_HAVE_STDARG_H 1 +#else +/** DK4 version of HAVE_STDARG_H, not available. +*/ +#define DK4_HAVE_STDARG_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STDATOMIC_H +#if HAVE_STDATOMIC_H +/** DK4 version of HAVE_STDATOMIC_H, available. +*/ +#define DK4_HAVE_STDATOMIC_H 1 +#else +/** DK4 version of HAVE_STDATOMIC_H, not available. +*/ +#define DK4_HAVE_STDATOMIC_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STDBOOL_H +#if HAVE_STDBOOL_H +/** DK4 version of HAVE_STDBOOL_H, available. +*/ +#define DK4_HAVE_STDBOOL_H 1 +#else +/** DK4 version of HAVE_STDBOOL_H, not available. +*/ +#define DK4_HAVE_STDBOOL_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STDDEF_H +#if HAVE_STDDEF_H +/** DK4 version of HAVE_STDDEF_H, available. +*/ +#define DK4_HAVE_STDDEF_H 1 +#else +/** DK4 version of HAVE_STDDEF_H, not available. +*/ +#define DK4_HAVE_STDDEF_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STDINT_H +#if HAVE_STDINT_H +/** DK4 version of HAVE_STDINT_H, available. +*/ +#define DK4_HAVE_STDINT_H 1 +#else +/** DK4 version of HAVE_STDINT_H, not available. +*/ +#define DK4_HAVE_STDINT_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STDLIB_H +#if HAVE_STDLIB_H +/** DK4 version of HAVE_STDLIB_H, available. +*/ +#define DK4_HAVE_STDLIB_H 1 +#else +/** DK4 version of HAVE_STDLIB_H, not available. +*/ +#define DK4_HAVE_STDLIB_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STDNORETURN_H +#if HAVE_STDNORETURN_H +/** DK4 version of HAVE_STDNORETURN_H, available. +*/ +#define DK4_HAVE_STDNORETURN_H 1 +#else +/** DK4 version of HAVE_STDNORETURN_H, not available. +*/ +#define DK4_HAVE_STDNORETURN_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STRCASECMP +#if HAVE_STRCASECMP +/** DK4 version of HAVE_STRCASECMP, available. +*/ +#define DK4_HAVE_STRCASECMP 1 +#else +/** DK4 version of HAVE_STRCASECMP, not available. +*/ +#define DK4_HAVE_STRCASECMP 0 +#endif +#endif + +#ifndef DK4_HAVE_STRCAT_S +#if HAVE_STRCAT_S +/** DK4 version of HAVE_STRCAT_S, available. +*/ +#define DK4_HAVE_STRCAT_S 1 +#else +/** DK4 version of HAVE_STRCAT_S, not available. +*/ +#define DK4_HAVE_STRCAT_S 0 +#endif +#endif + +#ifndef DK4_HAVE_STRCPY_S +#if HAVE_STRCPY_S +/** DK4 version of HAVE_STRCPY_S, available. +*/ +#define DK4_HAVE_STRCPY_S 1 +#else +/** DK4 version of HAVE_STRCPY_S, not available. +*/ +#define DK4_HAVE_STRCPY_S 0 +#endif +#endif + +#ifndef DK4_HAVE_STRERROR +#if HAVE_STRERROR +/** DK4 version of HAVE_STRERROR, available. +*/ +#define DK4_HAVE_STRERROR 1 +#else +/** DK4 version of HAVE_STRERROR, not available. +*/ +#define DK4_HAVE_STRERROR 0 +#endif +#endif + +#ifndef DK4_HAVE_STRERROR_R +#if HAVE_STRERROR_R +/** DK4 version of HAVE_STRERROR_R, available. +*/ +#define DK4_HAVE_STRERROR_R 1 +#else +/** DK4 version of HAVE_STRERROR_R, not available. +*/ +#define DK4_HAVE_STRERROR_R 0 +#endif +#endif + +#ifndef DK4_HAVE_STRICMP +#if HAVE_STRICMP +/** DK4 version of HAVE_STRICMP, available. +*/ +#define DK4_HAVE_STRICMP 1 +#else +/** DK4 version of HAVE_STRICMP, not available. +*/ +#define DK4_HAVE_STRICMP 0 +#endif +#endif + +#ifndef DK4_HAVE_STRINGS_H +#if HAVE_STRINGS_H +/** DK4 version of HAVE_STRINGS_H, available. +*/ +#define DK4_HAVE_STRINGS_H 1 +#else +/** DK4 version of HAVE_STRINGS_H, not available. +*/ +#define DK4_HAVE_STRINGS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STRING_H +#if HAVE_STRING_H +/** DK4 version of HAVE_STRING_H, available. +*/ +#define DK4_HAVE_STRING_H 1 +#else +/** DK4 version of HAVE_STRING_H, not available. +*/ +#define DK4_HAVE_STRING_H 0 +#endif +#endif + +#ifndef DK4_HAVE_STRTOD +#if HAVE_STRTOD +/** DK4 version of HAVE_STRTOD, available. +*/ +#define DK4_HAVE_STRTOD 1 +#else +/** DK4 version of HAVE_STRTOD, not available. +*/ +#define DK4_HAVE_STRTOD 0 +#endif +#endif + +#ifndef DK4_HAVE_STRUCT_ADDRINFO +#if HAVE_STRUCT_ADDRINFO +/** DK4 version of HAVE_STRUCT_ADDRINFO, available. +*/ +#define DK4_HAVE_STRUCT_ADDRINFO 1 +#else +/** DK4 version of HAVE_STRUCT_ADDRINFO, not available. +*/ +#define DK4_HAVE_STRUCT_ADDRINFO 0 +#endif +#endif + +#ifndef DK4_HAVE_STRUCT_SOCKADDR_IN +#if HAVE_STRUCT_SOCKADDR_IN +/** DK4 version of HAVE_STRUCT_SOCKADDR_IN, available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_IN 1 +#else +/** DK4 version of HAVE_STRUCT_SOCKADDR_IN, not available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_IN 0 +#endif +#endif + +#ifndef DK4_HAVE_STRUCT_SOCKADDR_IN6 +#if HAVE_STRUCT_SOCKADDR_IN6 +/** DK4 version of HAVE_STRUCT_SOCKADDR_IN6, available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_IN6 1 +#else +/** DK4 version of HAVE_STRUCT_SOCKADDR_IN6, not available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_IN6 0 +#endif +#endif + +#ifndef DK4_HAVE_STRUCT_SOCKADDR_STORAGE +#if HAVE_STRUCT_SOCKADDR_STORAGE +/** DK4 version of HAVE_STRUCT_SOCKADDR_STORAGE, available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_STORAGE 1 +#else +/** DK4 version of HAVE_STRUCT_SOCKADDR_STORAGE, not available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_STORAGE 0 +#endif +#endif + +#ifndef DK4_HAVE_STRUCT_SOCKADDR_UN +#if HAVE_STRUCT_SOCKADDR_UN +/** DK4 version of HAVE_STRUCT_SOCKADDR_UN, available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_UN 1 +#else +/** DK4 version of HAVE_STRUCT_SOCKADDR_UN, not available. +*/ +#define DK4_HAVE_STRUCT_SOCKADDR_UN 0 +#endif +#endif + +#ifndef DK4_HAVE_SWPRINTF +#if HAVE_SWPRINTF +/** DK4 version of HAVE_SWPRINTF, available. +*/ +#define DK4_HAVE_SWPRINTF 1 +#else +/** DK4 version of HAVE_SWPRINTF, not available. +*/ +#define DK4_HAVE_SWPRINTF 0 +#endif +#endif + +#ifndef DK4_HAVE_SYSLOG +#if HAVE_SYSLOG +/** DK4 version of HAVE_SYSLOG, available. +*/ +#define DK4_HAVE_SYSLOG 1 +#else +/** DK4 version of HAVE_SYSLOG, not available. +*/ +#define DK4_HAVE_SYSLOG 0 +#endif +#endif + +#ifndef DK4_HAVE_SYSLOG_H +#if HAVE_SYSLOG_H +/** DK4 version of HAVE_SYSLOG_H, available. +*/ +#define DK4_HAVE_SYSLOG_H 1 +#else +/** DK4 version of HAVE_SYSLOG_H, not available. +*/ +#define DK4_HAVE_SYSLOG_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_PARAM_H +#if HAVE_SYS_PARAM_H +/** DK4 version of HAVE_SYS_PARAM_H, available. +*/ +#define DK4_HAVE_SYS_PARAM_H 1 +#else +/** DK4 version of HAVE_SYS_PARAM_H, not available. +*/ +#define DK4_HAVE_SYS_PARAM_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_RESOURCE_H +#if HAVE_SYS_RESOURCE_H +/** DK4 version of HAVE_SYS_RESOURCE_H, available. +*/ +#define DK4_HAVE_SYS_RESOURCE_H 1 +#else +/** DK4 version of HAVE_SYS_RESOURCE_H, not available. +*/ +#define DK4_HAVE_SYS_RESOURCE_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_SELECT_H +#if HAVE_SYS_SELECT_H +/** DK4 version of HAVE_SYS_SELECT_H, available. +*/ +#define DK4_HAVE_SYS_SELECT_H 1 +#else +/** DK4 version of HAVE_SYS_SELECT_H, not available. +*/ +#define DK4_HAVE_SYS_SELECT_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_SOCKET_H +#if HAVE_SYS_SOCKET_H +/** DK4 version of HAVE_SYS_SOCKET_H, available. +*/ +#define DK4_HAVE_SYS_SOCKET_H 1 +#else +/** DK4 version of HAVE_SYS_SOCKET_H, not available. +*/ +#define DK4_HAVE_SYS_SOCKET_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_STAT_H +#if HAVE_SYS_STAT_H +/** DK4 version of HAVE_SYS_STAT_H, available. +*/ +#define DK4_HAVE_SYS_STAT_H 1 +#else +/** DK4 version of HAVE_SYS_STAT_H, not available. +*/ +#define DK4_HAVE_SYS_STAT_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_TIME_H +#if HAVE_SYS_TIME_H +/** DK4 version of HAVE_SYS_TIME_H, available. +*/ +#define DK4_HAVE_SYS_TIME_H 1 +#else +/** DK4 version of HAVE_SYS_TIME_H, not available. +*/ +#define DK4_HAVE_SYS_TIME_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_TYPES_H +#if HAVE_SYS_TYPES_H +/** DK4 version of HAVE_SYS_TYPES_H, available. +*/ +#define DK4_HAVE_SYS_TYPES_H 1 +#else +/** DK4 version of HAVE_SYS_TYPES_H, not available. +*/ +#define DK4_HAVE_SYS_TYPES_H 0 +#endif +#endif + +#ifndef DK4_HAVE_SYS_UN_H +#if HAVE_SYS_UN_H +/** DK4 version of HAVE_SYS_UN_H, available. +*/ +#define DK4_HAVE_SYS_UN_H 1 +#else +/** DK4 version of HAVE_SYS_UN_H, not available. +*/ +#define DK4_HAVE_SYS_UN_H 0 +#endif +#endif + +#ifndef DK4_HAVE_TGMATH_H +#if HAVE_TGMATH_H +/** DK4 version of HAVE_TGMATH_H, available. +*/ +#define DK4_HAVE_TGMATH_H 1 +#else +/** DK4 version of HAVE_TGMATH_H, not available. +*/ +#define DK4_HAVE_TGMATH_H 0 +#endif +#endif + +#ifndef DK4_HAVE_THREADS_H +#if HAVE_THREADS_H +/** DK4 version of HAVE_THREADS_H, available. +*/ +#define DK4_HAVE_THREADS_H 1 +#else +/** DK4 version of HAVE_THREADS_H, not available. +*/ +#define DK4_HAVE_THREADS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_TIFF_H +#if HAVE_TIFF_H +/** DK4 version of HAVE_TIFF_H, available. +*/ +#define DK4_HAVE_TIFF_H 1 +#else +/** DK4 version of HAVE_TIFF_H, not available. +*/ +#define DK4_HAVE_TIFF_H 0 +#endif +#endif + +#ifndef DK4_HAVE_TIME_H +#if HAVE_TIME_H +/** DK4 version of HAVE_TIME_H, available. +*/ +#define DK4_HAVE_TIME_H 1 +#else +/** DK4 version of HAVE_TIME_H, not available. +*/ +#define DK4_HAVE_TIME_H 0 +#endif +#endif + +#ifndef DK4_HAVE_TYPE_STAT64 +#if HAVE_TYPE_STAT64 +/** DK4 version of HAVE_TYPE_STAT64, available. +*/ +#define DK4_HAVE_TYPE_STAT64 1 +#else +/** DK4 version of HAVE_TYPE_STAT64, not available. +*/ +#define DK4_HAVE_TYPE_STAT64 0 +#endif +#endif + +#ifndef DK4_HAVE_UCHAR_H +#if HAVE_UCHAR_H +/** DK4 version of HAVE_UCHAR_H, available. +*/ +#define DK4_HAVE_UCHAR_H 1 +#else +/** DK4 version of HAVE_UCHAR_H, not available. +*/ +#define DK4_HAVE_UCHAR_H 0 +#endif +#endif + +#ifndef DK4_HAVE_UID_T +#if HAVE_UID_T +/** DK4 version of HAVE_UID_T, available. +*/ +#define DK4_HAVE_UID_T 1 +#else +/** DK4 version of HAVE_UID_T, not available. +*/ +#define DK4_HAVE_UID_T 0 +#endif +#endif + +#ifndef DK4_HAVE_UINT16_T +#if HAVE_UINT16_T +/** DK4 version of HAVE_UINT16_T, available. +*/ +#define DK4_HAVE_UINT16_T 1 +#else +/** DK4 version of HAVE_UINT16_T, not available. +*/ +#define DK4_HAVE_UINT16_T 0 +#endif +#endif + +#ifndef DK4_HAVE_UINT32_T +#if HAVE_UINT32_T +/** DK4 version of HAVE_UINT32_T, available. +*/ +#define DK4_HAVE_UINT32_T 1 +#else +/** DK4 version of HAVE_UINT32_T, not available. +*/ +#define DK4_HAVE_UINT32_T 0 +#endif +#endif + +#ifndef DK4_HAVE_UINT8_T +#if HAVE_UINT8_T +/** DK4 version of HAVE_UINT8_T, available. +*/ +#define DK4_HAVE_UINT8_T 1 +#else +/** DK4 version of HAVE_UINT8_T, not available. +*/ +#define DK4_HAVE_UINT8_T 0 +#endif +#endif + +#ifndef DK4_HAVE_UNISTD_H +#if HAVE_UNISTD_H +/** DK4 version of HAVE_UNISTD_H, available. +*/ +#define DK4_HAVE_UNISTD_H 1 +#else +/** DK4 version of HAVE_UNISTD_H, not available. +*/ +#define DK4_HAVE_UNISTD_H 0 +#endif +#endif + +#ifndef DK4_HAVE_UNLINK +#if HAVE_UNLINK +/** DK4 version of HAVE_UNLINK, available. +*/ +#define DK4_HAVE_UNLINK 1 +#else +/** DK4 version of HAVE_UNLINK, not available. +*/ +#define DK4_HAVE_UNLINK 0 +#endif +#endif + +#ifndef DK4_HAVE_VOLATILE +#if HAVE_VOLATILE +/** DK4 version of HAVE_VOLATILE, available. +*/ +#define DK4_HAVE_VOLATILE 1 +#else +/** DK4 version of HAVE_VOLATILE, not available. +*/ +#define DK4_HAVE_VOLATILE 0 +#endif +#endif + +#ifndef DK4_HAVE_WCHAR_H +#if HAVE_WCHAR_H +/** DK4 version of HAVE_WCHAR_H, available. +*/ +#define DK4_HAVE_WCHAR_H 1 +#else +/** DK4 version of HAVE_WCHAR_H, not available. +*/ +#define DK4_HAVE_WCHAR_H 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSCASECMP +#if HAVE_WCSCASECMP +/** DK4 version of HAVE_WCSCASECMP, available. +*/ +#define DK4_HAVE_WCSCASECMP 1 +#else +/** DK4 version of HAVE_WCSCASECMP, not available. +*/ +#define DK4_HAVE_WCSCASECMP 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSCAT +#if HAVE_WCSCAT +/** DK4 version of HAVE_WCSCAT, available. +*/ +#define DK4_HAVE_WCSCAT 1 +#else +/** DK4 version of HAVE_WCSCAT, not available. +*/ +#define DK4_HAVE_WCSCAT 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSCAT_S +#if HAVE_WCSCAT_S +/** DK4 version of HAVE_WCSCAT_S, available. +*/ +#define DK4_HAVE_WCSCAT_S 1 +#else +/** DK4 version of HAVE_WCSCAT_S, not available. +*/ +#define DK4_HAVE_WCSCAT_S 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSCHR +#if HAVE_WCSCHR +/** DK4 version of HAVE_WCSCHR, available. +*/ +#define DK4_HAVE_WCSCHR 1 +#else +/** DK4 version of HAVE_WCSCHR, not available. +*/ +#define DK4_HAVE_WCSCHR 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSCMP +#if HAVE_WCSCMP +/** DK4 version of HAVE_WCSCMP, available. +*/ +#define DK4_HAVE_WCSCMP 1 +#else +/** DK4 version of HAVE_WCSCMP, not available. +*/ +#define DK4_HAVE_WCSCMP 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSCPY +#if HAVE_WCSCPY +/** DK4 version of HAVE_WCSCPY, available. +*/ +#define DK4_HAVE_WCSCPY 1 +#else +/** DK4 version of HAVE_WCSCPY, not available. +*/ +#define DK4_HAVE_WCSCPY 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSCPY_S +#if HAVE_WCSCPY_S +/** DK4 version of HAVE_WCSCPY_S, available. +*/ +#define DK4_HAVE_WCSCPY_S 1 +#else +/** DK4 version of HAVE_WCSCPY_S, not available. +*/ +#define DK4_HAVE_WCSCPY_S 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSICMP +#if HAVE_WCSICMP +/** DK4 version of HAVE_WCSICMP, available. +*/ +#define DK4_HAVE_WCSICMP 1 +#else +/** DK4 version of HAVE_WCSICMP, not available. +*/ +#define DK4_HAVE_WCSICMP 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSLEN +#if HAVE_WCSLEN +/** DK4 version of HAVE_WCSLEN, available. +*/ +#define DK4_HAVE_WCSLEN 1 +#else +/** DK4 version of HAVE_WCSLEN, not available. +*/ +#define DK4_HAVE_WCSLEN 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSNCMP +#if HAVE_WCSNCMP +/** DK4 version of HAVE_WCSNCMP, available. +*/ +#define DK4_HAVE_WCSNCMP 1 +#else +/** DK4 version of HAVE_WCSNCMP, not available. +*/ +#define DK4_HAVE_WCSNCMP 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSRCHR +#if HAVE_WCSRCHR +/** DK4 version of HAVE_WCSRCHR, available. +*/ +#define DK4_HAVE_WCSRCHR 1 +#else +/** DK4 version of HAVE_WCSRCHR, not available. +*/ +#define DK4_HAVE_WCSRCHR 0 +#endif +#endif + +#ifndef DK4_HAVE_WCSTOD +#if HAVE_WCSTOD +/** DK4 version of HAVE_WCSTOD, available. +*/ +#define DK4_HAVE_WCSTOD 1 +#else +/** DK4 version of HAVE_WCSTOD, not available. +*/ +#define DK4_HAVE_WCSTOD 0 +#endif +#endif + +#ifndef DK4_HAVE_WCTYPE_H +#if HAVE_WCTYPE_H +/** DK4 version of HAVE_WCTYPE_H, available. +*/ +#define DK4_HAVE_WCTYPE_H 1 +#else +/** DK4 version of HAVE_WCTYPE_H, not available. +*/ +#define DK4_HAVE_WCTYPE_H 0 +#endif +#endif + +#ifndef DK4_HAVE_WINDOWS_H +#if HAVE_WINDOWS_H +/** DK4 version of HAVE_WINDOWS_H, available. +*/ +#define DK4_HAVE_WINDOWS_H 1 +#else +/** DK4 version of HAVE_WINDOWS_H, not available. +*/ +#define DK4_HAVE_WINDOWS_H 0 +#endif +#endif + +#ifndef DK4_HAVE_WINSOCK2_H +#if HAVE_WINSOCK2_H +/** DK4 version of HAVE_WINSOCK2_H, available. +*/ +#define DK4_HAVE_WINSOCK2_H 1 +#else +/** DK4 version of HAVE_WINSOCK2_H, not available. +*/ +#define DK4_HAVE_WINSOCK2_H 0 +#endif +#endif + +#ifndef DK4_HAVE_WMKDIR +#if HAVE_WMKDIR +/** DK4 version of HAVE_WMKDIR, available. +*/ +#define DK4_HAVE_WMKDIR 1 +#else +/** DK4 version of HAVE_WMKDIR, not available. +*/ +#define DK4_HAVE_WMKDIR 0 +#endif +#endif + +#ifndef DK4_HAVE_WRITE +#if HAVE_WRITE +/** DK4 version of HAVE_WRITE, available. +*/ +#define DK4_HAVE_WRITE 1 +#else +/** DK4 version of HAVE_WRITE, not available. +*/ +#define DK4_HAVE_WRITE 0 +#endif +#endif + +#ifndef DK4_HAVE_WRMDIR +#if HAVE_WRMDIR +/** DK4 version of HAVE_WRMDIR, available. +*/ +#define DK4_HAVE_WRMDIR 1 +#else +/** DK4 version of HAVE_WRMDIR, not available. +*/ +#define DK4_HAVE_WRMDIR 0 +#endif +#endif + +#ifndef DK4_HAVE_WS2TCPIP_H +#if HAVE_WS2TCPIP_H +/** DK4 version of HAVE_WS2TCPIP_H, available. +*/ +#define DK4_HAVE_WS2TCPIP_H 1 +#else +/** DK4 version of HAVE_WS2TCPIP_H, not available. +*/ +#define DK4_HAVE_WS2TCPIP_H 0 +#endif +#endif + +#ifndef DK4_HAVE_WUNLINK +#if HAVE_WUNLINK +/** DK4 version of HAVE_WUNLINK, available. +*/ +#define DK4_HAVE_WUNLINK 1 +#else +/** DK4 version of HAVE_WUNLINK, not available. +*/ +#define DK4_HAVE_WUNLINK 0 +#endif +#endif + +#ifndef DK4_HAVE_WXWIDGETS +#if HAVE_WXWIDGETS +/** DK4 version of HAVE_WXWIDGETS, available. +*/ +#define DK4_HAVE_WXWIDGETS 1 +#else +/** DK4 version of HAVE_WXWIDGETS, not available. +*/ +#define DK4_HAVE_WXWIDGETS 0 +#endif +#endif + +#ifndef DK4_HAVE_ZLIB_H +#if HAVE_ZLIB_H +/** DK4 version of HAVE_ZLIB_H, available. +*/ +#define DK4_HAVE_ZLIB_H 1 +#else +/** DK4 version of HAVE_ZLIB_H, not available. +*/ +#define DK4_HAVE_ZLIB_H 0 +#endif +#endif + +#ifndef DK4_HAVE__DEV_T +#if HAVE__DEV_T +/** DK4 version of HAVE__DEV_T, available. +*/ +#define DK4_HAVE__DEV_T 1 +#else +/** DK4 version of HAVE__DEV_T, not available. +*/ +#define DK4_HAVE__DEV_T 0 +#endif +#endif + +#ifndef DK4_HAVE__FILENO +#if HAVE__FILENO +/** DK4 version of HAVE__FILENO, available. +*/ +#define DK4_HAVE__FILENO 1 +#else +/** DK4 version of HAVE__FILENO, not available. +*/ +#define DK4_HAVE__FILENO 0 +#endif +#endif + +#ifndef DK4_HAVE__FINITE +#if HAVE__FINITE +/** DK4 version of HAVE__FINITE, available. +*/ +#define DK4_HAVE__FINITE 1 +#else +/** DK4 version of HAVE__FINITE, not available. +*/ +#define DK4_HAVE__FINITE 0 +#endif +#endif + +#ifndef DK4_HAVE__FPOS_T +#if HAVE__FPOS_T +/** DK4 version of HAVE__FPOS_T, available. +*/ +#define DK4_HAVE__FPOS_T 1 +#else +/** DK4 version of HAVE__FPOS_T, not available. +*/ +#define DK4_HAVE__FPOS_T 0 +#endif +#endif + +#ifndef DK4_HAVE__GETCWD +#if HAVE__GETCWD +/** DK4 version of HAVE__GETCWD, available. +*/ +#define DK4_HAVE__GETCWD 1 +#else +/** DK4 version of HAVE__GETCWD, not available. +*/ +#define DK4_HAVE__GETCWD 0 +#endif +#endif + +#ifndef DK4_HAVE__INO64_T +#if HAVE__INO64_T +/** DK4 version of HAVE__INO64_T, available. +*/ +#define DK4_HAVE__INO64_T 1 +#else +/** DK4 version of HAVE__INO64_T, not available. +*/ +#define DK4_HAVE__INO64_T 0 +#endif +#endif + +#ifndef DK4_HAVE__INO_T +#if HAVE__INO_T +/** DK4 version of HAVE__INO_T, available. +*/ +#define DK4_HAVE__INO_T 1 +#else +/** DK4 version of HAVE__INO_T, not available. +*/ +#define DK4_HAVE__INO_T 0 +#endif +#endif + +#ifndef DK4_HAVE__ISATTY +#if HAVE__ISATTY +/** DK4 version of HAVE__ISATTY, available. +*/ +#define DK4_HAVE__ISATTY 1 +#else +/** DK4 version of HAVE__ISATTY, not available. +*/ +#define DK4_HAVE__ISATTY 0 +#endif +#endif + +#ifndef DK4_HAVE__MKDIR +#if HAVE__MKDIR +/** DK4 version of HAVE__MKDIR, available. +*/ +#define DK4_HAVE__MKDIR 1 +#else +/** DK4 version of HAVE__MKDIR, not available. +*/ +#define DK4_HAVE__MKDIR 0 +#endif +#endif + +#ifndef DK4_HAVE__OFF64_T +#if HAVE__OFF64_T +/** DK4 version of HAVE__OFF64_T, available. +*/ +#define DK4_HAVE__OFF64_T 1 +#else +/** DK4 version of HAVE__OFF64_T, not available. +*/ +#define DK4_HAVE__OFF64_T 0 +#endif +#endif + +#ifndef DK4_HAVE__OFF_T +#if HAVE__OFF_T +/** DK4 version of HAVE__OFF_T, available. +*/ +#define DK4_HAVE__OFF_T 1 +#else +/** DK4 version of HAVE__OFF_T, not available. +*/ +#define DK4_HAVE__OFF_T 0 +#endif +#endif + +#ifndef DK4_HAVE__READ +#if HAVE__READ +/** DK4 version of HAVE__READ, available. +*/ +#define DK4_HAVE__READ 1 +#else +/** DK4 version of HAVE__READ, not available. +*/ +#define DK4_HAVE__READ 0 +#endif +#endif + +#ifndef DK4_HAVE__RMDIR +#if HAVE__RMDIR +/** DK4 version of HAVE__RMDIR, available. +*/ +#define DK4_HAVE__RMDIR 1 +#else +/** DK4 version of HAVE__RMDIR, not available. +*/ +#define DK4_HAVE__RMDIR 0 +#endif +#endif + +#ifndef DK4_HAVE__SETMODE +#if HAVE__SETMODE +/** DK4 version of HAVE__SETMODE, available. +*/ +#define DK4_HAVE__SETMODE 1 +#else +/** DK4 version of HAVE__SETMODE, not available. +*/ +#define DK4_HAVE__SETMODE 0 +#endif +#endif + +#ifndef DK4_HAVE__SNPRINTF +#if HAVE__SNPRINTF +/** DK4 version of HAVE__SNPRINTF, available. +*/ +#define DK4_HAVE__SNPRINTF 1 +#else +/** DK4 version of HAVE__SNPRINTF, not available. +*/ +#define DK4_HAVE__SNPRINTF 0 +#endif +#endif + +#ifndef DK4_HAVE__SNPRINTF_S +#if HAVE__SNPRINTF_S +/** DK4 version of HAVE__SNPRINTF_S, available. +*/ +#define DK4_HAVE__SNPRINTF_S 1 +#else +/** DK4 version of HAVE__SNPRINTF_S, not available. +*/ +#define DK4_HAVE__SNPRINTF_S 0 +#endif +#endif + +#ifndef DK4_HAVE__SNWPRINTF +#if HAVE__SNWPRINTF +/** DK4 version of HAVE__SNWPRINTF, available. +*/ +#define DK4_HAVE__SNWPRINTF 1 +#else +/** DK4 version of HAVE__SNWPRINTF, not available. +*/ +#define DK4_HAVE__SNWPRINTF 0 +#endif +#endif + +#ifndef DK4_HAVE__SNWPRINTF_S +#if HAVE__SNWPRINTF_S +/** DK4 version of HAVE__SNWPRINTF_S, available. +*/ +#define DK4_HAVE__SNWPRINTF_S 1 +#else +/** DK4 version of HAVE__SNWPRINTF_S, not available. +*/ +#define DK4_HAVE__SNWPRINTF_S 0 +#endif +#endif + +#ifndef DK4_HAVE__STRICMP +#if HAVE__STRICMP +/** DK4 version of HAVE__STRICMP, available. +*/ +#define DK4_HAVE__STRICMP 1 +#else +/** DK4 version of HAVE__STRICMP, not available. +*/ +#define DK4_HAVE__STRICMP 0 +#endif +#endif + +#ifndef DK4_HAVE__STRTOD +#if HAVE__STRTOD +/** DK4 version of HAVE__STRTOD, available. +*/ +#define DK4_HAVE__STRTOD 1 +#else +/** DK4 version of HAVE__STRTOD, not available. +*/ +#define DK4_HAVE__STRTOD 0 +#endif +#endif + +#ifndef DK4_HAVE__UNLINK +#if HAVE__UNLINK +/** DK4 version of HAVE__UNLINK, available. +*/ +#define DK4_HAVE__UNLINK 1 +#else +/** DK4 version of HAVE__UNLINK, not available. +*/ +#define DK4_HAVE__UNLINK 0 +#endif +#endif + +#ifndef DK4_HAVE__WCSCASECMP +#if HAVE__WCSCASECMP +/** DK4 version of HAVE__WCSCASECMP, available. +*/ +#define DK4_HAVE__WCSCASECMP 1 +#else +/** DK4 version of HAVE__WCSCASECMP, not available. +*/ +#define DK4_HAVE__WCSCASECMP 0 +#endif +#endif + +#ifndef DK4_HAVE__WCSCMP +#if HAVE__WCSCMP +/** DK4 version of HAVE__WCSCMP, available. +*/ +#define DK4_HAVE__WCSCMP 1 +#else +/** DK4 version of HAVE__WCSCMP, not available. +*/ +#define DK4_HAVE__WCSCMP 0 +#endif +#endif + +#ifndef DK4_HAVE__WCSICMP +#if HAVE__WCSICMP +/** DK4 version of HAVE__WCSICMP, available. +*/ +#define DK4_HAVE__WCSICMP 1 +#else +/** DK4 version of HAVE__WCSICMP, not available. +*/ +#define DK4_HAVE__WCSICMP 0 +#endif +#endif + +#ifndef DK4_HAVE__WCSNCMP +#if HAVE__WCSNCMP +/** DK4 version of HAVE__WCSNCMP, available. +*/ +#define DK4_HAVE__WCSNCMP 1 +#else +/** DK4 version of HAVE__WCSNCMP, not available. +*/ +#define DK4_HAVE__WCSNCMP 0 +#endif +#endif + +#ifndef DK4_HAVE__WCSTOD +#if HAVE__WCSTOD +/** DK4 version of HAVE__WCSTOD, available. +*/ +#define DK4_HAVE__WCSTOD 1 +#else +/** DK4 version of HAVE__WCSTOD, not available. +*/ +#define DK4_HAVE__WCSTOD 0 +#endif +#endif + +#ifndef DK4_HAVE__WFOPEN +#if HAVE__WFOPEN +/** DK4 version of HAVE__WFOPEN, available. +*/ +#define DK4_HAVE__WFOPEN 1 +#else +/** DK4 version of HAVE__WFOPEN, not available. +*/ +#define DK4_HAVE__WFOPEN 0 +#endif +#endif + +#ifndef DK4_HAVE__WFOPEN64 +#if HAVE__WFOPEN64 +/** DK4 version of HAVE__WFOPEN64, available. +*/ +#define DK4_HAVE__WFOPEN64 1 +#else +/** DK4 version of HAVE__WFOPEN64, not available. +*/ +#define DK4_HAVE__WFOPEN64 0 +#endif +#endif + +#ifndef DK4_HAVE__WFOPEN_S +#if HAVE__WFOPEN_S +/** DK4 version of HAVE__WFOPEN_S, available. +*/ +#define DK4_HAVE__WFOPEN_S 1 +#else +/** DK4 version of HAVE__WFOPEN_S, not available. +*/ +#define DK4_HAVE__WFOPEN_S 0 +#endif +#endif + +#ifndef DK4_HAVE__WGETCWD +#if HAVE__WGETCWD +/** DK4 version of HAVE__WGETCWD, available. +*/ +#define DK4_HAVE__WGETCWD 1 +#else +/** DK4 version of HAVE__WGETCWD, not available. +*/ +#define DK4_HAVE__WGETCWD 0 +#endif +#endif + +#ifndef DK4_HAVE__WMKDIR +#if HAVE__WMKDIR +/** DK4 version of HAVE__WMKDIR, available. +*/ +#define DK4_HAVE__WMKDIR 1 +#else +/** DK4 version of HAVE__WMKDIR, not available. +*/ +#define DK4_HAVE__WMKDIR 0 +#endif +#endif + +#ifndef DK4_HAVE__WRITE +#if HAVE__WRITE +/** DK4 version of HAVE__WRITE, available. +*/ +#define DK4_HAVE__WRITE 1 +#else +/** DK4 version of HAVE__WRITE, not available. +*/ +#define DK4_HAVE__WRITE 0 +#endif +#endif + +#ifndef DK4_HAVE__WRMDIR +#if HAVE__WRMDIR +/** DK4 version of HAVE__WRMDIR, available. +*/ +#define DK4_HAVE__WRMDIR 1 +#else +/** DK4 version of HAVE__WRMDIR, not available. +*/ +#define DK4_HAVE__WRMDIR 0 +#endif +#endif + +#ifndef DK4_HAVE__WUNLINK +#if HAVE__WUNLINK +/** DK4 version of HAVE__WUNLINK, available. +*/ +#define DK4_HAVE__WUNLINK 1 +#else +/** DK4 version of HAVE__WUNLINK, not available. +*/ +#define DK4_HAVE__WUNLINK 0 +#endif +#endif + +#ifndef DK4_SIZEOF_DOUBLE +/** DK4 version of SIZEOF_DOUBLE. +*/ +#define DK4_SIZEOF_DOUBLE SIZEOF_DOUBLE +#endif + +#ifndef DK4_SIZEOF_INO64_T +/** DK4 version of SIZEOF_INO64_T. +*/ +#define DK4_SIZEOF_INO64_T SIZEOF_INO64_T +#endif + +#ifndef DK4_SIZEOF_INO_T +/** DK4 version of SIZEOF_INO_T. +*/ +#define DK4_SIZEOF_INO_T SIZEOF_INO_T +#endif + +#ifndef DK4_SIZEOF_INT +/** DK4 version of SIZEOF_INT. +*/ +#define DK4_SIZEOF_INT SIZEOF_INT +#endif + +#ifndef DK4_SIZEOF_INTMAX_T +/** DK4 version of SIZEOF_INTMAX_T. +*/ +#define DK4_SIZEOF_INTMAX_T SIZEOF_INTMAX_T +#endif + +#ifndef DK4_SIZEOF_LONG +/** DK4 version of SIZEOF_LONG. +*/ +#define DK4_SIZEOF_LONG SIZEOF_LONG +#endif + +#ifndef DK4_SIZEOF_LONG_DOUBLE +/** DK4 version of SIZEOF_LONG_DOUBLE. +*/ +#define DK4_SIZEOF_LONG_DOUBLE SIZEOF_LONG_DOUBLE +#endif + +#ifndef DK4_SIZEOF_LONG_LONG +/** DK4 version of SIZEOF_LONG_LONG. +*/ +#define DK4_SIZEOF_LONG_LONG SIZEOF_LONG_LONG +#endif + +#ifndef DK4_SIZEOF_OFF64_T +/** DK4 version of SIZEOF_OFF64_T. +*/ +#define DK4_SIZEOF_OFF64_T SIZEOF_OFF64_T +#endif + +#ifndef DK4_SIZEOF_OFF_T +/** DK4 version of SIZEOF_OFF_T. +*/ +#define DK4_SIZEOF_OFF_T SIZEOF_OFF_T +#endif + +#ifndef DK4_SIZEOF_SHORT +/** DK4 version of SIZEOF_SHORT. +*/ +#define DK4_SIZEOF_SHORT SIZEOF_SHORT +#endif + +#ifndef DK4_SIZEOF_SIZE_T +/** DK4 version of SIZEOF_SIZE_T. +*/ +#define DK4_SIZEOF_SIZE_T SIZEOF_SIZE_T +#endif + +#ifndef DK4_SIZEOF_WCHAR_T +/** DK4 version of SIZEOF_WCHAR_T. +*/ +#define DK4_SIZEOF_WCHAR_T SIZEOF_WCHAR_T +#endif + +#ifndef DK4_TIME_WITH_SYS_TIME +#if TIME_WITH_SYS_TIME +/** DK4 version of TIME_WITH_SYS_TIME, available. +*/ +#define DK4_TIME_WITH_SYS_TIME TIME_WITH_SYS_TIME +#else +/** DK4 version of TIME_WITH_SYS_TIME, not available. +*/ +#define DK4_TIME_WITH_SYS_TIME 0 +#endif +#endif + +#ifndef DK4_USE_FALLBACK_NUMERIC_LIMITS +#if USE_FALLBACK_NUMERIC_LIMITS +/** DK4 version of USE_FALLBACK_NUMERIC_LIMITS, available. +*/ +#define DK4_USE_FALLBACK_NUMERIC_LIMITS USE_FALLBACK_NUMERIC_LIMITS +#else +/** DK4 version of USE_FALLBACK_NUMERIC_LIMITS, not available. +*/ +#define DK4_USE_FALLBACK_NUMERIC_LIMITS 0 +#endif +#endif + +#ifndef DK4_USE_PRINTF_SCANF +#if USE_PRINTF_SCANF +/** DK4 version of USE_PRINTF_SCANF, available. +*/ +#define DK4_USE_PRINTF_SCANF USE_PRINTF_SCANF +#else +/** DK4 version of USE_PRINTF_SCANF, not available. +*/ +#define DK4_USE_PRINTF_SCANF 0 +#endif +#endif + +#ifndef DK4_USE_WINDOWS_LOCAL_ALLOC +#if USE_WINDOWS_LOCAL_ALLOC +/** DK4 version of USE_WINDOWS_LOCAL_ALLOC, available. +*/ +#define DK4_USE_WINDOWS_LOCAL_ALLOC USE_WINDOWS_LOCAL_ALLOC +#else +/** DK4 version of USE_WINDOWS_LOCAL_ALLOC, not available. +*/ +#define DK4_USE_WINDOWS_LOCAL_ALLOC 0 +#endif +#endif + +#ifndef DK4_WORDS_BIGENDIAN +#if WORDS_BIGENDIAN +/** DK4 version of WORDS_BIGENDIAN, available. +*/ +#define DK4_WORDS_BIGENDIAN WORDS_BIGENDIAN +#else +/** DK4 version of WORDS_BIGENDIAN, not available. +*/ +#define DK4_WORDS_BIGENDIAN 0 +#endif +#endif + +#endif +/* if DK4CONF_H_INCLUDED */ -- cgit v1.2.3