~drizzle-trunk/drizzle/development

 

m4_include(m4/bzr_version.m4)

 

gl_EARLY

 

 

dnl Checks for programs.

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" -a "$host_vendor" = "apple"

  then

    AC_MSG_ERROR([Your version of GCC is too old. Drizzle requires at least version 4.2 on OSX. You may need to install a version of XCode >= 3.1.2])

  fi

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

  fi

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

 

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

# 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

AC_PROG_AWK

 

 

AC_SUBST(NM)dnl

 

AC_PROG_INSTALL

 

dnl Not critical since the generated file is distributed

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

AC_CHECK_PROGS(ISAINFO, [isainfo], [no])

AS_IF([test "x$ISAINFO" != "xno"],

      [isainfo_b=`isainfo -b`],

      [isainfo_b="x"])

  if test "$isainfo_b" = "64"

  then

    IS_64="-m64"

  fi

  case "$host_cpu" in

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

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

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

  CXXFLAGS="-ggdb3  ${IS_64} ${CXXFLAGS}"

  AC_CXX_CHECK_STANDARD

 

  if test "$isainfo_b" = "64"

  then

    IS_64="-m64"

  fi

  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_

  if test "$target_cpu" = "sparc"

  then

    MEMALIGN_FLAGS="-xmemalign=8s"

  fi

 

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

  then

    AS_IF([test "$isainfo_b" != "none"],[

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

      ],[

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

      ])

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

  fi

  AS_IF([test "$isainfo_b" != "none"],

        [LDFLAGS="${LDFLAGS} -L/usr/lib/${isainfo_b}"])

 

  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"

m4_include(m4/gettext.m4)

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

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

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

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

DRIZZLE_PROG_AR

 

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

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)

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

# Types that must be checked AFTER large file support is checked

AC_TYPE_SIZE_T

 

  COMPILATION_COMMENT="Source distribution"

AC_C_CONST

AC_C_INLINE

AC_C_VOLATILE

AC_TYPE_OFF_T

AC_HEADER_TIME

# This always gives a warning. Ignore it unless you are cross compiling

AC_C_BIGENDIAN

 

# Find where the stack goes

DRIZZLE_STACK_DIRECTION

AC_TYPE_SIGNAL

# from old readline settting:

 

MAKE_SHELL=/bin/sh

AC_SUBST(MAKE_SHELL)

 

DRIZZLE_SIGNAL_CHECK

DRIZZLE_CHECK_GETPW_FUNCS

    CFLAGS="-xinstrument=datarace ${CFLAGS}"

    CXXFLAGS="-xinstrument=datarace ${CXXFLAGS}"

    CPPFLAGS="-isystem \$(top_srcdir)/gnulib -isystem \$(top_builddir)/gnulib ${CPPFLAGS}"

    CPPFLAGS="-I\$(top_srcdir)/gnulib -I\$(top_builddir)/gnulib ${CPPFLAGS}"

CPPFLAGS="-I\$(top_srcdir) -I\$(top_builddir) ${CPPFLAGS}"

CFLAGS="${CC_WARNINGS} ${CFLAGS}"

CXXFLAGS="${CXX_WARNINGS} ${W_EXCEPTIONS} ${CXXFLAGS}"

AM_CPPFLAGS="${CPPFLAGS}"

AM_CFLAGS="${CFLAGS}"

AM_CXXFLAGS="${CXXFLAGS}"

 

dnl We've collected the flags in AM_*FLAGS now, so blank these.

CFLAGS=""

CXXFLAGS=""

CPPFLAGS=""

AC_CONFIG_COMMANDS([timestamp-h], , test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h)

 

AC_CONFIG_COMMANDS_PRE([

if test "x$EGREP" != "x" -a -d po

then

  echo "# This file is auto-generated from configure. Do not edit directly" > po/POTFILES.in.in

  # The grep -v 'drizzle-' is to exclude any distcheck leftovers

  for f in `find . | grep -v 'drizzle-' | ${EGREP} '\.(cc|c|h|yy)$' | cut -c3- | sort`

  do

    if grep gettext.h "$f" | grep include >/dev/null 2>&1

    then

      echo "$f" >> po/POTFILES.in.in

    fi

  done

  if ! diff po/POTFILES.in.in po/POTFILES.in >/dev/null 2>&1

  then

    mv po/POTFILES.in.in po/POTFILES.in

  else

    rm po/POTFILES.in.in

  fi

else

  touch po/POTFILES.in

fi

])

 

# Ensure that table handlers gets all modifications to CFLAGS/CXXFLAGS

AC_CONFIG_COMMANDS_POST(ac_configure_args="$ac_configure_args CFLAGS='$CFLAGS' CXXFLAGS='$CXXFLAGS' AM_CFLAGS='$AM_CFLAGS' AM_CXXFLAGS='$AM_CXXFLAGS'")

 

echo "Configuration summary for $PACKAGE_NAME version $VERSION"

echo "   * System type:               $SYSTEM_TYPE"