~drizzle-trunk/drizzle/development

dnl -*- bash -*-

dnl Process this file with autoconf to produce a configure script.

AC_PREREQ(2.59)dnl		Minimum Autoconf version required.

m4_include(m4/bzr_version.m4)

AC_CONFIG_SRCDIR([drizzled/drizzled.cc])

AC_CONFIG_AUX_DIR(config)

AC_CONFIG_HEADERS([config.h])

AC_CONFIG_MACRO_DIR([m4])

# Setting CFLAGS here prevents AC_CANONICAL_TARGET from injecting them

SAVE_CFLAGS=${CFLAGS}

SAVE_CXXFLAGS=${CXXFLAGS}

CFLAGS=

CXXFLAGS=

AC_CANONICAL_TARGET

CFLAGS=${SAVE_CFLAGS}

CXXFLAGS=${SAVE_CXXFLAGS}

AM_INIT_AUTOMAKE(nostdinc subdir-objects -Wall -Werror)

if test "x${enable_dependency_tracking}" = "x"

then

  enable_dependency_tracking=yes

fi

gl_EARLY

# See the libtool docs for information on how to do shared lib versions.

SHARED_LIB_MAJOR_VERSION=1

SHARED_LIB_VERSION=$SHARED_LIB_MAJOR_VERSION:0:0

AC_SUBST(SHARED_LIB_MAJOR_VERSION)

AC_SUBST(SHARED_LIB_VERSION)

dnl Checks for programs.

AC_PROG_CXX

gl_USE_SYSTEM_EXTENSIONS

if test "$GCC" = "yes"

then

  # If you're on a Mac, and you didn't ask for a specific compiler

  # You're gonna get 4.2.

  if test "$host_vendor" = "apple" -a "x${ac_cv_env_CC_set}" = "x"

  then

    CPP="/usr/bin/gcc-4.2 -E"

    CC=/usr/bin/gcc-4.2

    CXX=/usr/bin/g++-4.2

  fi

  AC_CACHE_CHECK([if GCC is recent enough], [drizzle_cv_gcc_recent],

    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#if !defined(__GNUC__) || (__GNUC__ < 4) || ((__GNUC__ >= 4) && (__GNUC_MINOR__ < 1))

# error GCC is Too Old!

#endif

      ]])],

      [drizzle_cv_gcc_recent=yes],

      [drizzle_cv_gcc_recent=no])])

  if test "$drizzle_cv_gcc_recent" = "no"

  then

    AC_MSG_ERROR([Your version of GCC is too old. Drizzle requires at least version 4.1. If you are on OSX, you may need to specify ./configure CC=gcc-4.2 CXX=g++4.2])

  fi

fi

AC_CXX_HEADER_STDCXX_98

if test "$ac_cv_cxx_stdcxx_98" = "no"

then

  AC_MSG_ERROR([No working C++ Compiler has been found. Drizzle requires a C++ compiler that can handle C++98])

fi

AC_PROG_CPP

AM_PROG_CC_C_O

if test "$am_cv_prog_cc_stdc" = "no"

then

  AC_MSG_ERROR([Drizzle requires an ANSI C compiler (and a C++ compiler). Try gcc. See the Installation chapter in the Reference Manual.])

fi

gl_INIT

AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"])

AC_PROG_GCC_TRADITIONAL

# Set all version vars based on $VERSION. How do we do this more elegant ?

# Remember that regexps needs to quote [ and ] since this is run through m4

# We take some made up examples

#

#  VERSION                  5.1.40sp1-alpha     5.0.34a

#  DRIZZLE_NO_DASH_VERSION    5.1.40sp1           5.0.34a

#  DRIZZLE_NUMERIC_VERSION    5.1.40              5.0.34

#  DRIZZLE_BASE_VERSION       5.1                 5.0

#  DRIZZLE_VERSION_ID         50140               50034

#

DRIZZLE_NO_DASH_VERSION=`echo $VERSION | sed -e "s|-.*$||"`

DRIZZLE_NUMERIC_VERSION=`echo $DRIZZLE_NO_DASH_VERSION | sed -e "s|[[a-z]][[a-z0-9]]*$||"`

DRIZZLE_BASE_VERSION=`echo $DRIZZLE_NUMERIC_VERSION | sed -e "s|\.[[^.]]*$||"`

DRIZZLE_VERSION_ID=`echo $DRIZZLE_NUMERIC_VERSION | \

    awk -F. '{printf "%d%0.2d%0.2d", $1, $2, $3}'`

AC_DEFINE_UNQUOTED(DRIZZLE_BASE_VERSION,["$DRIZZLE_BASE_VERSION"],

                   [Major and minor version])

AC_DEFINE_UNQUOTED([DRIZZLE_VERSION_ID],[$DRIZZLE_VERSION_ID],

		   [Version ID that can be easily used for numeric comparison])

AC_DEFINE([_BACKWARD_BACKWARD_WARNING_H],[1],[Hack to disable deprecation warning in gcc])

# The port should be constant for a LONG time

DRIZZLE_TCP_PORT_DEFAULT=4427

m4_include(m4/dtrace.m4)

m4_include(m4/character_sets.m4)

AC_SUBST(AVAILABLE_LANGUAGES)

# Set this for plugins to use

ac_build_drizzle="yes"

# Canonicalize the configuration name.

# Check whether --with-system-type or --without-system-type was given.

AC_ARG_WITH([system-type],

    [AS_HELP_STRING([--with-system-type],

       [Set the system type, like "sun-solaris10"])],

    [SYSTEM_TYPE="$withval"],

    [SYSTEM_TYPE="$host_vendor-$host_os"])

AC_ARG_WITH([machine-type],

    [AS_HELP_STRING([--with-machine-type],

       [Set the machine type, like "sparc"])],

    [MACHINE_TYPE="$withval"],

    [MACHINE_TYPE="$host_cpu"])

AC_SUBST(SYSTEM_TYPE)

AC_DEFINE_UNQUOTED([SYSTEM_TYPE], ["$SYSTEM_TYPE"],

                   [Name of system, eg sun-solaris])

AC_SUBST(MACHINE_TYPE)

AC_DEFINE_UNQUOTED([MACHINE_TYPE], ["$MACHINE_TYPE"],

                   [Machine type name, eg sparc])

# Detect intel x86 like processor

BASE_MACHINE_TYPE=$MACHINE_TYPE

case $MACHINE_TYPE in

  i?86) BASE_MACHINE_TYPE=i386 ;;

esac

case "$target_os" in

  *linux*)

  TARGET_LINUX="true"

  AC_SUBST(TARGET_LINUX)

  AC_DEFINE([TARGET_OS_LINUX], [1], [Whether we build for Linux])

    ;;

  *apple-darwin*)

    TARGET_OSX="true"

    AC_SUBST(TARGET_OSX)

    AC_DEFINE([TARGET_OS_OSX], [1], [Whether we build for OSX])

    ;;

  *solaris*)

    TARGET_SOLARIS="true"

    AC_SUBST(TARGET_SOLARIS)

    AC_DEFINE([TARGET_OS_SOLARIS], [1], [Whether we are building for Solaris])

    ;;

  *)

    ;;

esac

DRIZZLE_CHECK_C_VERSION

DRIZZLE_CHECK_CXX_VERSION

AC_SYS_LARGEFILE

AC_PROG_AWK

AC_PATH_PROG(GPERF, gperf)

AS_IF([test "x$GPERF" = "x"],

      AC_MSG_ERROR("Drizzle requires gperf to build."))

AC_PATH_PROG(LCOV, lcov)

AC_PATH_PROG(GENHTML, genhtml)

AM_CONDITIONAL(HAVE_LCOV,[test "x$LCOV" != "x"])

dnl TODO: This needs to go away and be replaced with _ISOC99_SOURCE

if test "$ac_cv_c_compiler_gnu" = "yes" -o "$target_os" = "linux-gnu"

then

  AC_DEFINE([_GNU_SOURCE],[1],[Fix problem with S_ISLNK() on Linux])

fi

dnl C99 is illegal in C++... but these turn on extensions to the standard

dnl On Solars. This whole block is sort of silly atm, since we don't do 

dnl GCC on Solaris.

if test "$GCC" = "yes"

then

  case "$target_os" in

    *solaris*)

    AC_DEFINE([_XOPEN_SOURCE],[600],[Turn on XOpen 6.0 Features])

    AC_DEFINE([__C99FEATURES__],[1],[Turn on C99 Features for C++])

    AC_DEFINE([__XPG6],[1],[Turn on C99/XOpen Group 6 Extensions])

    ;;

  esac

fi

AC_SUBST(NM)dnl

AC_PROG_INSTALL

# Look for "(group|user)add". 

# TODO: If the programs do not exist, inform the DBA that the user

#       was not created at the end of the install routine.

AC_CHECK_PROGS(GROUPADD, groupadd addgroup)

AC_CHECK_PROGS(USERADD, useradd adduser)

dnl Not critical since the generated file is distributed

AC_CHECK_PROGS(YACC, ['bison -y'])

if test -z "$YACC" && test -d ".bzr"

then

  AC_MSG_ERROR(["bison is required for Drizzle to build from a bzr branch"])

fi

# Build optimized or debug version ?

# First check for gcc and g++

if test "$GCC" = "yes"

then

  dnl The following is required for portable results of floating point 

  dnl calculations on PowerPC. The same must also be done for IA-64, but 

  dnl this options is missing in the IA-64 gcc backend.

  case "$host_cpu" in

    *ppc* | *powerpc*)

      CFLAGS="-mno-fused-madd ${CFLAGS}"

      CXXFLAGS="-mno-fused-madd ${CXXFLAGS}"

    ;;

  esac

  CFLAGS="-ggdb3 -std=gnu99 ${CFLAGS}"

  CXXFLAGS="-ggdb3 ${CXXFLAGS}"

  AC_CXX_CHECK_STANDARD

  DEBUG_CFLAGS="-O0"

  DEBUG_CXXFLAGS="-O0"

  OPTIMIZE_CFLAGS="-O3"

  OPTIMIZE_CXXFLAGS="-O3"

fi

if test "$SUNCC" = "yes"

then

  dnl we put CPPFLAGS and LDFLAGS first here, because if the user has specified

  dnl command line CPPFLAGS or LDFLAGS, their -I or -L should come _first_

  isainfo_k=`isainfo -k`

  if test "$target_cpu" = "sparc"

  then

    MEMALIGN_FLAGS="-xmemalign=8s"

    IS_64="-m64"

  else

    if test "$isainfo_k" = "amd64"

    then

      IS_64="-m64"

    fi

  fi

  LDFLAGS="${LDFLAGS} -L/usr/local/lib/${isainfo_k} -L/usr/local/lib -L/opt/csw/lib/${isainfo_k} -L/opt/csw/lib -L/usr/lib/${isainfo_k}"

  CPPFLAGS="${CPPFLAGS} -I/usr/local/include -I/opt/csw/include"

  CXXFLAGS="-xlang=c99 -g -mt -compat=5 -library=stlport4 -template=no%extdef ${IS_64} ${MEMALIGN_FLAGS} ${CXXFLAGS}"

  CFLAGS="-g -mt -xc99=all ${IS_64} ${MEMALIGN_FLAGS} ${CFLAGS}"

  DEBUG_CFLAGS="-xO0"

  DEBUG_CXXFLAGS="-xO0" 

  dnl TODO: -xO4 causes a Sun Studio failure in innodb... let's check back

  dnl       in on this one.

  OPTIMIZE_FLAGS="-xO3 -xlibmil -xdepend"

  OPTIMIZE_CFLAGS="${OPTIMIZE_FLAGS} -Xa -xstrconst"

  OPTIMIZE_CXXFLAGS="${OPTIMIZE_FLAGS}"

fi

m4_include(m4/gettext.m4)

AM_GNU_GETTEXT(external, need-formatstring-macros)

if test "x$MSGMERGE" = "x" -o "x$MSGMERGE" = "x:"

then

  AM_PATH_PROG_WITH_TEST(GMSGMERGE, gmsgmerge,

    [$ac_dir/$ac_word --update -q /dev/null /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1], :)

  MSGMERGE="${GMSGMERGE}"

fi

AM_CONDITIONAL([BUILD_GETTEXT],[test "x$MSGMERGE" != "x" -a "x$MSGMERGE" != "x:"])

# We use libtool

AC_PROG_LIBTOOL

dnl TODO: Remove this define once we are using 2.61 across the board.

# AX_HEADER_ASSERT

# ----------------

# Check whether to enable assertions.

AC_DEFUN([AX_HEADER_ASSERT],

[

  AC_MSG_CHECKING([whether to enable assertions])

  AC_ARG_ENABLE([assert],

    [AS_HELP_STRING([--disable-assert],

       [Turn off assertions])],

    [ac_cv_assert="no"],

    [ac_cv_assert="yes"])

  AC_MSG_RESULT([$ac_cv_assert])

])

AX_HEADER_ASSERT

AC_ARG_WITH([debug],

    [AS_HELP_STRING([--with-debug],

       [Add debug code/turns off optimizations (yes|no) @<:@default=no@:>@])],

    [with_debug=$withval],

    [with_debug=no])

if test "$with_debug" = "yes"

then

  # Debuging. No optimization.

  CFLAGS="${DEBUG_CFLAGS} ${CFLAGS}"

  CXXFLAGS="${DEBUG_CXXFLAGS} ${CXXFLAGS}"

else

  # Optimized version. No debug

  CFLAGS="${OPTIMIZE_CFLAGS} ${CFLAGS}"

  CXXFLAGS="${OPTIMIZE_CXXFLAGS} ${CXXFLAGS}"

fi

AC_CXX_STL_HASH

AC_CXX_CSTDINT

AC_CXX_CINTTYPES

AC_CXX_SHARED_PTR

DRIZZLE_PROG_AR

# libdrizzle versioning when linked with GNU ld.

if test "x$EGREP" != "x"

then

  if test "$lt_cv_prog_gnu_ld" = "yes" -a $LD --version 2>/dev/null|${EGREP} -q GNU

  then

    LD_VERSION_SCRIPT="-Wl,--version-script=\$(top_srcdir)/libdrizzleclient/libdrizzleclient.ver"

  fi

fi

AC_SUBST(LD_VERSION_SCRIPT)

AC_LIB_PREFIX

#--------------------------------------------------------------------

# Check for Google Proto Buffers

#--------------------------------------------------------------------

AC_LANG_PUSH([C++])

AC_LIB_HAVE_LINKFLAGS(protobuf,,

[#include <google/protobuf/descriptor.h>

],

[google::protobuf::FileDescriptor* file;])

AS_IF([test x$ac_cv_libprotobuf = xno],

      AC_MSG_ERROR([protobuf is required for Drizzle. On Debian this can be found in libprotobuf-dev. On RedHat this can be found in protobuf-devel.]))

AC_CACHE_CHECK([if protobuf is recent enough], [drizzle_cv_protobuf_recent],

  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[

#include <google/protobuf/descriptor.h>

#if GOOGLE_PROTOBUF_VERSION < 2000002

# error Your version of Protobuf is too old

#endif

    ]])],

    [drizzle_cv_protobuf_recent=yes],

    [drizzle_cv_protobuf_recent=no])])

if test "$drizzle_cv_protobuf_recent" = "no"

then

  AC_MSG_ERROR([Your version of Google Protocol Buffers is too old. Drizzle requires at least version 2.0.2])

fi

AC_PATH_PROG([PROTOC],[protoc],[no],[$LIBPROTOBUF_PREFIX/bin:$PATH])

if test "x$PROTOC" = "xno"

then

  AC_MSG_ERROR([Couldn't find the protoc compiler. On Debian this can be found in protobuf-compiler. On RedHat this can be found in protobuf-compiler.])

fi

AC_LANG_POP()

#--------------------------------------------------------------------

# Check for libuuid

#--------------------------------------------------------------------

dnl Do this by hand. Need to check for uuid/uuid.h, but uuid may or may

dnl not be a lib is weird.

AC_CHECK_HEADERS(uuid/uuid.h)

if test "x$ac_cv_header_uuid_uuid_h" = "xno"

then

  AC_MSG_ERROR([Couldn't find uuid/uuid.h. On Debian this can be found in uuid-dev. On Redhat this can be found in e2fsprogs-devel.])

fi

AC_LIB_HAVE_LINKFLAGS(uuid,,

[

#include <uuid/uuid.h>

],

[

  uuid_t uout;

  uuid_generate(uout);

])

#--------------------------------------------------------------------

# Check for libpthread

#--------------------------------------------------------------------

ACX_PTHREAD(,AC_MSG_ERROR(could not find libpthread))

LIBS="$PTHREAD_LIBS $LIBS"

CFLAGS="${CFLAGS} ${PTHREAD_CFLAGS}"

CC="$PTHREAD_CC"

#--------------------------------------------------------------------

# Check for tcmalloc/mtmalloc

#--------------------------------------------------------------------

AC_ARG_ENABLE([tcmalloc],

    [AS_HELP_STRING([--enable-tcmalloc],

       [Enable linking with tcmalloc @<:@default=off@:>@])],

    [ac_enable_tcmalloc="$enableval"],

    [ac_enable_tcmalloc="no"])

if test "x$ac_enable_tcmalloc" != "xno"

then

  AC_CHECK_LIB(tcmalloc,malloc,[],[])

fi

if test "x$ac_cv_lib_tcmalloc_malloc" != "xyes"

then

  AC_CHECK_LIB(mtmalloc,malloc,[],[])

fi

#--------------------------------------------------------------------

# Check for libdrizzle

#--------------------------------------------------------------------

AC_LIB_HAVE_LINKFLAGS(drizzle,,

[#include <libdrizzle/drizzle.h>],

[

  const char *version= drizzle_version()

])

dnl AS_IF([test x$ac_cv_libdrizzle = xno],

dnl       AC_MSG_ERROR([libdrizzle is required for Drizzle])

#--------------------------------------------------------------------

# Check for libz

#--------------------------------------------------------------------

AC_LIB_HAVE_LINKFLAGS(z,,

[#include <zlib.h>],

[

  crc32(0, Z_NULL, 0);

])

AS_IF([test x$ac_cv_libz = xno],

      AC_MSG_ERROR([libz is required for Drizzle. On Debian this can be found in zlib1g-dev. On RedHat this can be found in zlib-devel.]))

#--------------------------------------------------------------------

# Check for TBB

#--------------------------------------------------------------------

AC_LANG_PUSH(C++)

AC_LIB_HAVE_LINKFLAGS(tbb,,

[#include <tbb/atomic.h>

 #include <stdint.h>

],

[

  tbb::atomic<uint64_t> x;

  tbb::atomic<uint8_t> y;

  x=0;

  y=0;

  x++;

  y++;

])

AC_LANG_POP()

#--------------------------------------------------------------------

# Check for libreadline or compatible (libedit on Mac OS X)

#--------------------------------------------------------------------

save_LIBS="${LIBS}"

LIBS=""

VL_LIB_READLINE

AS_IF([test "x$vl_cv_lib_readline" = "xno"],

      AC_MSG_ERROR([libreadline is required for Drizzle. On Debian this can be found in libreadline5-dev. On RedHat this can be found in readline-devel.]))

READLINE_LIBS="${LIBS}"

LIBS="${save_LIBS}"

AC_SUBST(READLINE_LIBS)

DRIZZLE_CHECK_NEW_RL_INTERFACE

#--------------------------------------------------------------------

# Check for libpcre

#--------------------------------------------------------------------

AC_LIB_HAVE_LINKFLAGS(pcre,, [#include <pcre.h>], [pcre *re= NULL])

AS_IF([test "x$ac_cv_libpcre" = "xno"],[

  unset ac_cv_libpcre

  AC_LIB_HAVE_LINKFLAGS(pcre,, [#include <pcre/pcre.h>], [pcre *re= NULL])

  AS_IF([test "x$ac_cv_libpcre" = "xno"],

        [AC_MSG_ERROR([libpcre is required for Drizzle. On Debian this can be found in libpcre3-dev. On RedHat this can be found in pcre-devel.])]

        [AC_DEFINE(PCRE_HEADER,[<pcre/pcre.h>],[Location of pcre header])])

],[

  AC_DEFINE(PCRE_HEADER,[<pcre.h>],[Location of pcre header])

])

dnl Find paths to some shell programs

AC_PATH_PROG(LN, ln, ln)

# This must be able to take a -f flag like normal unix ln.

AC_PATH_PROG(LN_CP_F, ln, ln)

AC_PATH_PROG(MV, mv, mv)

AC_PATH_PROG(RM, rm, rm)

AC_PATH_PROG(CP, cp, cp)

AC_PATH_PROG(SED, sed, sed)

AC_PATH_PROG(CMP, cmp, cmp)

AC_PATH_PROG(CHMOD, chmod, chmod)

AC_PATH_PROG(HOSTNAME, hostname, hostname)

# Check for a GNU tar named 'gtar', or 'gnutar' (MacOS X) and

# fall back to 'tar' otherwise and hope that it's a GNU tar as well

AC_CHECK_PROGS(TAR, gnutar gtar tar)

dnl We use a path for perl so the script startup works

dnl We make sure to use perl, not perl5, in hopes that the RPMs will

dnl not depend on the perl5 binary being installed (probably a bug in RPM)

AC_PATH_PROG(PERL, perl, no)

if test "$PERL" != "no" && $PERL -e 'require 5' > /dev/null 2>&1

then

  PERL5=$PERL

else

  AC_PATH_PROG(PERL5, perl5, no)

  if test "$PERL5" != no

  then

    PERL=$PERL5

    ac_cv_path_PERL=$ac_cv_path_PERL5

  fi

fi

AC_SUBST(HOSTNAME)

AC_SUBST(PERL)

AC_SUBST(PERL5)

# icheck, used for ABI check

AC_PATH_PROG(ICHECK, icheck, no)

# "icheck" is also the name of a file system check program on Tru64.

# Verify the program found is really the interface checker.

if test "x$ICHECK" != "xno"

then

  AC_MSG_CHECKING(if $ICHECK works as expected)

  echo "int foo;" > conftest.h

  $ICHECK --canonify -o conftest.ic conftest.h 2>/dev/null

  if test -f "conftest.ic"

  then

    AC_MSG_RESULT(yes)

  else

    AC_MSG_RESULT(no)

    ICHECK=no

  fi

  rm -f conftest.ic conftest.h

fi

AC_SUBST(ICHECK)

# Lock for PS

AC_PATH_PROG(PS, ps, ps)

AC_MSG_CHECKING("how to check if pid exists")

PS=$ac_cv_path_PS

# Linux style

if $PS p $$ 2> /dev/null | grep `echo $0 | sed s/\-//` > /dev/null

then

  FIND_PROC="$PS p \$\$PID | grep -v grep | grep \$\$MYSQLD > /dev/null"

# Solaris

elif $PS -fp $$ 2> /dev/null | grep $0 > /dev/null

then

  FIND_PROC="$PS -p \$\$PID | grep -v grep | grep \$\$MYSQLD > /dev/null"

# BSD style

elif $PS -uaxww 2> /dev/null | grep $0 > /dev/null

then

  FIND_PROC="$PS -uaxww | grep -v grep | grep \$\$MYSQLD | grep \" \$\$PID \" > /dev/null"

# SysV style

elif $PS -ef 2> /dev/null | grep $0 > /dev/null

then

  FIND_PROC="$PS -ef | grep -v grep | grep \$\$MYSQLD | grep \" \$\$PID \" > /dev/null"

# Do anybody use this?

elif $PS $$ 2> /dev/null | grep $0 > /dev/null

then

  FIND_PROC="$PS \$\$PID | grep -v grep | grep \$\$MYSQLD > /dev/null"

else

  case $SYSTEM_TYPE in

    *freebsd*|*dragonfly*|*cygwin*)

      FIND_PROC="$PS p \$\$PID | grep -v grep | grep \$\$MYSQLD > /dev/null"

      ;;

    *darwin*)

      FIND_PROC="$PS -uaxww | grep -v grep | grep \$\$MYSQLD | grep \" \$\$PID \" > /dev/null"

      ;;

    *)

      AC_MSG_ERROR([Could not find the right ps switches. Which OS is this ?. See the Installation chapter in the Reference Manual.])

      ;;

  esac

fi

AC_SUBST(FIND_PROC)

AC_MSG_RESULT("$FIND_PROC")

# Check if a pid is valid

AC_PATH_PROG(KILL, kill, kill)

AC_MSG_CHECKING("for kill switches")

if $ac_cv_path_KILL -0 $$

then

  CHECK_PID="$ac_cv_path_KILL -0 \$\$PID > /dev/null 2> /dev/null"

elif kill -s 0 $$

then

  CHECK_PID="$ac_cv_path_KILL -s 0 \$\$PID > /dev/null 2> /dev/null"

else

  AC_MSG_WARN([kill -0 to check for pid seems to fail])

    CHECK_PID="$ac_cv_path_KILL -s SIGCONT \$\$PID > /dev/null 2> /dev/null"

fi

AC_SUBST(CHECK_PID)

AC_MSG_RESULT("$CHECK_PID")

# Check if we need noexec stack for assembler

AC_CHECK_NOEXECSTACK

AC_ARG_WITH([server-suffix],

    [AS_HELP_STRING([--with-server-suffix],

      [Append value to the version string.])],

    [ DRIZZLE_SERVER_SUFFIX=`echo "$withval" | sed -e  's/^\(...................................\)..*$/\1/'` ],

    [ DRIZZLE_SERVER_SUFFIX= ]

    )

AC_DEFINE_UNQUOTED([DRIZZLE_SERVER_SUFFIX],[$DRIZZLE_SERVER_SUFFIX],

                   [Append value to the version string])

# Force use of a curses libs

AC_ARG_WITH([named-curses-libs],

    [AS_HELP_STRING([--with-named-curses-libs=ARG],

            [Use specified curses libraries instead of those

		automatically found by configure.])],

    [ with_named_curses=$withval ],

    [ with_named_curses=no ]

    )

AC_ARG_WITH([tcp-port],

    [AS_HELP_STRING([--with-tcp-port=port-number],

            [Which port to use for Drizzle services @<:@default=4427@:>@])],

    [ DRIZZLE_TCP_PORT=$withval ],

    [ DRIZZLE_TCP_PORT=$DRIZZLE_TCP_PORT_DEFAULT

      # if we actually defaulted (as opposed to the pathological case of

      # --with-tcp-port=<DRIZZLE_TCP_PORT_DEFAULT> which might in theory

      # happen if whole batch of servers was built from a script), set

      # the default to zero to indicate that; we don't lose information

      # that way, because 0 obviously indicates that we can get the

      # default value from DRIZZLE_TCP_PORT. this seems really evil, but

      # testing for DRIZZLE_TCP_PORT==DRIZZLE_TCP_PORT_DEFAULT would make a

      # a port of DRIZZLE_TCP_PORT_DEFAULT magic even if the builder did not

      # intend it to mean "use the default, in fact, look up a good default

      # from /etc/services if you can", but really, really meant 4427 when

      # they passed in 4427. When they pass in a specific value, let them

      # have it; don't second guess user and think we know better, this will

      # just make people cross.  this makes the the logic work like this

      # (which is complicated enough):

      #

      # - if a port was set during build, use that as a default.

      #

      # - otherwise, try to look up a port in /etc/services; if that fails,

      #   use DRIZZLE_TCP_PORT_DEFAULT (at the time of this writing 4427)

      #

      # - allow the DRIZZLE_TCP_PORT environment variable to override that.

      #

      # - allow command-line parameters to override all of the above.

      #

      # the top-most DRIZZLE_TCP_PORT_DEFAULT is read from win/configure.js,

      # so don't mess with that.

      DRIZZLE_TCP_PORT_DEFAULT=0 ]

    )

AC_SUBST(DRIZZLE_TCP_PORT)

# We might want to document the assigned port in the manual.

AC_SUBST(DRIZZLE_TCP_PORT_DEFAULT)

AC_DEFINE_UNQUOTED([DRIZZLE_PORT],[$DRIZZLE_TCP_PORT],

                   [Drizzle port to use])

AC_DEFINE_UNQUOTED([DRIZZLE_PORT_DEFAULT],[$DRIZZLE_TCP_PORT_DEFAULT],

		   [If we defaulted to DRIZZLE_PORT, then this will be zero])

# Use this to set the place used for unix socket used to local communication.

AC_ARG_WITH([drizzled-user],

    [AS_HELP_STRING([--with-drizzled-user=username],

            [What user the drizzled daemon shall be run as.

		@<:@default=drizzle@:>@])],

    [ DRIZZLED_USER=$withval ],

    [ DRIZZLED_USER=drizzle ]

    )

AC_SUBST(DRIZZLED_USER)

# If we should allow LOAD DATA LOCAL