WL#5161 : Cross-platform build with CMake

BUILD-CMAKE:
  WL#5161 : Documentation on how to build with CMake on Unix/Windows
BUILD/Makefile.am:
  Add new file
BUILD/autorun.sh:
  WL#5161 : use choose_configure instead of autotools configure script
  (choose configure will call cmake if cmake is available)
BUILD/choose_configure.sh:
  WL#5161 : use choose_configure instead of autotools configure script
  (choose configure will call cmake if cmake is available)
CMakeLists.txt:
  WL#5161 : Rewrite top-level CMakeLists.txt. 
  Remove  Windows specifics
  - compiler flags handling moved to configure.cmake
  - storage engine/plugin stuff moved into cmake/plugin.cmake
  - copy docs
Makefile.am:
  Added new files
client/CMakeLists.txt:
  WL#5161 : Rewrite CMakeLists.txt to be platform-independent
  Handle packagng (add INSTALL commands)
cmake/Makefile.am:
  WL#5161 : use choose_configure instead of autotools configure script
  (choose configure will call cmake if cmake is available)
cmake/abi_check.cmake:
  Custom targets for abi_check (for cmake)
cmake/bison.cmake:
  - Check bison availability
  - Add RUN_BISON macro (used to create sql_yacc.cc and sql_yacc.h)
cmake/cat.cmake:
  Add helper script to concatenate files.
cmake/character_sets.cmake:
  Handle configuration parameters WITH_EXTRA_CHARSETS
cmake/check_minimal_version.cmake:
  Helper script to check the minimum required version of cmake
cmake/configure.pl:
  Add perl script to convert ./configure parameters for cmake
cmake/create_initial_db.cmake.in:
  Add script helper to create initial database. 
  (on Windows, we pack initial db with the redistribution
  package)
cmake/do_abi_check.cmake:
  Perform abi check
cmake/dtrace.cmake:
  Handle dtrace in CMake Build.
  Check for dtrace availablility,
  run dtrace -G on solaris in prelink step
cmake/dtrace_prelink.cmake:
  Run dtrace -G on Solaris in pre-link step,
  link the object it creates together with library or
  executable
cmake/install_macros.cmake:
  Helper macros for packaging
  (install pdb on Windows, install symlinks on Unix)
cmake/make_dist.cmake.in:
  "make dist" - 
  - pack autotools ./configure script with the source
  (renamed to configure.am)
  - pack bison output
cmake/merge_archives_unix.cmake.in:
  script to merge static libraries on Unix
cmake/misc.cmake:
  Build helper macros
  - MERGE_STATIC_LIBS 
  We use it when building client library and embedded
  (avoid recompilation)
  
  - Convert source file paths to absolute names.
  We use it in  to locate files of a different project,
  when the files need to be recompiled (e.g in embedded
  several storage engines are recompiled with 
  -DEMBEDDED_LIBRARY)
cmake/mysql_version.cmake:
  Extract version info from configure.in
  Handle package names.
cmake/plugin.cmake:
  Rewrote storage/mysql_storage_engine.cmake to handle 
  other types of plugins and do it in OS-independent manner.
cmake/readline.cmake:
  Macros to handle WITH_READLINE/WITH_LIBEDIT parameters
cmake/ssl.cmake:
  Add macros to handle WITH_SSL parameter.
cmake/stack_direction.c:
  Helper to check stack direction.
cmake/zlib.cmake:
  Add macros to handle WITH_ZLIB parameter
cmd-line-utils/libedit/CMakeLists.txt:
  Build libedit with cmake.
cmd-line-utils/libedit/Makefile.am:
  Add new file
cmd-line-utils/readline/CMakeLists.txt:
  Build readline with CMake.
cmd-line-utils/readline/Makefile.am:
  Add new file
config.h.cmake:
  WL#5161 : Add config.h template for cmake
configure.cmake:
  WL#5161 : Add platform tests ( for cmake)
configure.in:
  Added new subdirectories
dbug/CMakeLists.txt:
  WL#5161
extra/CMakeLists.txt:
  WL#5161
extra/yassl/CMakeLists.txt:
  WL#5161
extra/yassl/taocrypt/CMakeLists.txt:
  WL#5161
include/Makefile.am:
  Add new file
include/keycache.h:
  remove configure-win.h and remove HUGE_PTR defined there.
include/my_global.h:
  use my_config.h for Windows, not config-win.h anymore
include/my_pthread.h:
  - Move thread_safe_increment from config-win.h to other headers
  (config-win.h is not used anymore)
  - Declare pthread_cancel on Windows (it is used in daemon_example)
include/my_sys.h:
  Add malloc.h on Windows (we use -D_WIN32_LEAN_AND_MEAN now, and 
  with this define malloc.h is not included automatically via windows.h)
include/mysql/plugin.h:
  Handle pure-C plugins with Microsoft compiler.
include/thr_alarm.h:
  remove rf_SetTimer that used to be defined in config-win.h
  Replace with UINT_PTR (we do not use config-win.h anymore
  and typedef was needed in this single place only)
libmysql/CMakeLists.txt:
  Avoid pointless recompilation of source files 
  in client library if possible. Merge static 
  libs (dbug, mysys) to create static client 
  library.
libmysqld/CMakeLists.txt:
  Avoid pointless recompilation of source files 
  when building embedded. Instead, merge dbug and 
  mysys (and some other static libs) into embedded.
libmysqld/examples/CMakeLists.txt:
  Embedded compilation on Unix
libmysqld/lib_sql.cc:
  Do not define THD::clear_error() in lib_sql.cc
  for embedded. Instead, use the same inline 
  definition from sql_class.h as in none-embedded 
  case (fixes duplicate symbol errors on Windows
  and removes pointless #ifdef EMBEDDED)
man/CMakeLists.txt:
  Install man files.
man/Makefile.am:
  Add new file.
mysql-test/CMakeLists.txt:
  Install mysql-test files
mysql-test/Makefile.am:
  Add new files
mysql-test/lib/My/ConfigFactory.pm:
  Allow testing with mtr in out-of-source builds.
mysql-test/lib/My/Find.pm:
  the build configurations are now also available on Unix
  Xcode on Mac uses the Release, RelwithDebinfo and Debug 
  subdirectories for executables. Earlier, build configurations 
  were available only on Windows.
mysql-test/lib/My/SafeProcess.pm:
  Allow testing with mtr in out-of-source builds.
mysql-test/lib/My/SafeProcess/CMakeLists.txt:
  Port CMakeLists.txt to Unix
mysql-test/lib/My/SafeProcess/safe_kill_win.cc:
  add stdlib.h (to be able to compile with -DWIN32_LEAN_AND_MEAN)
mysql-test/lib/My/SafeProcess/safe_process_win.cc:
  Add stdlib.h (to be able to compile with -DWIN32_LEAN_AND_MEAN)
  define JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE if not defined 
  (can happen using MinGW compiler that comes with old SDK)
mysql-test/mtr.out-of-source:
  Allow testing with mtr in out-of-source builds.
mysql-test/mysql-test-run.pl:
  Allow testing with mtr in out-of-source builds.
  Use common find_plugin macro for Windows and unix.
mysql-test/t/fulltext_plugin.test:
  This test can now run on Windows as well.
mysys/CMakeLists.txt:
  Port CMakeLists.txt to Unix
mysys/my_create.c:
  config-win.h is dead => NO_OPEN_3 is never defined.
mysys/my_getsystime.c:
  config-win.h is dead => define OFFSET_TO_EPOCH where it is used.
mysys/my_winthread.c:
  Add  win32 pthread_cancel - used by daemon_example
mysys/mysys_priv.h:
  config-win.h is dead => include <sys/stat.h> where it is used
  fix prototype of my_win_(f)stat
plugin/daemon_example/CMakeLists.txt:
  Compile daemon_example with CMake
plugin/daemon_example/Makefile.am:
  Add new file
plugin/fulltext/CMakeLists.txt:
  Compile full-text example with CMake
plugin/fulltext/Makefile.am:
  Add new file.
plugin/semisync/CMakeLists.txt:
  Fix semisync to use common  macro for plugins.
regex/CMakeLists.txt:
  Use absolute filenames, when adding regex library 
  (we recompile files in embedded, and want to locate 
  sources via GET_TARGET_PROPERTY( ... SOURCES ..))
regex/regex2.h:
  Remove pointless typedef (produces error with MinGW compiler)
scripts/CMakeLists.txt:
  Add configure/install for scripts
sql-bench/CMakeLists.txt:
  install sql-bench files
sql-bench/Makefile.am:
  Add new file
sql/CMakeLists.txt:
  Port CmakeLists.txt to Unix
sql/nt_servc.cc:
  compile server with -DWIN32_LEAN_AND_MEAN
sql/share/CMakeLists.txt:
  Install charsets
sql/share/Makefile.am:
  Add new file
sql/sql_builtin.cc.in:
  Handle pure-C plugins on Windows.
sql/sql_class.h:
  Use the same clear_error macro in embedded and not embedded.
  Fixes pointless #ifdef and avoids duplicate symbols when linking
  on Windows.
storage/Makefile.am:
  storage/mysql_storage_engine.cmake => cmake/plugin.cmake
storage/archive/CMakeLists.txt:
  Add names for static and dynamic plugin libraries.
  Link archive with zlib
storage/blackhole/CMakeLists.txt:
  Add names for static and dynamic storage 
  engine libraries
storage/csv/CMakeLists.txt:
  Add names for static and dynamic storage engine
  libraries
storage/example/CMakeLists.txt:
  Add names for static and dynamic storage engine 
  libraries
storage/federated/CMakeLists.txt:
  Add names for static and dynamic storage engine 
  libraries
storage/heap/CMakeLists.txt:
  Add names for static and dynamic storage engine 
  libraries
storage/ibmdb2i/CMakeLists.txt:
  Better port for ibmdb2i plugin
storage/innobase/CMakeLists.txt:
  Run system checks.
  
  Add names for static and dynamic storage engine 
  libraries.
storage/innobase/include/page0page.ic:
  Fix compile error on OpenSolaris.
storage/myisam/CMakeLists.txt:
  Port CmakeLists.txt to Unix
storage/myisammrg/CMakeLists.txt:
  Add names for static and dynamic storage engine 
  libraries
storage/mysql_storage_engine.cmake:
  storage/mysql_storage_engine.cmake => cmake/plugin.cmake
support-files/CMakeLists.txt:
  Configure and install some files from support-files.
support-files/Makefile.am:
  Add new file
tests/CMakeLists.txt:
  In general case, mysqlclient library can be dependent
  on C++ runtime(if it includes yassl and is not compiled
  with gcc or MSVC)
unittest/mysys/CMakeLists.txt:
  Add unit tests
unittest/mysys/Makefile.am:
  Add new file
unittest/mytap/CMakeLists.txt:
  Add library for unit tests
unittest/mytap/Makefile.am:
  Add new file
unittest/mytap/tap.c:
  fix function definitions to match declarations
win/create_def_file.js:
  Fix link error with intel compiler (icl 
  defines of special label for exception handler)

1 files changed, 1335 insertions, 0 deletions

diff --git a/configure.cmake b/configure.cmake
new file mode 100644
index 00000000000..aff4c1403f9
--- /dev/null
+++ b/configure.cmake
@@ -0,0 +1,1335 @@
+# Copyright (C) 2009 Sun Microsystems,Inc
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+INCLUDE (CheckCSourceCompiles)
+INCLUDE (CheckCXXSourceCompiles)
+INCLUDE (CheckStructHasMember)
+INCLUDE (CheckLibraryExists)
+INCLUDE (CheckFunctionExists)
+INCLUDE (CheckCCompilerFlag)
+INCLUDE (CheckCSourceRuns)
+
+
+# Sometimes it is handy to know if PIC option
+# is set, to avoid recompilation of the same source 
+# for shared libs. We also allow it as an option for
+# fast compile.
+IF(UNIX)
+  IF(APPLE)  
+    # OSX  executable are always PIC
+    SET(WITH_PIC ON)
+  ELSE()
+    OPTION(WITH_PIC "Generate PIC objects" OFF)
+    IF(WITH_PIC)
+      SET(CMAKE_C_FLAGS 
+        "${CMAKE_C_FLAGS} ${CMAKE_SHARED_LIBRARY_C_FLAGS}")
+      SET(CMAKE_CXX_FLAGS 
+        "${CMAKE_CXX_FLAGS} ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}")
+    ENDIF()
+  ENDIF()
+ENDIF()
+
+
+#
+# Tests for OS
+IF (CMAKE_SYSTEM_NAME MATCHES "Linux")
+  SET(TARGET_OS_LINUX 1)
+  SET(HAVE_NPTL 1)
+ELSEIF(CMAKE_SYSTEM_NAME MATCHES "SunOS")
+  SET(TARGET_OS_SOLARIS 1)
+ENDIF()
+
+
+# OS display name (version_compile_os etc).
+# Used by the test suite to ignore bugs on some platforms, 
+# typically on Windows.
+IF(WIN32)
+ IF(CMAKE_SIZEOF_VOID_P MATCHES 8)
+   SET(SYSTEM_TYPE "Win64")
+ ELSE()
+   SET(SYSTEM_TYPE "Win32")
+ ENDIF()
+ELSE()
+  IF(PLATFORM)
+    SET(SYSTEM_TYPE ${PLATFORM})
+  ELSE()
+    SET(SYSTEM_TYPE ${CMAKE_SYSTEM_NAME})
+  ENDIF()
+ENDIF()
+
+
+# Intel compiler is almost Visual C++
+# (same compile flags etc). Set MSVC flag
+IF(WIN32 AND CMAKE_C_COMPILER MATCHES "icl")
+ SET(MSVC TRUE)
+ENDIF()
+
+IF(CMAKE_COMPILER_IS_GNUCXX)
+  SET(CMAKE_CXX_FLAGS 
+    "${CMAKE_CXX_FLAGS} -fno-implicit-templates -fno-exceptions -fno-rtti")
+  IF(CMAKE_CXX_FLAGS)
+    STRING(REGEX MATCH "fno-implicit-templates" NO_IMPLICIT_TEMPLATES
+      ${CMAKE_CXX_FLAGS})
+    IF (NO_IMPLICIT_TEMPLATES)
+      SET(HAVE_EXPLICIT_TEMPLATE_INSTANTIATION TRUE)
+    ENDIF()
+  ENDIF()
+  IF(MINGW AND CMAKE_SIZEOF_VOIDP EQUAL 4)
+   # mininal architecture flags, i486 enables GCC atomics
+   ADD_DEFINITIONS(-march=i486)
+  ENDIF()
+ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+
+IF(WIN32)
+  SET(CAN_CONVERT_STATIC_TO_SHARED_LIB 1)
+ENDIF()
+
+# Large files
+SET(_LARGEFILE_SOURCE  1)
+IF(CMAKE_SYSTEM_NAME STREQUAL "HP-UX")
+  SET(_LARGEFILE64_SOURCE 1)
+  SET(_FILE_OFFSET_BITS 64)
+ENDIF()
+IF(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_SYSTEM_NAME STREQUAL "SunOS" )
+  SET(_FILE_OFFSET_BITS 64)
+ENDIF()
+IF(CMAKE_SYSTEM_NAME MATCHES "AIX" OR CMAKE_SYSTEM_NAME MATCHES "OS400")
+  SET(_LARGE_FILES 1)
+ENDIF()
+
+
+
+  
+IF(MSVC)
+# Enable debug info also in Release build, and create PDB to be able to analyze 
+# crashes
+  SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+  SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zi")
+  SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /debug")
+ENDIF()
+
+IF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
+    # VS2003 has a bug that prevents linking mysqld with module definition file 
+    # (/DEF option for linker). Linker would incorrectly complain about multiply
+    # defined symbols. Workaround is to disable dynamic plugins, so /DEF is not
+    # used.
+    MESSAGE(
+   "Warning: Building MySQL with Visual Studio 2003.NET is no more supported.")
+    MESSAGE("Please use a newer version of Visual Studio.")
+    SET(WITHOUT_DYNAMIC_PLUGINS TRUE)
+	
+    # VS2003 needs the /Op compiler option to disable floating point 
+    # optimizations
+    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Op")
+    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Op")
+    SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Op")
+    SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Op")
+    SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Op")
+    SET(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} /Op")
+ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
+
+
+IF(CMAKE_SYSTEM_NAME STREQUAL "HP-UX" )
+  IF(CMAKE_SIZEOF_VOID_P EQUAL 4)
+    # HPUX linker crashes building plugins
+    SET(WITHOUT_DYNAMIC_PLUGINS TRUE)
+  ENDIF()
+  # If not PA-RISC make shared library suffix .so
+  # OS understands both .sl and .so. CMake would
+  # use .sl, however MySQL prefers .so
+  IF(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "9000")
+    SET(CMAKE_SHARED_LIBRARY_SUFFIX ".so" CACHE INTERNAL "" FORCE)
+    SET(CMAKE_SHARED_MODULE_SUFFIX ".so" CACHE INTERNAL "" FORCE)
+  ENDIF()
+ENDIF()
+
+#Some OS specific hacks
+IF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+  ADD_DEFINITIONS(-DNET_RETRY_COUNT=1000000)
+ELSEIF(CMAKE_SYSTEM MATCHES "HP-UX" AND CMAKE_SYSTEM MATCHES "11")
+  ADD_DEFINITIONS(-DHPUX11)
+ENDIF()
+
+# Disable warnings in Visual Studio 8 and above
+IF(MSVC AND NOT CMAKE_GENERATOR MATCHES "Visual Studio 7")
+  #TODO: update the code and remove the disabled warnings
+  ADD_DEFINITIONS(/wd4800 /wd4805)
+  ADD_DEFINITIONS(/wd4996)
+ENDIF()
+
+
+# Settings for Visual Studio 7 and above.  
+IF(MSVC)
+    # replace /MDd with /MTd
+    STRING(REPLACE "/MD"  "/MT"  CMAKE_C_FLAGS_RELEASE          ${CMAKE_C_FLAGS_RELEASE})
+    STRING(REPLACE "/MD"  "/MT"  CMAKE_C_FLAGS_RELWITHDEBINFO   ${CMAKE_C_FLAGS_RELWITHDEBINFO})
+    STRING(REPLACE "/MDd" "/MTd" CMAKE_C_FLAGS_DEBUG            ${CMAKE_C_FLAGS_DEBUG})
+    STRING(REPLACE "/MDd" "/MTd" CMAKE_C_FLAGS_DEBUG_INIT       ${CMAKE_C_FLAGS_DEBUG_INIT})
+
+    STRING(REPLACE "/MD"  "/MT"  CMAKE_CXX_FLAGS_RELEASE        ${CMAKE_CXX_FLAGS_RELEASE})
+    STRING(REPLACE "/MD"  "/MT"  CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
+    STRING(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG          ${CMAKE_CXX_FLAGS_DEBUG})
+    STRING(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG_INIT     ${CMAKE_CXX_FLAGS_DEBUG_INIT})
+
+    # generate map files, set stack size (see bug#20815)
+    SET(thread_stack_size 1048576)
+    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:${thread_stack_size}")
+    ADD_DEFINITIONS(-DPTHREAD_STACK_MIN=${thread_stack_size})
+
+    # remove support for Exception handling
+    STRING(REPLACE "/GX"   "" CMAKE_CXX_FLAGS            ${CMAKE_CXX_FLAGS})
+    STRING(REPLACE "/EHsc" "" CMAKE_CXX_FLAGS            ${CMAKE_CXX_FLAGS})
+    STRING(REPLACE "/EHsc" "" CMAKE_CXX_FLAGS_INIT       ${CMAKE_CXX_FLAGS_INIT})
+    STRING(REPLACE "/EHsc" "" CMAKE_CXX_FLAGS_DEBUG_INIT ${CMAKE_CXX_FLAGS_DEBUG_INIT})
+    
+    # Mark 32 bit executables large address aware so they can 
+    # use > 2GB address space
+    IF(CMAKE_SIZEOF_VOID_P MATCHES 4)
+      SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE")
+    ENDIF(CMAKE_SIZEOF_VOID_P MATCHES 4)
+ENDIF(MSVC)
+
+IF(WIN32)
+  ADD_DEFINITIONS("-D_WINDOWS -D__WIN__ -D_CRT_SECURE_NO_DEPRECATE")
+  ADD_DEFINITIONS("-D_WIN32_WINNT=0x0501")
+  # Speed up build process excluding unused header files
+  ADD_DEFINITIONS("-DWIN32_LEAN_AND_MEAN")
+  IF (MSVC_VERSION GREATER 1400)
+    # Speed up multiprocessor build
+     ADD_DEFINITIONS("/MP")
+  ENDIF()
+
+  # default to x86 platform.  We'll check for X64 in a bit
+  SET (PLATFORM X86)
+  IF(MSVC AND CMAKE_SIZEOF_VOID_P MATCHES 8)
+    # _WIN64 is defined by the compiler itself. 
+    # Yet, we define it here again   to work around a bug with  Intellisense 
+    # described here: http://tinyurl.com/2cb428. 
+    # Syntax highlighting is important for proper debugger functionality.
+    ADD_DEFINITIONS("-D_WIN64")
+    SET (PLATFORM X64)
+  ENDIF()
+ENDIF()
+
+
+
+# Figure out what engines to build and how (statically or dynamically),
+# add preprocessor defines for storage engines.
+IF(WITHOUT_DYNAMIC_PLUGINS)
+  MESSAGE("Dynamic plugins are disabled.")
+ENDIF(WITHOUT_DYNAMIC_PLUGINS)
+
+
+# Perform machine tests on posix platforms only
+IF(WIN32)
+ SET(SYSTEM_LIBS ws2_32)
+ SET(CMAKE_REQUIRED_INCLUDES "winsock2.h;ws2tcpip.h")
+ SET(CMAKE_REQUIRED_DEFINITONS "-D_WIN32_WINNT=0x0501")
+ SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ws2_32)
+ LINK_LIBRARIES(ws2_32)
+ENDIF()
+
+
+
+MACRO(MY_CHECK_LIB func lib found)
+  SET(${found} 0)
+  CHECK_FUNCTION_EXISTS(${func} HAVE_${func}_IN_LIBC)
+  CHECK_LIBRARY_EXISTS(${lib} ${func} "" HAVE_${func}_IN_${lib}) 
+  IF (HAVE_${func}_IN_${lib})
+    SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${lib})
+    LINK_LIBRARIES(${lib})
+    STRING(TOUPPER ${lib} upper_lib) 
+    SET(HAVE_LIB${upper_lib} 1 CACHE INTERNAL "Library check")
+    SET(${found} 1)
+  ENDIF()
+ENDMACRO()
+
+MACRO(MY_SEARCH_LIBS func lib found)
+  SET(${found} 0)
+  CHECK_FUNCTION_EXISTS(${func} HAVE_${func}_IN_LIBC)
+  IF(NOT HAVE_${func}_IN_LIBC) 
+    MY_CHECK_LIB(${func} ${lib} ${found})    
+  ELSE()
+    SET(${found} 1)
+  ENDIF()
+ENDMACRO()
+
+IF(UNIX)
+  MY_CHECK_LIB(floor m found)
+  IF(NOT found)
+    MY_CHECK_LIB( __infinity m found)
+  ENDIF()
+  MY_CHECK_LIB(gethostbyname_r  nsl_r found)
+  IF (NOT found)
+    MY_CHECK_LIB(gethostbyname_r nsl found)
+  ENDIF()
+  MY_SEARCH_LIBS(bind bind found)
+  MY_SEARCH_LIBS(crypt crypt found)
+  MY_SEARCH_LIBS(setsockopt socket found)
+  MY_SEARCH_LIBS(aio_read rt found)
+  MY_SEARCH_LIBS(sched_yield posix4 found)
+  MY_CHECK_LIB(pthread_create pthread found)
+  MY_SEARCH_LIBS(dlopen dl found)
+ 
+  OPTION(WITH_LIBWRAP "Compile with tcp wrappers support" OFF)
+  IF(WITH_LIBWRAP)
+    SET(SAVE_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
+    SET(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} wrap)
+    CHECK_C_SOURCE_COMPILES(
+    "
+    #include <tcpd.h>
+    int allow_severity = 0;
+    int deny_severity  = 0;
+    int main()
+    {
+      hosts_access(0);
+    }"
+    HAVE_LIBWRAP)
+    SET(CMAKE_REQUIRED_LIBRARIES ${SAVE_CMAKE_REQUIRED_LIBRARIES})
+    IF(HAVE_LIBWRAP)
+      SET(MYSYS_LIBWRAP_SOURCE  ${CMAKE_SOURCE_DIR}/mysys/my_libwrap.c)
+      SET(LIBWRAP_LIBRARY "wrap")
+    ENDIF()
+  ENDIF()
+ENDIF()
+
+IF (CMAKE_SYSTEM_NAME MATCHES "SunOS")
+  INCLUDE(CheckLibraryExists)
+  CHECK_LIBRARY_EXISTS(mtmalloc malloc "" HAVE_LIBMTMALLOC)
+  IF(HAVE_LIBMTMALLOC)
+    LINK_LIBRARIES(mtmalloc)
+  ENDIF()
+ENDIF()
+
+
+# Workaround for CMake bug#9051
+IF(CMAKE_OSX_SYSROOT)
+ SET(ENV{CMAKE_OSX_SYSROOT} ${CMAKE_OSX_SYSROOT})
+ENDIF()
+IF(CMAKE_OSX_SYSROOT)
+ SET(ENV{MACOSX_DEPLOYMENT_TARGET} ${OSX_DEPLOYMENT_TARGET})
+ENDIF()
+
+# This macro is used only on Windows at the moment
+# Some standard functions exist there under different
+# names (e.g popen is _popen or strok_r is _strtok_s)
+# If a replacement function exists, HAVE_FUNCTION is
+# defined to 1. CMake variable <function_name> will also
+# be defined to the replacement name.
+# So for example, CHECK_FUNCTION_REPLACEMENT(popen _popen)
+# will define HAVE_POPEN to 1 and set variable named popen
+# to _popen. If the header template, one needs to have
+# cmakedefine popen @popen@ which will expand to 
+# define popen _popen after CONFIGURE_FILE
+
+MACRO(CHECK_FUNCTION_REPLACEMENT function replacement)
+  STRING(TOUPPER ${function} function_upper)
+  CHECK_FUNCTION_EXISTS(${function} HAVE_${function_upper})
+  IF(NOT HAVE_${function_upper})
+    CHECK_FUNCTION_EXISTS(${replacement}  HAVE_${replacement})
+    IF(HAVE_${replacement})
+      SET(HAVE_${function_upper} 1 )
+      SET(${function} ${replacement})
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+
+MACRO(CHECK_SYMBOL_REPLACEMENT symbol replacement header)
+  STRING(TOUPPER ${symbol} symbol_upper)
+  CHECK_SYMBOL_EXISTS(${symbol} ${header} HAVE_${symbol_upper})
+  IF(NOT HAVE_${symbol_upper})
+    CHECK_SYMBOL_EXISTS(${replacement} ${header} HAVE_${replacement})
+    IF(HAVE_${replacement})
+      SET(HAVE_${symbol_upper} 1)
+      SET(${symbol} ${replacement})
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+
+
+MACRO(CHECK_INCLUDE_FILES_UNIX INCLUDES VAR)
+IF(UNIX)
+  CHECK_INCLUDE_FILES ("${INCLUDES}" ${VAR})
+ENDIF()
+ENDMACRO()
+
+MACRO(CHECK_C_SOURCE_COMPILES_UNIX SRC VAR)
+IF(UNIX)
+  CHECK_C_SOURCE_COMPILES("${SRC}" ${VAR})
+ENDIF()
+ENDMACRO()
+
+MACRO(CHECK_CXX_SOURCE_COMPILES_UNIX SRC VAR)
+IF(UNIX)
+  CHECK_CXX_SOURCE_COMPILES("${SRC}" ${VAR})
+ENDIF()
+ENDMACRO()
+
+MACRO(CHECK_FUNCTION_EXISTS_UNIX FUNC VAR)
+IF(UNIX)
+  CHECK_FUNCTION_EXISTS("${FUNC}" ${VAR})
+ENDIF()
+ENDMACRO()
+
+MACRO (CHECK_SYMBOL_EXISTS_UNIX SYM HEADER VAR)
+IF(UNIX)
+  CHECK_SYMBOL_EXISTS("${SYM}" "${HEADER}" ${VAR})
+ENDIF()
+ENDMACRO()
+
+#
+# Tests for header files
+#
+INCLUDE (CheckIncludeFiles)
+
+CHECK_INCLUDE_FILES ("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS)
+CHECK_INCLUDE_FILES (sys/types.h HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILES_UNIX (alloca.h HAVE_ALLOCA_H)
+CHECK_INCLUDE_FILES_UNIX (aio.h HAVE_AIO_H)
+CHECK_INCLUDE_FILES_UNIX (arpa/inet.h HAVE_ARPA_INET_H)
+CHECK_INCLUDE_FILES_UNIX (crypt.h HAVE_CRYPT_H)
+CHECK_INCLUDE_FILES (dirent.h HAVE_DIRENT_H)
+CHECK_INCLUDE_FILES_UNIX (dlfcn.h HAVE_DLFCN_H)
+CHECK_INCLUDE_FILES_UNIX (execinfo.h HAVE_EXECINFO_H)
+CHECK_INCLUDE_FILES (fcntl.h HAVE_FCNTL_H)
+CHECK_INCLUDE_FILES (fenv.h HAVE_FENV_H)
+CHECK_INCLUDE_FILES (float.h HAVE_FLOAT_H)
+CHECK_INCLUDE_FILES_UNIX (floatingpoint.h HAVE_FLOATINGPOINT_H)
+CHECK_INCLUDE_FILES_UNIX (fpu_control.h HAVE_FPU_CONTROL_H)
+CHECK_INCLUDE_FILES_UNIX (grp.h HAVE_GRP_H)
+CHECK_INCLUDE_FILES_UNIX (ieeefp.h HAVE_IEEEFP_H)
+CHECK_INCLUDE_FILES (inttypes.h HAVE_INTTYPES_H)
+CHECK_INCLUDE_FILES_UNIX (langinfo.h HAVE_LANGINFO_H)
+CHECK_INCLUDE_FILES (limits.h HAVE_LIMITS_H)
+CHECK_INCLUDE_FILES (locale.h HAVE_LOCALE_H)
+CHECK_INCLUDE_FILES (malloc.h HAVE_MALLOC_H)
+CHECK_INCLUDE_FILES (memory.h HAVE_MEMORY_H)
+CHECK_INCLUDE_FILES_UNIX (netinet/in.h HAVE_NETINET_IN_H)
+CHECK_INCLUDE_FILES_UNIX (paths.h HAVE_PATHS_H)
+CHECK_INCLUDE_FILES_UNIX (port.h HAVE_PORT_H)
+CHECK_INCLUDE_FILES_UNIX (pwd.h HAVE_PWD_H)
+CHECK_INCLUDE_FILES_UNIX (sched.h HAVE_SCHED_H)
+CHECK_INCLUDE_FILES_UNIX (select.h HAVE_SELECT_H)
+CHECK_INCLUDE_FILES_UNIX (semaphore.h HAVE_SEMAPHORE_H)
+CHECK_INCLUDE_FILES_UNIX (sys/dir.h HAVE_SYS_DIR_H)
+CHECK_INCLUDE_FILES_UNIX (sys/pte.h HAVE_SYS_PTE_H)
+CHECK_INCLUDE_FILES_UNIX (sys/ptem.h HAVE_SYS_PTEM_H)
+CHECK_INCLUDE_FILES (stddef.h HAVE_STDDEF_H)
+CHECK_INCLUDE_FILES (stdint.h HAVE_STDINT_H)
+CHECK_INCLUDE_FILES (stdlib.h HAVE_STDLIB_H)
+CHECK_INCLUDE_FILES (strings.h HAVE_STRINGS_H)
+CHECK_INCLUDE_FILES (string.h HAVE_STRING_H)
+CHECK_INCLUDE_FILES_UNIX (synch.h HAVE_SYNCH_H)
+CHECK_INCLUDE_FILES_UNIX (sysent.h HAVE_SYSENT_H)
+CHECK_INCLUDE_FILES_UNIX (sys/cdefs.h HAVE_SYS_CDEFS_H)
+CHECK_INCLUDE_FILES_UNIX (sys/file.h HAVE_SYS_FILE_H)
+CHECK_INCLUDE_FILES_UNIX (sys/fpu.h HAVE_SYS_FPU_H)
+CHECK_INCLUDE_FILES_UNIX (sys/ioctl.h HAVE_SYS_IOCTL_H)
+CHECK_INCLUDE_FILES_UNIX (sys/ipc.h HAVE_SYS_IPC_H)
+CHECK_INCLUDE_FILES_UNIX (sys/malloc.h HAVE_SYS_MALLOC_H)
+CHECK_INCLUDE_FILES_UNIX (sys/mman.h HAVE_SYS_MMAN_H)
+CHECK_INCLUDE_FILES_UNIX (sys/prctl.h HAVE_SYS_PRCTL_H)
+CHECK_INCLUDE_FILES_UNIX (sys/resource.h HAVE_SYS_RESOURCE_H)
+CHECK_INCLUDE_FILES_UNIX (sys/select.h HAVE_SYS_SELECT_H)
+CHECK_INCLUDE_FILES_UNIX (sys/shm.h HAVE_SYS_SHM_H)
+CHECK_INCLUDE_FILES_UNIX (sys/socket.h HAVE_SYS_SOCKET_H)
+CHECK_INCLUDE_FILES (sys/stat.h HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILES_UNIX (sys/stream.h HAVE_SYS_STREAM_H)
+CHECK_INCLUDE_FILES_UNIX (sys/termcap.h HAVE_SYS_TERMCAP_H)
+CHECK_INCLUDE_FILES ("time.h;sys/timeb.h" HAVE_SYS_TIMEB_H)
+CHECK_INCLUDE_FILES_UNIX ("curses.h;term.h" HAVE_TERM_H)
+CHECK_INCLUDE_FILES_UNIX (termios.h HAVE_TERMIOS_H)
+CHECK_INCLUDE_FILES_UNIX (termio.h HAVE_TERMIO_H)
+CHECK_INCLUDE_FILES_UNIX (termcap.h HAVE_TERMCAP_H)
+CHECK_INCLUDE_FILES_UNIX (unistd.h HAVE_UNISTD_H)
+CHECK_INCLUDE_FILES (utime.h HAVE_UTIME_H)
+CHECK_INCLUDE_FILES (varargs.h HAVE_VARARGS_H)
+CHECK_INCLUDE_FILES (sys/time.h HAVE_SYS_TIME_H)
+CHECK_INCLUDE_FILES (sys/utime.h HAVE_SYS_UTIME_H)
+CHECK_INCLUDE_FILES_UNIX (sys/wait.h HAVE_SYS_WAIT_H)
+CHECK_INCLUDE_FILES_UNIX (sys/param.h HAVE_SYS_PARAM_H)
+CHECK_INCLUDE_FILES_UNIX (sys/vadvise.h HAVE_SYS_VADVISE_H)
+CHECK_INCLUDE_FILES_UNIX (fnmatch.h HAVE_FNMATCH_H)
+CHECK_INCLUDE_FILES (stdarg.h  HAVE_STDARG_H)
+
+# sys/un.h is broken on Linux and Solaris
+# It cannot be included alone ( it references types 
+# defined in stdlib.h, i.e size_t) 
+CHECK_C_SOURCE_COMPILES_UNIX("
+#include <stdlib.h>
+#include <sys/un.h>
+int main()
+{
+  return 0;
+}
+"
+HAVE_SYS_UN_H)
+
+#
+# Figure out threading library
+#
+FIND_PACKAGE (Threads)
+
+#
+# Tests for functions
+#
+#CHECK_FUNCTION_EXISTS (aiowait HAVE_AIOWAIT)
+CHECK_FUNCTION_EXISTS_UNIX (aio_read HAVE_AIO_READ)
+CHECK_FUNCTION_EXISTS_UNIX (alarm HAVE_ALARM)
+SET(HAVE_ALLOCA 1)
+CHECK_FUNCTION_EXISTS_UNIX (backtrace HAVE_BACKTRACE)
+CHECK_FUNCTION_EXISTS_UNIX (backtrace_symbols HAVE_BACKTRACE_SYMBOLS)
+CHECK_FUNCTION_EXISTS_UNIX (backtrace_symbols_fd HAVE_BACKTRACE_SYMBOLS_FD)
+CHECK_FUNCTION_EXISTS_UNIX (bcmp HAVE_BCMP)
+CHECK_FUNCTION_EXISTS_UNIX (bfill HAVE_BFILL)
+CHECK_FUNCTION_EXISTS_UNIX (bmove HAVE_BMOVE)
+CHECK_FUNCTION_EXISTS (bsearch HAVE_BSEARCH)
+CHECK_FUNCTION_EXISTS (index HAVE_INDEX)
+CHECK_FUNCTION_EXISTS_UNIX (bzero HAVE_BZERO)
+CHECK_FUNCTION_EXISTS_UNIX (clock_gettime HAVE_CLOCK_GETTIME)
+CHECK_FUNCTION_EXISTS_UNIX (cuserid HAVE_CUSERID)
+CHECK_FUNCTION_EXISTS_UNIX (directio HAVE_DIRECTIO)
+CHECK_FUNCTION_EXISTS_UNIX (_doprnt HAVE_DOPRNT)
+CHECK_FUNCTION_EXISTS_UNIX (flockfile HAVE_FLOCKFILE)
+CHECK_FUNCTION_EXISTS_UNIX (ftruncate HAVE_FTRUNCATE)
+CHECK_FUNCTION_EXISTS_UNIX (getline HAVE_GETLINE)
+CHECK_FUNCTION_EXISTS_UNIX (compress HAVE_COMPRESS)
+CHECK_FUNCTION_EXISTS_UNIX (crypt HAVE_CRYPT)
+CHECK_FUNCTION_EXISTS_UNIX (dlerror HAVE_DLERROR)
+CHECK_FUNCTION_EXISTS_UNIX (dlopen HAVE_DLOPEN)
+IF (CMAKE_COMPILER_IS_GNUCC)
+ IF (CMAKE_EXE_LINKER_FLAGS MATCHES " -static " 
+     OR CMAKE_EXE_LINKER_FLAGS MATCHES " -static$")
+   SET(HAVE_DLOPEN FALSE CACHE "Disable dlopen due to -static flag" FORCE)
+   SET(WITHOUT_DYNAMIC_PLUGINS TRUE)
+ ENDIF()
+ENDIF()
+CHECK_FUNCTION_EXISTS_UNIX (fchmod HAVE_FCHMOD)
+CHECK_FUNCTION_EXISTS_UNIX (fcntl HAVE_FCNTL)
+CHECK_FUNCTION_EXISTS_UNIX (fconvert HAVE_FCONVERT)
+CHECK_FUNCTION_EXISTS_UNIX (fdatasync HAVE_FDATASYNC)
+CHECK_FUNCTION_EXISTS_UNIX (fesetround HAVE_FESETROUND)
+CHECK_FUNCTION_EXISTS_UNIX (fpsetmask HAVE_FPSETMASK)
+CHECK_FUNCTION_EXISTS_UNIX (fseeko HAVE_FSEEKO)
+CHECK_FUNCTION_EXISTS_UNIX (fsync HAVE_FSYNC)
+CHECK_FUNCTION_EXISTS (getcwd HAVE_GETCWD)
+CHECK_FUNCTION_EXISTS_UNIX (gethostbyaddr_r HAVE_GETHOSTBYADDR_R)
+CHECK_FUNCTION_EXISTS_UNIX (gethostbyname_r HAVE_GETHOSTBYNAME_R)
+CHECK_FUNCTION_EXISTS_UNIX (gethrtime HAVE_GETHRTIME)
+CHECK_FUNCTION_EXISTS (getnameinfo HAVE_GETNAMEINFO)
+CHECK_FUNCTION_EXISTS_UNIX (getpass HAVE_GETPASS)
+CHECK_FUNCTION_EXISTS_UNIX (getpassphrase HAVE_GETPASSPHRASE)
+CHECK_FUNCTION_EXISTS_UNIX (getpwnam HAVE_GETPWNAM)
+CHECK_FUNCTION_EXISTS_UNIX (getpwuid HAVE_GETPWUID)
+CHECK_FUNCTION_EXISTS_UNIX (getrlimit HAVE_GETRLIMIT)
+CHECK_FUNCTION_EXISTS_UNIX (getrusage HAVE_GETRUSAGE)
+CHECK_FUNCTION_EXISTS_UNIX (getwd HAVE_GETWD)
+CHECK_FUNCTION_EXISTS_UNIX (gmtime_r HAVE_GMTIME_R)
+CHECK_FUNCTION_EXISTS_UNIX (initgroups HAVE_INITGROUPS)
+CHECK_FUNCTION_EXISTS_UNIX (issetugid HAVE_ISSETUGID)
+CHECK_FUNCTION_EXISTS (ldiv HAVE_LDIV)
+CHECK_FUNCTION_EXISTS_UNIX (localtime_r HAVE_LOCALTIME_R)
+CHECK_FUNCTION_EXISTS (longjmp HAVE_LONGJMP)
+CHECK_FUNCTION_EXISTS (lstat HAVE_LSTAT)
+CHECK_FUNCTION_EXISTS_UNIX (madvise HAVE_MADVISE)
+CHECK_FUNCTION_EXISTS_UNIX (mallinfo HAVE_MALLINFO)
+CHECK_FUNCTION_EXISTS (memcpy HAVE_MEMCPY)
+CHECK_FUNCTION_EXISTS (memmove HAVE_MEMMOVE)
+CHECK_FUNCTION_EXISTS (mkstemp HAVE_MKSTEMP)
+CHECK_FUNCTION_EXISTS_UNIX (mlock HAVE_MLOCK)
+CHECK_FUNCTION_EXISTS_UNIX (mlockall HAVE_MLOCKALL)
+CHECK_FUNCTION_EXISTS_UNIX (mmap HAVE_MMAP)
+CHECK_FUNCTION_EXISTS_UNIX (mmap64 HAVE_MMAP64)
+CHECK_FUNCTION_EXISTS (perror HAVE_PERROR)
+CHECK_FUNCTION_EXISTS_UNIX (poll HAVE_POLL)
+CHECK_FUNCTION_EXISTS_UNIX (port_create HAVE_PORT_CREATE)
+CHECK_FUNCTION_EXISTS_UNIX (posix_fallocate HAVE_POSIX_FALLOCATE)
+CHECK_FUNCTION_EXISTS_UNIX (pread HAVE_PREAD)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_attr_create HAVE_PTHREAD_ATTR_CREATE)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_attr_getstacksize HAVE_PTHREAD_ATTR_GETSTACKSIZE)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_attr_setprio HAVE_PTHREAD_ATTR_SETPRIO)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_attr_setschedparam
+                       HAVE_PTHREAD_ATTR_SETSCHEDPARAM)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_attr_setscope HAVE_PTHREAD_ATTR_SETSCOPE)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_attr_setstacksize HAVE_PTHREAD_ATTR_SETSTACKSIZE)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_condattr_create HAVE_PTHREAD_CONDATTR_CREATE)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_condattr_setclock HAVE_PTHREAD_CONDATTR_SETCLOCK)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_init HAVE_PTHREAD_INIT)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_key_delete HAVE_PTHREAD_KEY_DELETE)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_rwlock_rdlock HAVE_PTHREAD_RWLOCK_RDLOCK)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_setprio_np HAVE_PTHREAD_SETPRIO_NP)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_setschedparam HAVE_PTHREAD_SETSCHEDPARAM)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_sigmask HAVE_PTHREAD_SIGMASK)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_threadmask HAVE_PTHREAD_THREADMASK)
+CHECK_FUNCTION_EXISTS_UNIX (pthread_yield_np HAVE_PTHREAD_YIELD_NP)
+CHECK_FUNCTION_EXISTS (putenv HAVE_PUTENV)
+CHECK_FUNCTION_EXISTS_UNIX (readdir_r HAVE_READDIR_R)
+CHECK_FUNCTION_EXISTS_UNIX (readlink HAVE_READLINK)
+CHECK_FUNCTION_EXISTS_UNIX (re_comp HAVE_RE_COMP)
+CHECK_FUNCTION_EXISTS_UNIX (regcomp HAVE_REGCOMP)
+CHECK_FUNCTION_EXISTS_UNIX (realpath HAVE_REALPATH)
+CHECK_FUNCTION_EXISTS (rename HAVE_RENAME)
+CHECK_FUNCTION_EXISTS_UNIX (rwlock_init HAVE_RWLOCK_INIT)
+CHECK_FUNCTION_EXISTS_UNIX (sched_yield HAVE_SCHED_YIELD)
+CHECK_FUNCTION_EXISTS_UNIX (setenv HAVE_SETENV)
+CHECK_FUNCTION_EXISTS (setlocale HAVE_SETLOCALE)
+CHECK_FUNCTION_EXISTS_UNIX (setfd HAVE_SETFD)
+CHECK_FUNCTION_EXISTS_UNIX (sigaction HAVE_SIGACTION)
+CHECK_FUNCTION_EXISTS_UNIX (sigthreadmask HAVE_SIGTHREADMASK)
+CHECK_FUNCTION_EXISTS_UNIX (sigwait HAVE_SIGWAIT)
+CHECK_FUNCTION_EXISTS_UNIX (sigaddset HAVE_SIGADDSET)
+CHECK_FUNCTION_EXISTS_UNIX (sigemptyset HAVE_SIGEMPTYSET)
+CHECK_FUNCTION_EXISTS_UNIX (sighold HAVE_SIGHOLD) 
+CHECK_FUNCTION_EXISTS_UNIX (sigset HAVE_SIGSET)
+CHECK_FUNCTION_EXISTS_UNIX (sleep HAVE_SLEEP)
+CHECK_FUNCTION_EXISTS (snprintf HAVE_SNPRINTF)
+CHECK_FUNCTION_EXISTS_UNIX (stpcpy HAVE_STPCPY)
+CHECK_FUNCTION_EXISTS (strcoll HAVE_STRCOLL)
+CHECK_FUNCTION_EXISTS (strerror HAVE_STRERROR)
+CHECK_FUNCTION_EXISTS_UNIX (strlcpy HAVE_STRLCPY)
+CHECK_FUNCTION_EXISTS (strnlen HAVE_STRNLEN)
+CHECK_FUNCTION_EXISTS_UNIX (strlcat HAVE_STRLCAT)
+CHECK_FUNCTION_EXISTS_UNIX (strsignal HAVE_STRSIGNAL)
+CHECK_FUNCTION_EXISTS_UNIX (fgetln HAVE_FGETLN)
+CHECK_FUNCTION_EXISTS (strpbrk HAVE_STRPBRK)
+CHECK_FUNCTION_EXISTS (strsep HAVE_STRSEP)
+CHECK_FUNCTION_EXISTS (strstr HAVE_STRSTR)
+CHECK_FUNCTION_EXISTS_UNIX (strtok_r HAVE_STRTOK_R)
+CHECK_FUNCTION_EXISTS (strtol HAVE_STRTOL)
+CHECK_FUNCTION_EXISTS (strtoll HAVE_STRTOLL)
+CHECK_FUNCTION_EXISTS (strtoul HAVE_STRTOUL)
+CHECK_FUNCTION_EXISTS (strtoull HAVE_STRTOULL)
+CHECK_FUNCTION_EXISTS (strcasecmp HAVE_STRCASECMP)
+CHECK_FUNCTION_EXISTS (strncasecmp HAVE_STRNCASECMP)
+CHECK_FUNCTION_EXISTS (strdup HAVE_STRDUP)
+CHECK_FUNCTION_EXISTS_UNIX (shmat HAVE_SHMAT) 
+CHECK_FUNCTION_EXISTS_UNIX (shmctl HAVE_SHMCTL)
+CHECK_FUNCTION_EXISTS_UNIX (shmdt HAVE_SHMDT)
+CHECK_FUNCTION_EXISTS_UNIX (shmget HAVE_SHMGET)
+CHECK_FUNCTION_EXISTS (tell HAVE_TELL)
+CHECK_FUNCTION_EXISTS (tempnam HAVE_TEMPNAM)
+CHECK_FUNCTION_EXISTS_UNIX (thr_setconcurrency HAVE_THR_SETCONCURRENCY)
+CHECK_FUNCTION_EXISTS_UNIX (thr_yield HAVE_THR_YIELD)
+CHECK_FUNCTION_EXISTS_UNIX (vasprintf HAVE_VASPRINTF)
+CHECK_FUNCTION_EXISTS (vsnprintf HAVE_VSNPRINTF)
+CHECK_FUNCTION_EXISTS_UNIX (vprintf HAVE_VPRINTF)
+CHECK_FUNCTION_EXISTS_UNIX (valloc HAVE_VALLOC)
+CHECK_FUNCTION_EXISTS_UNIX (memalign HAVE_MEMALIGN)
+CHECK_FUNCTION_EXISTS_UNIX (chown HAVE_CHOWN)
+CHECK_FUNCTION_EXISTS_UNIX (nl_langinfo HAVE_NL_LANGINFO)
+
+
+#
+# Tests for symbols
+#
+INCLUDE (CheckSymbolExists)
+CHECK_SYMBOL_EXISTS_UNIX(sys_errlist "stdio.h" HAVE_SYS_ERRLIST)
+CHECK_SYMBOL_EXISTS_UNIX(madvise "sys/mman.h" HAVE_DECL_MADVISE)
+CHECK_SYMBOL_EXISTS_UNIX(tzname "time.h" HAVE_TZNAME)
+CHECK_SYMBOL_EXISTS(lrand48 "stdlib.h" HAVE_LRAND48)
+CHECK_SYMBOL_EXISTS_UNIX(getpagesize "unistd.h" HAVE_GETPAGESIZE)
+CHECK_SYMBOL_EXISTS_UNIX(TIOCGWINSZ "sys/ioctl.h" GWINSZ_IN_SYS_IOCTL)
+CHECK_SYMBOL_EXISTS_UNIX(FIONREAD "sys/ioctl.h" FIONREAD_IN_SYS_IOCTL)
+CHECK_SYMBOL_EXISTS_UNIX(TIOCSTAT "sys/ioctl.h" TIOCSTAT_IN_SYS_IOCTL)
+CHECK_SYMBOL_EXISTS(gettimeofday "sys/time.h" HAVE_GETTIMEOFDAY)
+
+CHECK_SYMBOL_EXISTS(finite  "math.h" HAVE_FINITE_IN_MATH_H)
+IF(HAVE_FINITE_IN_MATH_H)
+  SET(HAVE_FINITE TRUE CACHE INTERNAL "")
+ELSE()
+  CHECK_SYMBOL_EXISTS(finite  "ieeefp.h" HAVE_FINITE)
+ENDIF()
+CHECK_SYMBOL_EXISTS(log2 "math.h" HAVE_LOG2)
+
+
+
+#
+# Test for endianess
+#
+INCLUDE(TestBigEndian)
+IF(APPLE)
+  # Care for universal binary format
+  SET(WORDS_BIGENDIAN __BIG_ENDIAN CACHE INTERNAL "big endian test")
+ELSE()
+  TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
+ENDIF()
+
+#
+# Tests for type sizes (and presence)
+#
+INCLUDE (CheckTypeSize)
+set(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+        -D_LARGEFILE_SOURCE -D_LARGE_FILES -D_FILE_OFFSET_BITS=64
+        -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS)
+SET(CMAKE_EXTRA_INCLUDE_FILES signal.h)
+CHECK_TYPE_SIZE(sigset_t SIZEOF_SIGSET_T)
+IF(SIZEOF_SIGSET_T)
+  SET(HAVE_SIGSET_T 1) 
+ENDIF()
+IF(NOT SIZEOF_SIGSET_T)
+ SET(sigset_t int)
+ENDIF()
+CHECK_TYPE_SIZE(mode_t SIZEOF_MODE_T)
+IF(NOT SIZEOF_MODE_T)
+ SET(mode_t int)
+ENDIF()
+
+
+IF(HAVE_STDINT_H)
+  SET(CMAKE_EXTRA_INCLUDE_FILES stdint.h)
+ENDIF(HAVE_STDINT_H)
+CHECK_TYPE_SIZE(char SIZEOF_CHAR)
+CHECK_TYPE_SIZE("char *" SIZEOF_CHARP)
+CHECK_TYPE_SIZE(short SIZEOF_SHORT)
+CHECK_TYPE_SIZE(int SIZEOF_INT)
+CHECK_TYPE_SIZE(long SIZEOF_LONG)
+CHECK_TYPE_SIZE("long long" SIZEOF_LONG_LONG)
+SET(CMAKE_EXTRA_INCLUDE_FILES stdio.h)
+CHECK_TYPE_SIZE(size_t SIZEOF_SIZE_T)
+SET(CMAKE_EXTRA_INCLUDE_FILES sys/types.h)
+CHECK_TYPE_SIZE(off_t SIZEOF_OFF_T)
+CHECK_TYPE_SIZE(uchar SIZEOF_UCHAR)
+CHECK_TYPE_SIZE(uint SIZEOF_UINT)
+CHECK_TYPE_SIZE(ulong SIZEOF_ULONG)
+CHECK_TYPE_SIZE(int8 SIZEOF_INT8)
+CHECK_TYPE_SIZE(uint8 SIZEOF_UINT8)
+CHECK_TYPE_SIZE(int16 SIZEOF_INT16)
+CHECK_TYPE_SIZE(uint16 SIZEOF_UINT16)
+CHECK_TYPE_SIZE(int32 SIZEOF_INT32)
+CHECK_TYPE_SIZE(uint32 SIZEOF_UINT32)
+CHECK_TYPE_SIZE(u_int32_t SIZEOF_U_INT32_T)
+CHECK_TYPE_SIZE(int64 SIZEOF_INT64)
+CHECK_TYPE_SIZE(uint64 SIZEOF_UINT64)
+SET (CMAKE_EXTRA_INCLUDE_FILES sys/types.h)
+CHECK_TYPE_SIZE(bool  SIZEOF_BOOL)
+SET(CMAKE_EXTRA_INCLUDE_FILES)
+IF(HAVE_SYS_SOCKET_H)
+  SET(CMAKE_EXTRA_INCLUDE_FILES sys/socket.h)
+ENDIF(HAVE_SYS_SOCKET_H)
+CHECK_TYPE_SIZE(socklen_t SIZEOF_SOCKLEN_T)
+SET(CMAKE_EXTRA_INCLUDE_FILES)
+
+IF(HAVE_IEEEFP_H)
+  SET(CMAKE_EXTRA_INCLUDE_FILES ieeefp.h)
+  CHECK_TYPE_SIZE(fp_except SIZEOF_FP_EXCEPT)
+  IF(SIZEOF_FP_EXCEPT)
+    SET(HAVE_FP_EXCEPT TRUE)
+  ENDIF() 
+ENDIF()
+
+
+#
+# Code tests
+#
+
+CHECK_C_SOURCE_COMPILES("
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#endif
+int main()
+{
+  getaddrinfo( 0, 0, 0, 0);
+  return 0;
+}"
+HAVE_GETADDRINFO)
+
+CHECK_C_SOURCE_COMPILES("
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#endif
+int main()
+{
+  select(0,0,0,0,0);
+  return 0;
+}"
+HAVE_SELECT)
+
+#
+# Check if timespec has ts_sec and ts_nsec fields
+#
+
+CHECK_C_SOURCE_COMPILES_UNIX("
+#include <pthread.h>
+
+int main(int ac, char **av)
+{
+  struct timespec abstime;
+  abstime.ts_sec = time(NULL)+1;
+  abstime.ts_nsec = 0;
+}
+" HAVE_TIMESPEC_TS_SEC)
+
+
+#
+# Check return type of qsort()
+#
+CHECK_C_SOURCE_COMPILES("
+#include <stdlib.h>
+#ifdef __cplusplus
+extern \"C\"
+#endif
+void qsort(void *base, size_t nel, size_t width,
+  int (*compar) (const void *, const void *));
+int main(int ac, char **av) {}
+" QSORT_TYPE_IS_VOID)
+IF(QSORT_TYPE_IS_VOID)
+  SET(RETQSORTTYPE "void")
+ELSE(QSORT_TYPE_IS_VOID)
+  SET(RETQSORTTYPE "int")
+ENDIF(QSORT_TYPE_IS_VOID)
+
+IF(WIN32)
+SET(SOCKET_SIZE_TYPE int)
+ELSE()
+CHECK_CXX_SOURCE_COMPILES("
+#include <sys/socket.h>
+int main(int argc, char **argv)
+{
+  getsockname(0,0,(socklen_t *) 0);
+  return 0; 
+}"
+HAVE_SOCKET_SIZE_T_AS_socklen_t)
+
+IF(HAVE_SOCKET_SIZE_T_AS_socklen_t)
+  SET(SOCKET_SIZE_TYPE socklen_t)
+ELSE()
+  CHECK_CXX_SOURCE_COMPILES("
+  #include <sys/socket.h>
+  int main(int argc, char **argv)
+  {
+    getsockname(0,0,(int *) 0);
+    return 0; 
+  }"
+  HAVE_SOCKET_SIZE_T_AS_int)
+  IF(HAVE_SOCKET_SIZE_T_AS_int)
+    SET(SOCKET_SIZE_TYPE int)
+  ELSE()
+    CHECK_CXX_SOURCE_COMPILES("
+    #include <sys/socket.h>
+    int main(int argc, char **argv)
+    {
+      getsockname(0,0,(size_t *) 0);
+      return 0; 
+    }"
+    HAVE_SOCKET_SIZE_T_AS_size_t)
+    IF(HAVE_SOCKET_SIZE_T_AS_size_t)
+      SET(SOCKET_SIZE_TYPE size_t)
+    ELSE()
+      SET(SOCKET_SIZE_TYPE int)
+    ENDIF()
+  ENDIF()
+ENDIF()
+ENDIF()
+
+CHECK_CXX_SOURCE_COMPILES_UNIX("
+#include <pthread.h>
+int main()
+{
+  pthread_yield();
+  return 0;
+}
+" HAVE_PTHREAD_YIELD_ZERO_ARG)
+
+IF(NOT STACK_DIRECTION)
+  IF(CMAKE_CROSSCOMPILING)
+   MESSAGE(FATAL_ERROR 
+   "STACK_DIRECTION is not defined.  Please specify -DSTACK_DIRECTION=1 "
+   "or -DSTACK_DIRECTION=-1 when calling cmake.")
+  ELSE()
+    TRY_RUN(STACKDIR_RUN_RESULT STACKDIR_COMPILE_RESULT    
+     ${CMAKE_BINARY_DIR} 
+     ${CMAKE_SOURCE_DIR}/cmake/stack_direction.c
+     )
+     # Test program returns 0 (down) or 1 (up).
+     # Convert to -1 or 1
+     IF(STACKDIR_RUN_RESULT EQUAL 0)
+       SET(STACK_DIRECTION -1 CACHE INTERNAL "Stack grows direction")
+     ELSE()
+       SET(STACK_DIRECTION 1 CACHE INTERNAL "Stack grows direction")
+     ENDIF()
+     MESSAGE(STATUS "Checking stack grows direction : ${STACK_DIRECTION}")
+   ENDIF()
+ENDIF()
+
+#
+# Check return type of signal handlers
+#
+CHECK_C_SOURCE_COMPILES("
+#include <signal.h>
+#ifdef signal
+# undef signal
+#endif
+#ifdef __cplusplus
+extern \"C\" void (*signal (int, void (*)(int)))(int);
+#else
+void (*signal ()) ();
+#endif
+int main(int ac, char **av) {}
+" SIGNAL_RETURN_TYPE_IS_VOID)
+IF(SIGNAL_RETURN_TYPE_IS_VOID)
+  SET(RETSIGTYPE void)
+ELSE(SIGNAL_RETURN_TYPE_IS_VOID)
+  SET(RETSIGTYPE int)
+ENDIF(SIGNAL_RETURN_TYPE_IS_VOID)
+
+#
+# isnan() is trickier than the usual function test -- it may be a macro
+#
+CHECK_CXX_SOURCE_COMPILES("#include <math.h>
+  int main(int ac, char **av)
+  {
+    isnan(0.0);
+    return 0;
+  }"
+  HAVE_ISNAN)
+
+#
+# isinf() is trickier than the usual function test -- it may be a macro
+#
+CHECK_CXX_SOURCE_COMPILES("#include <math.h>
+  int main(int ac, char **av)
+  {
+    isinf(0.0);
+    return 0;
+  }"
+  HAVE_ISINF)
+#
+# rint() is trickier than the usual function test -- it may be a macro
+#
+CHECK_CXX_SOURCE_COMPILES("#include <math.h>
+  int main(int ac, char **av)
+  {
+    rint(0.0);
+    return 0;
+  }"
+  HAVE_RINT)
+
+CHECK_CXX_SOURCE_COMPILES("
+    #include <time.h>
+    #include <sys/time.h>
+    int main()
+    {
+      return 0;
+    }"
+    TIME_WITH_SYS_TIME)
+
+IF(UNIX)
+CHECK_C_SOURCE_COMPILES("
+#include <unistd.h>
+#include <fcntl.h>
+int main()
+{
+  fcntl(0, F_SETFL, O_NONBLOCK);
+  return 0;
+}
+"
+HAVE_FCNTL_NONBLOCK)
+ENDIF()
+
+IF(NOT HAVE_FCNTL_NONBLOCK)
+ SET(NO_FCNTL_NONBLOCK 1)
+ENDIF()
+
+#
+# Test for how the C compiler does inline, if at all
+#
+CHECK_C_SOURCE_COMPILES("
+static inline int foo(){return 0;}
+int main(int argc, char *argv[]){return 0;}"
+                            C_HAS_inline)
+IF(NOT C_HAS_inline)
+  CHECK_C_SOURCE_COMPILES("
+  static __inline int foo(){return 0;}
+  int main(int argc, char *argv[]){return 0;}"
+                            C_HAS___inline)
+  SET(C_INLINE __inline)
+ENDIF()
+
+IF(NOT CMAKE_CROSSCOMPILING AND NOT MSVC)
+  STRING(TOLOWER ${CMAKE_SYSTEM_PROCESSOR}  processor)
+  IF(processor MATCHES "86" OR processor MATCHES "amd64" OR processor MATCHES "x64")
+  #Check for x86 PAUSE instruction
+  # We have to actually try running the test program, because of a bug
+  # in Solaris on x86_64, where it wrongly reports that PAUSE is not
+  # supported when trying to run an application.  See
+  # http://bugs.opensolaris.org/bugdatabase/printableBug.do?bug_id=6478684
+  CHECK_C_SOURCE_RUNS("
+  int main()
+  { 
+    __asm__ __volatile__ (\"pause\"); 
+    return 0;
+  }"  HAVE_PAUSE_INSTRUCTION)
+  ENDIF()
+  IF (NOT HAVE_PAUSE_INSTRUCTION)
+    CHECK_C_SOURCE_COMPILES("
+    int main()
+    {
+     __asm__ __volatile__ (\"rep; nop\");
+     return 0;
+    }
+   " HAVE_FAKE_PAUSE_INSTRUCTION)
+  ENDIF()
+ENDIF()
+
+
+
+  
+CHECK_SYMBOL_EXISTS_UNIX(tcgetattr "termios.h" HAVE_TCGETATTR 1)
+CHECK_INCLUDE_FILES_UNIX(sys/ioctl.h HAVE_SYS_IOCTL 1)
+
+
+#
+# Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
+#
+CHECK_C_SOURCE_COMPILES_UNIX("
+  #include <signal.h>
+  int main(int ac, char **av)
+  {
+    sigset_t ss;
+    struct sigaction sa;
+    sigemptyset(&ss); sigsuspend(&ss);
+    sigaction(SIGINT, &sa, (struct sigaction *) 0);
+    sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
+  }"
+  HAVE_POSIX_SIGNALS)
+
+IF(NOT HAVE_POSIX_SIGNALS)
+ CHECK_C_SOURCE_COMPILES_UNIX("
+  #include <signal.h>
+  int main(int ac, char **av)
+  {
+    int mask = sigmask(SIGINT);
+    sigsetmask(mask); sigblock(mask); sigpause(mask);
+  }"
+  HAVE_BSD_SIGNALS)
+  IF (NOT HAVE_BSD_SIGNALS)
+    CHECK_C_SOURCE_COMPILES_UNIX("
+    #include <signal.h>
+    void foo() { }
+    int main(int ac, char **av)
+    {
+      int mask = sigmask(SIGINT);
+      sigset(SIGINT, foo); sigrelse(SIGINT);
+      sighold(SIGINT); sigpause(SIGINT);
+    }"
+   HAVE_SVR3_SIGNALS)  
+   IF (NOT HAVE_SVR3_SIGNALS)
+    SET(HAVE_V7_SIGNALS 1)
+   ENDIF(NOT HAVE_SVR3_SIGNALS)
+ ENDIF(NOT HAVE_BSD_SIGNALS)
+ENDIF(NOT HAVE_POSIX_SIGNALS)
+
+# Assume regular sprintf
+SET(SPRINTFS_RETURNS_INT 1)
+
+IF(CMAKE_COMPILER_IS_GNUXX)
+CHECK_CXX_SOURCE_COMPILES("
+ #include <cxxabi.h>
+ int main(int argc, char **argv) 
+  {
+    char *foo= 0; int bar= 0;
+    foo= abi::__cxa_demangle(foo, foo, 0, &bar);
+    return 0;
+  }"
+  HAVE_ABI_CXA_DEMANGLE)
+IF(HAVE_ABI_CXA_DEMANGLE)
+ SET(HAVE_CXXABI_H 1)
+ENDIF()
+ENDIF()
+
+CHECK_C_SOURCE_COMPILES_UNIX("
+  int main(int argc, char **argv) 
+  {
+    extern char *__bss_start;
+    return __bss_start ? 1 : 0;
+  }"
+HAVE_BSS_START)
+
+CHECK_C_SOURCE_COMPILES_UNIX("
+    int main()
+    {
+      extern void __attribute__((weak)) foo(void);
+      return 0;
+    }"
+    HAVE_WEAK_SYMBOL
+)
+
+
+CHECK_CXX_SOURCE_COMPILES("
+    #include <new>
+    int main()
+    {
+      char *c = new char;
+      return 0;
+    }"
+    HAVE_CXX_NEW
+)
+
+CHECK_CXX_SOURCE_COMPILES_UNIX("
+    #undef inline
+    #if !defined(SCO) && !defined(__osf__) && !defined(_REENTRANT)
+    #define _REENTRANT
+    #endif
+    #include <pthread.h>
+    #include <sys/types.h>
+    #include <sys/socket.h>
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+    #include <netdb.h>
+    int main()
+    {
+
+       struct hostent *foo =
+	  gethostbyaddr_r((const char *) 0,
+			  0, 0, (struct hostent *) 0, (char *) NULL,  0, (int *)0);
+       return 0;
+    }
+  "
+  HAVE_SOLARIS_STYLE_GETHOST)
+
+CHECK_CXX_SOURCE_COMPILES_UNIX("
+    #undef inline
+    #if !defined(SCO) && !defined(__osf__) && !defined(_REENTRANT)
+    #define _REENTRANT
+    #endif
+    #include <pthread.h>
+    #include <sys/types.h>
+    #include <sys/socket.h>
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+    #include <netdb.h>
+    int main()
+    {
+       int ret = gethostbyname_r((const char *) 0,
+	(struct hostent*) 0, (char*) 0, 0, (struct hostent **) 0, (int *) 0);
+      return 0;
+    }"
+    HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE)
+
+CHECK_CXX_SOURCE_COMPILES_UNIX("
+    #undef inline
+    #if !defined(SCO) && !defined(__osf__) && !defined(_REENTRANT)
+    #define _REENTRANT
+    #endif
+    #include <pthread.h>
+    #include <sys/types.h>
+    #include <sys/socket.h>
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+    #include <netdb.h>
+    int main()
+    {
+      int ret = gethostbyname_r((const char *) 0, (struct hostent*) 0, (struct hostent_data*) 0);
+      return 0;
+    }"
+    HAVE_GETHOSTBYNAME_R_RETURN_INT)
+
+IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+ CHECK_SYMBOL_EXISTS(SHM_HUGETLB sys/shm.h  HAVE_DECL_SHM_HUGETLB)
+ IF(HAVE_DECL_SHM_HUGETLB)
+   SET(HAVE_LARGE_PAGES 1)
+   SET(HUGETLB_USE_PROC_MEMINFO 1)
+   SET(HAVE_LARGE_PAGE_OPTION 1)
+  ENDIF()
+ENDIF()
+
+IF(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+ CHECK_SYMBOL_EXISTS(MHA_MAPSIZE_VA sys/mman.h  HAVE_DECL_MHA_MAPSIZE_VA)
+ IF(HAVE_DECL_MHA_MAPSIZE_VA)
+   SET(HAVE_SOLARIS_LARGE_PAGES 1)
+   SET(HAVE_LARGE_PAGE_OPTION 1)
+  ENDIF()
+ENDIF()
+
+IF(CMAKE_SYSTEM_NAME STREQUAL "AIX" OR CMAKE_SYSTEM_NAME STREQUAL "OS400")
+  # xlC oddity - it complains about same inline function defined multiple times
+  # in different compilation units
+  INCLUDE(CheckCXXCompilerFlag)
+  CHECK_CXX_COMPILER_FLAG("-qstaticinline" HAVE_QSTATICINLINE)
+  IF(HAVE_QSTATICINLINE)
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -qstaticinline")
+  ENDIF()
+
+  # The following is required to export all symbols (also with leading underscore
+  # from libraries and mysqld
+  STRING(REPLACE  "-bexpall" "-bexpfull" CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS
+          ${CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS})
+  STRING(REPLACE  "-bexpall" "-bexpfull" CMAKE_SHARED_LIBRARY_LINK_C_FLAGS
+          ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS})
+ENDIF()
+
+IF(CMAKE_COMPILER_IS_GNUCXX)
+IF(WITH_ATOMIC_OPS STREQUAL "up")
+  SET(MY_ATOMIC_MODE_DUMMY 1 CACHE BOOL "Assume single-CPU mode, no concurrency")
+ELSEIF(WITH_ATOMIC_OPS STREQUAL "rwlocks")
+  SET(MY_ATOMIC_MODE_RWLOCK 1 CACHE BOOL "Use pthread rwlocks for atomic ops")
+ELSEIF(WITH_ATOMIC_OPS STREQUAL "smp")
+ELSEIF(NOT WITH_ATOMIC_OPS)
+  CHECK_CXX_SOURCE_COMPILES("
+  int main()
+  {
+    int foo= -10;
+    int bar=  10;
+    if (!__sync_fetch_and_add(&foo, bar) || foo)
+      return -1;
+    bar= __sync_lock_test_and_set(&foo, bar);
+    if (bar || foo != 10)
+     return -1;
+    bar= __sync_val_compare_and_swap(&bar, foo, 15);
+    if (bar)
+      return -1;
+    return 0;
+  }"
+  HAVE_GCC_ATOMIC_BUILTINS)
+ELSE()
+  MESSAGE(FATAL_ERROR "${WITH_ATOMIC_OPS} is not a valid value for WITH_ATOMIC_OPS!")
+ENDIF()
+ENDIF()
+
+SET(WITH_ATOMIC_LOCKS "${WITH_ATOMIC_LOCKS}" CACHE STRING
+"Implement atomic operations using pthread rwlocks or atomic CPU
+instructions for multi-processor or uniprocessor
+configuration. By default gcc built-in sync functions are used,
+if available and 'smp' configuration otherwise.")
+MARK_AS_ADVANCED(WITH_ATOMIC_LOCKS MY_ATOMIC_MODE_RWLOCK MY_ATOMIC_MODE_DUMMY)
+
+IF(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+ CHECK_C_SOURCE_RUNS(
+ "
+ #include  <atomic.h>
+  int main()
+  {
+	int foo = -10; int bar = 10;
+	if (atomic_add_int_nv((uint_t *)&foo, bar) || foo)
+		return -1;
+	bar = atomic_swap_uint((uint_t *)&foo, (uint_t)bar);
+	if (bar || foo != 10)
+		return -1;
+	bar = atomic_cas_uint((uint_t *)&bar, (uint_t)foo, 15);
+	if (bar)
+		return -1;
+	return 0;
+	}
+"  HAVE_SOLARIS_ATOMIC)
+ENDIF()
+
+#--------------------------------------------------------------------
+# Check for IPv6 support
+#--------------------------------------------------------------------
+CHECK_INCLUDE_FILE(netinet/in6.h HAVE_NETINET_IN6_H)
+
+IF(UNIX)
+  SET(CMAKE_EXTRA_INCLUDE_FILES sys/types.h netinet/in.h sys/socket.h)
+  IF(HAVE_NETINET_IN6_H)
+    SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} netinet/in6.h)
+  ENDIF()
+ELSEIF(WIN32)
+  SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} winsock2.h ws2ipdef.h)
+ENDIF()
+
+CHECK_TYPE_SIZE("struct sockaddr_in6" SIZEOF_SOCKADDR_IN6)
+CHECK_TYPE_SIZE("struct in6_addr" SIZEOF_IN6_ADDR)
+IF(SIZEOF_SOCKADDR_IN6)
+  SET(HAVE_STRUCT_SOCKADDR_IN6 1)
+ENDIF()
+IF(SIZEOF_IN6_ADDR)
+  SET(HAVE_STRUCT_IN6_ADDR 1)
+ENDIF()
+
+IF(HAVE_STRUCT_SOCKADDR_IN6 OR HAVE_STRUCT_IN6_ADDR)
+  SET(HAVE_IPV6 TRUE CACHE INTERNAL "")
+ENDIF()
+
+
+# Check for sockaddr_storage.ss_family
+# It is called differently under OS400 and older AIX
+
+CHECK_STRUCT_HAS_MEMBER("struct sockaddr_storage"
+ ss_family "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_SOCKADDR_STORAGE_SS_FAMILY)
+IF(NOT HAVE_SOCKADDR_STORAGE_SS_FAMILY)
+  CHECK_STRUCT_HAS_MEMBER("struct sockaddr_storage"
+  __ss_family "${CMAKE_EXTRA_INCLUDE_FILES}" HAVE_SOCKADDR_STORAGE___SS_FAMILY)
+  IF(HAVE_SOCKADDR_STORAGE___SS_FAMILY)
+    SET(ss_family __ss_family)
+  ENDIF()
+ENDIF()
+SET(CMAKE_EXTRA_INCLUDE_FILES) 
+
+CHECK_STRUCT_HAS_MEMBER("struct dirent" d_ino "dirent.h"  STRUCT_DIRENT_HAS_D_INO)
+CHECK_STRUCT_HAS_MEMBER("struct dirent" d_namlen "dirent.h"  STRUCT_DIRENT_HAS_D_NAMLEN)
+SET(SPRINTF_RETURNS_INT 1)
+
+IF(WIN32)
+  SET(SIGNAL_WITH_VIO_CLOSE 1)
+  CHECK_SYMBOL_REPLACEMENT(S_IROTH _S_IREAD sys/stat.h)
+  CHECK_SYMBOL_REPLACEMENT(S_IFIFO _S_IFIFO sys/stat.h)
+  CHECK_SYMBOL_REPLACEMENT(SIGQUIT SIGTERM signal.h)
+  CHECK_SYMBOL_REPLACEMENT(SIGPIPE SIGINT signal.h)
+  CHECK_SYMBOL_REPLACEMENT(isnan _isnan float.h)
+  CHECK_SYMBOL_REPLACEMENT(finite _finite float.h)
+  CHECK_FUNCTION_REPLACEMENT(popen _popen)
+  CHECK_FUNCTION_REPLACEMENT(pclose _pclose)
+  CHECK_FUNCTION_REPLACEMENT(access _access)
+  CHECK_FUNCTION_REPLACEMENT(strcasecmp _stricmp)
+  CHECK_FUNCTION_REPLACEMENT(strncasecmp _strnicmp)
+  CHECK_FUNCTION_REPLACEMENT(snprintf _snprintf)
+  CHECK_FUNCTION_REPLACEMENT(strtok_r strtok_s)
+  CHECK_FUNCTION_REPLACEMENT(strtoll _strtoi64)
+  CHECK_FUNCTION_REPLACEMENT(strtoull _strtoui64)
+  CHECK_TYPE_SIZE(ssize_t SIZE_OF_SSIZE_T)
+  IF(NOT SIZE_OF_SSIZE_T)
+    SET(ssize_t SSIZE_T)
+  ENDIF()
+
+
+  # IPv6 definition (appeared in Vista SDK first)
+  CHECK_C_SOURCE_COMPILES("
+  #include <winsock2.h>
+  int main()
+  {
+    return IPPROTO_IPV6;
+  }"
+  HAVE_IPPROTO_IPV6)
+  
+  CHECK_C_SOURCE_COMPILES("
+  #include <winsock2.h>
+  #include <ws2ipdef.h>
+  int main()
+  {
+    return IPV6_V6ONLY;
+  }"
+  HAVE_IPV6_V6ONLY)
+
+  IF(NOT HAVE_IPPROTO_IPV6)
+    SET(HAVE_IPPROTO_IPV6 41)
+  ENDIF()
+  IF(NOT HAVE_IPV6_V6ONLY)
+    SET(IPV6_V6ONLY 27)
+  ENDIF()
+
+ENDIF(WIN32)
+
+