~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.

AC_INIT([drizzle],[7.0.0],[http://bugs.launchpad.net/drizzle])

AC_CONFIG_SRCDIR([drizzled/drizzled.cc])

AC_CONFIG_AUX_DIR(config)

AC_CONFIG_HEADERS([config.h])

# 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_CC

AC_PROG_CXX

gl_USE_SYSTEM_EXTENSIONS

AC_CXX_HEADER_STDCXX_98

if test "$ac_cv_cxx_stdcxx_98" = "no"

then

  AC_MSG_ERROR([C++ Compiler required to compile Drizzle])

fi

AC_PROG_CPP

AM_PROG_CC_C_O

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

# We need to hack in some of the non-standard locations that solaris sticks

# stuff in. This makes me very sad.

case "$host_os" in

  solaris*)

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

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

    ;;

esac

m4_include(m4/dtrace.m4)

m4_include(m4/character_sets.m4)

AC_SUBST(AVAILABLE_LANGUAGES)

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:"])

# 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. Please install it."))

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  Solaris 9 include file <sys/feature_tests.h> refers to X/Open document

dnl  System Interfaces and Headers, Issue 5

dnl  saying we should define _XOPEN_SOURCE=500 to get POSIX.1c prototypes,

dnl  but apparently other systems (namely FreeBSD) don't agree.

dnl  On a newer Solaris 10, the above file recognizes also _XOPEN_SOURCE=600.

dnl  Furthermore, it tests that if a program requires older standard

dnl  (_XOPEN_SOURCE<600 or _POSIX_C_SOURCE<200112L) it cannot be

dnl  run on a new compiler (that defines _STDC_C99) and issues an #error.

dnl  It's also an #error if a program requires new standard (_XOPEN_SOURCE=600

dnl  or _POSIX_C_SOURCE=200112L) and a compiler does not define _STDC_C99.

dnl  To add more to this mess, Sun Studio C compiler defines _STDC_C99 while

dnl  C++ compiler does not!

dnl TODO: Can _ISOC99_SOURCE be defined on all platforms and remove the 

dnl       Need for all of this? 

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++])

    ;;

  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

# The following is required for portable results of floating point calculations

# on PowerPC. The same must also be done for IA-64, but this options is missing

# in the IA-64 gcc backend.

if test "$GCC" = "yes"

then

  case "$host_cpu" in

    *ppc* | *powerpc*)

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

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

    ;;

  esac

fi

# Build optimized or debug version ?

# First check for gcc and g++

if test "$GCC" = "yes"

then

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

  CXXFLAGS="${CXXFLAGS} -ggdb3 -std=gnu++98"

  DEBUG_CFLAGS="-O0"

  DEBUG_CXXFLAGS="-O0"

  OPTIMIZE_CFLAGS="-O3"

  OPTIMIZE_CXXFLAGS="-O3"

fi

if test "$SUNCC" = "yes"

then

  if test "$target_cpu" = "sparc"

  then

    MEMALIGN_FLAGS="-xmemalign=8s"

    IS_64="-m64"

  else

    isainfo_k=`isainfo -k`

    if test "$isainfo_k" = "amd64"

    then

      IS_64="-m64"

      LDFLAGS="${LDFLAGS} -L/usr/lib/amd64 -L/usr/local/lib/amd64"

    fi

  fi

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

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

  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

# 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} -DDEBUG ${CFLAGS}"

  CXXFLAGS="${DEBUG_CXXFLAGS} -DDEBUG ${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_CMATH

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>

#if GOOGLE_PROTOBUF_VERSION < 2000002

# error Your version of Protobuf is too old

#endif

],

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

AS_IF([test x$ac_cv_libprotobuf = xno],

      AC_MSG_ERROR([protobuf is required for Drizzle]))

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

if test "x$PROTOC" = "xno"

then

  AC_MSG_ERROR([Couldn't find protoc. Try installing Google Protocol Buffer.])

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. Try installing libuuid development packages])

fi

AC_LIB_HAVE_LINKFLAGS(uuid,,

[

#include <uuid/uuid.h>

],

[

  uuid_t uout;

  uuid_generate(uout);

])

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

# Check for libevent

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

AC_LIB_HAVE_LINKFLAGS(event,,

[

#include <sys/types.h>

#include <sys/time.h>

#include <stdlib.h>

#include <event.h>

],[

  struct bufferevent bev;

  bufferevent_settimeout(&bev, 1, 1);

  event_init();

  event_loop(EVLOOP_ONCE);

]) 

AS_IF([test x$ac_cv_libevent = xno],

      AC_MSG_ERROR([A recent libevent is required for Drizzle. Check http://www.monkey.org/~provos/libevent ]))

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

# 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]))

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

# 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]))

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"],[

  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])]

          [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

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

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