configure.in

dnl Copyright (C) 2008 Oracle/Innobase Oy
dnl
dnl This program is free software; you can redistribute it and/or modify
dnl it under the terms of the GNU General Public License as published by
dnl the Free Software Foundation; version 2 of the License.
dnl 
dnl This program is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
dnl GNU General Public License for more details.
dnl 
dnl You should have received a copy of the GNU General Public License
dnl along with this program; if not, write to the Free Software
dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
dnl Process this file with autoconf to produce a configure script.

AC_PREREQ(2.52)		dnl              Minimum Autoconf version required.

dnl Temporary
AC_INIT(include/univ.i)
AC_LANG(C)
AC_CONFIG_AUX_DIR(aconf)

AC_CANONICAL_SYSTEM

AC_PROG_CC
AC_PROG_LIBTOOL

AC_SUBST(NM)

# Used by the Makefile to create the install directory
INSTDIR=embedded_innodb-1.0
AC_SUBST(INSTDIR)

INNODB_VERSION_STR=`grep '^#define INNODB_VERSION_STR' include/univ.i |cut -f 2 |cut -f 2 -d '"'`

IB_API_VERSION_CURRENT=`grep '^#define IB_API_VERSION_CURRENT' include/univ.i |cut -f 2`
IB_API_VERSION_REVISION=`grep '^#define IB_API_VERSION_REVISION' include/univ.i |cut -f 2`
IB_API_VERSION_AGE=`grep '^#define IB_API_VERSION_AGE' include/univ.i |cut -f 2`
AC_SUBST(IB_API_VERSION_CURRENT)
AC_SUBST(IB_API_VERSION_REVISION)
AC_SUBST(IB_API_VERSION_AGE)

AM_INIT_AUTOMAKE(embedded_innodb, $INNODB_VERSION_STR)
AM_CONFIG_HEADER([include/ib0config.h:config.h.in])

# Available languages
IB_LANG="english"

AC_SUBST(IB_LANG)

AM_SANITY_CHECK
AC_PROG_MAKE_SET

dnl Checks for programs.
AC_PROG_AWK
AC_PROG_CC
AC_PROG_CPP

AM_PROG_CC_C_O

AC_PROG_INSTALL
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'

# Not critical since the generated files are distributed
AC_CHECK_PROGS(YACC, ['bison -y -p InnoDB'])

AC_PATH_PROG(uname_prog, uname, no)

AC_SUBST(CC)
AC_SUBST(CFLAGS)
AC_SUBST(ASFLAGS)
AC_SUBST(LD)
AC_SUBST(INSTALL_SCRIPT)

export CC CFLAGS LD LDFLAGS AR ARFLAGS

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)

#####
## Libtool support
######
for top_builddir in . .. ../.. $ac_auxdir $ac_auxdir/..
do
	test -f $top_builddir/configure && break
done

#####
## Check for system header files used by InnoDB.
#####

AC_HEADER_TIME
AC_HEADER_DIRENT
AC_HEADER_STDC
AC_HEADER_SYS_WAIT
AC_HEADER_STDBOOL
AC_CHECK_HEADERS(\
	alloca.h \
	assert.h \
	atomic.h \
	ctype.h \
	dirent.h \
	errno.h \
	fcntl.h \
	inttypes.h \
	libintl.h \
	malloc.h \
	math.h \
	pthread.h \
	sched.h \
	stdarg.h \
	stddef.h \
	stdint.h \
	stdio.h \
	stdlib.h \
	string.h \
	strings.h \
	sys/ipc.h \
	sys/mman.h \
	sys/resource.h \
	sys/select.h \
	sys/shm.h \
	sys/stat.h \
	sys/time.h \
	sys/types.h \
	sys/utsname.h \
	time.h \
	unistd.h \
	valgrind/memcheck.h)

case "$target_os" in
lin*)
	TARGET_LINUX="true";
	CFLAGS="$CFLAGS -DUNIV_LINUX";;
hpux10*)
	CFLAGS="$CFLAGS -DUNIV_MUST_NOT_INLINE -DUNIV_HPUX -DUNIV_HPUX10";;
hp*)
	CFLAGS="$CFLAGS -DUNIV_MUST_NOT_INLINE -DUNIV_HPUX";;
aix*)
	CFLAGS="$CFLAGS -DUNIV_AIX";;
irix*|osf*|sysv5uw7*|openbsd*)
	CFLAGS="$CFLAGS -DUNIV_MUST_NOT_INLINE";;
*solaris*|*SunOS*)
	CFLAGS="$CFLAGS -DUNIV_SOLARIS";;
esac

  # do not reindent the following lines, they are copied from InnoDB Plugin's
  # plug.in and this way it is easier for maintenance

  AC_MSG_CHECKING(whether GCC atomic builtins are available)
  # either define HAVE_IB_GCC_ATOMIC_BUILTINS or not
  AC_TRY_RUN(
    [
      int main()
      {
	long	x;
	long	y;
	long	res;
	char	c;

	x = 10;
	y = 123;
	res = __sync_bool_compare_and_swap(&x, x, y);
	if (!res || x != y) {
          return(1);
        }

	x = 10;
	y = 123;
	res = __sync_bool_compare_and_swap(&x, x + 1, y);
	if (res || x != 10) {
          return(1);
        }

	x = 10;
	y = 123;
	res = __sync_add_and_fetch(&x, y);
	if (res != 123 + 10 || x != 123 + 10) {
	  return(1);
	}

	c = 10;
	res = __sync_lock_test_and_set(&c, 123);
	if (res != 10 || c != 123) {
	  return(1);
	}

	return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_GCC_ATOMIC_BUILTINS], [1],
                [GCC atomic builtins are available])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )

  AC_MSG_CHECKING(whether pthread_t can be used by GCC atomic builtins)
  # either define HAVE_IB_ATOMIC_PTHREAD_T_GCC or not
  AC_TRY_RUN(
    [
      #include <pthread.h>
      #include <string.h>

      int main(int argc, char** argv) {
        pthread_t       x1;
        pthread_t       x2;
        pthread_t       x3;

	memset(&x1, 0x0, sizeof(x1));
	memset(&x2, 0x0, sizeof(x2));
	memset(&x3, 0x0, sizeof(x3));

        __sync_bool_compare_and_swap(&x1, x2, x3);

        return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_ATOMIC_PTHREAD_T_GCC], [1],
                [pthread_t can be used by GCC atomic builtins])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )

  AC_MSG_CHECKING(whether Solaris libc atomic functions are available)
  # either define HAVE_IB_SOLARIS_ATOMICS or not
  AC_CHECK_FUNCS(atomic_add_long \
		 atomic_cas_32 \
		 atomic_cas_64 \
		 atomic_cas_ulong,

		 AC_DEFINE([HAVE_IB_SOLARIS_ATOMICS], [1],
			   [Define to 1 if Solaris libc atomic functions \
			    are available])
  )

  AC_MSG_CHECKING(whether pthread_t can be used by Solaris libc atomic functions)
  # either define HAVE_IB_ATOMIC_PTHREAD_T_SOLARIS or not
  AC_TRY_RUN(
    [
      #include <pthread.h>
      #include <string.h>

      int main(int argc, char** argv) {
        pthread_t       x1;
        pthread_t       x2;
        pthread_t       x3;

        memset(&x1, 0x0, sizeof(x1));
        memset(&x2, 0x0, sizeof(x2));
        memset(&x3, 0x0, sizeof(x3));

        if (sizeof(pthread_t) == 4) {
        
          atomic_cas_32(&x1, x2, x3);
        
        } else if (sizeof(pthread_t) == 8) {
        
          atomic_cas_64(&x1, x2, x3);
        
        } else {
        
          return(1);
        }

	return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_ATOMIC_PTHREAD_T_SOLARIS], [1],
                [pthread_t can be used by solaris atomics])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )

  # this is needed to know which one of atomic_cas_32() or atomic_cas_64()
  # to use in the source
  AC_CHECK_SIZEOF([pthread_t], [], [#include <pthread.h>])

  # Check for x86 PAUSE instruction
  AC_MSG_CHECKING(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
  # We use ib_ prefix to avoid collisoins if this code is added to
  # mysql's configure.in.
  AC_TRY_RUN(
    [
      int main() {
        __asm__ __volatile__ ("pause");
        return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_PAUSE_INSTRUCTION], [1], [Does x86 PAUSE instruction exist])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )
  # end of "do not reindent the following lines"

#
# The behavior of --with-atomic-ops must be:
# if this switch is not specified then
#   if gcc atomics are present, use them
#   else if solaris atomics are present, use them
#   else use innodb atomics
# else the switch is specified with some value,
#   check if the requested atomics are present
#   if present, use them
#   else emit error during ./configure
#

AC_ARG_WITH([atomic-ops],
	AC_HELP_STRING([--with-atomic-ops=      gcc_builtins|solaris|innodb],
	[Implement the atomic operations using GCC builtin atomic functions or \
	using the Solaris 10 atomic_ops(3C) from libc or InnoDB's own \
	implementation]))

case "$with_atomic_ops" in
"gcc_builtins") 
	AC_CHECK_DECLS(
		HAVE_IB_GCC_ATOMIC_BUILTINS,
		AC_MSG_NOTICE(will use the requested GCC atomic builtins),
		AC_MSG_ERROR(the requested GCC atomic builtins are not available)
	)
	AC_DEFINE([IB_ATOMIC_MODE_GCC_ATOMIC_BUILTINS], [1],
		[Use GCC builtin atomic functions])
       	;;
"solaris")
	AC_CHECK_DECLS(
		HAVE_IB_SOLARIS_ATOMICS,
		AC_MSG_NOTICE(will use the requested Solaris atomic functions),
		AC_MSG_ERROR(the requested Solaris atomic functions are not available)
	)
	AC_DEFINE([IB_ATOMIC_MODE_SOLARIS_ATOMICS], [1],
		[Use Solaris 10 atomic_ops(3C) from libc])
       	;;
"innodb")
	AC_MSG_NOTICE(will use the requested InnoDB's own implementation of mutexes and rw_locks)
	# this macro is not used but is here for clarity
	AC_DEFINE([IB_ATOMIC_MODE_INNODB], [1],
		[Use InnoDB's own implementation])
	;;
"")
	AC_CHECK_DECLS(
          HAVE_IB_GCC_ATOMIC_BUILTINS,
	  [
            AC_MSG_NOTICE(will use the GCC atomic builtins (auto selected));
            AC_DEFINE([IB_ATOMIC_MODE_GCC_ATOMIC_BUILTINS], [1],
                      [Use GCC builtin atomic functions])
          ],
          [
            AC_CHECK_DECLS(
              HAVE_IB_SOLARIS_ATOMICS,
              [
                AC_MSG_NOTICE(will use the Solaris atomic functions (auto selected));
                AC_DEFINE([IB_ATOMIC_MODE_SOLARIS_ATOMICS], [1],
                          [Use Solaris 10 atomic_ops(3C) from libc])
              ],
              AC_MSG_NOTICE(will use InnoDB's own implementation of mutexes and rw_locks (auto selected))
            )
          ]
	)

	;;
*)
	AC_MSG_ERROR(Unknown value "$with_atomic_ops" specified for --with-atomic-ops)
	;;
esac

# For large pages support
if test "$TARGET_LINUX" = "true"; then
	# For SHM_HUGETLB on Linux
	AC_CHECK_DECLS(SHM_HUGETLB, 
		AC_DEFINE([HAVE_LARGE_PAGES], [1], 
			[Define if you have large pages support])
		AC_DEFINE([HUGETLB_USE_PROC_MEMINFO], [1],
			[Define if /proc/meminfo shows the huge page size \
			 (Linux only)])
			, ,
			[
				#include <sys/shm.h>
			])
fi

AC_C_CONST
AC_C_INLINE
AC_C_VOLATILE
AC_CHECK_TYPES([int64_t, uint64_t, int32_t, uint32_t,
		int16_t, uint16_t, int8_t,  uint8_t,
		unsigned long long int, long long int], [],
		[AC_MSG_ERROR([Need the C99 integer types from stdint.h])],
		[#include <stdint.h>])
AC_STRUCT_TM
AC_TYPE_OFF_T
AC_TYPE_SIZE_T
AC_STRUCT_ST_RDEV
AC_CHECK_SIZEOF(char, 1)

if test "$ac_cv_sizeof_char" -eq 0; then
	AC_MSG_ERROR([No size for char type.
		A likely cause for this could be that there aren't any
static libraries installed. You can verify this by checking if you have libm.a
in /lib, /usr/lib or some other standard place.  If this is the problem,
install the static libraries and try again.  If this isn't the problem,
examine config.log for possible errors.])
fi

AC_CHECK_SIZEOF(void*, 4)
AC_CHECK_SIZEOF(char*, 4)
AC_CHECK_SIZEOF(short, 2)
AC_CHECK_SIZEOF(int, 4)

if test "$ac_cv_sizeof_int" -eq 0; then
	AC_MSG_ERROR("No size for int type.")
fi

AC_CHECK_SIZEOF(long, 4)

if test "$ac_cv_sizeof_long" -eq 0; then
	AC_MSG_ERROR("No size for long type.")
fi

AC_CHECK_SIZEOF(long long, 8)
if test "$ac_cv_sizeof_long_long" -eq 0; then
	AC_MSG_ERROR("InnoDB needs a long long type.")
fi

# off_t is not a builtin type
AC_CHECK_SIZEOF(off_t, 4)
if test "$ac_cv_sizeof_off_t" -eq 0; then
	AC_MSG_ERROR("InnoDB needs an off_t type.")
fi

AC_CHECK_TYPES([off_t, ulong], [], [], [#include <sys/types.h>])
AC_CHECK_TYPES([size_t], [], [], [#include <stdio.h>])
AC_CHECK_TYPES([u_int32_t])

AC_FUNC_ALLOCA
AC_TYPE_SIGNAL
AC_PROG_GCC_TRADITIONAL

AC_CHECK_LIB(pthread, pthread_mutex_trylock)

# Required on Solaris
AC_CHECK_FUNC(sched_yield, , AC_CHECK_LIB(posix4, sched_yield))
AC_CHECK_FUNCS(strdup strlcpy)

#####
# Check whether the user wants to disable compressed tables functionality
#####
AC_ARG_ENABLE(compression,
	[  --disable-compression   disable compressed tables support],
	[   ],
	enable_compression=yes)
if test $enable_compression = yes; then
	# Check for ZLib functions
	AC_CHECK_FUNC(deflate, ,
	       	AC_CHECK_LIB(z, deflate, ,
			AC_MSG_ERROR([Zlib is required for compression to work])))

	AC_CHECK_FUNC(inflate, ,
		AC_CHECK_LIB(z, inflate, ,
			AC_MSG_ERROR([Zlib is required for compression to work])))
	AC_CHECK_HEADERS(zlib.h)
	AC_DEFINE([WITH_ZIP], [1], [Compressed tables support])
fi
AM_CONDITIONAL(WITH_ZIP, test $enable_compression = yes)
# End Zip tests

#####
# Check whether the user wants to disable XA functionality
#####
AC_ARG_ENABLE(xa,
	[  --disable-xa            disable XA support],
	[   ],
	enable_xa=yes
	AC_DEFINE([WITH_XOPEN], [1], [XA support]))
AM_CONDITIONAL(WITH_XOPEN, test $enable_xa = yes)

MAKE_SHELL=/bin/sh
AC_SUBST(MAKE_SHELL)

AC_CHECK_FUNCS( \
	bcmp \
	fcntl \
	finite \
	fsync \
	ftruncate \
	getcwd \
	getrusage \
	index \
	localtime_r \
	locking \
	memcpy \
	memmove \
	perror \
	pread \
	mmap \
	getpagesize \
	pthread_attr_setstacksize \
	pthread_barrier_destroy \
	pthread_barrier_init \
	pthread_barrier_wait \
	pthread_setprio \
	rename \
	rint \
	shmget \
	shmat \
	shmdt \
	shmctl \
	sleep \
	snprintf \
	stpcpy \
	strcasecmp \
	strerror \
	strstr \
	strtoul \
	tell)

AM_CONDITIONAL([HAVE_PTHREAD_BARRIER], [test "$HAVE_PTHREAD_BARRIER_INIT" = yes])

AC_CONFIG_FILES(Makefile tests/Makefile)
AC_CONFIG_HEADERS(config.h)

# pkg-config checks for ZLib dependency
#PKG_CHECK_MODULES(DEPS, zlib1g-dev >= 1.2.3)
#AC_SUBST(DEPS_LIBS)
#AC_SUBST(DEPS_CFLAGS)
#AC_OUTPUT(embedded_innodb-1.0.0.pc)

AC_OUTPUT

echo
echo "Please visit http://www.innodb.com for more information"
echo
echo "Have a look at the files in the docs directory"
echo
echo "Thank you for choosing Embedded InnoDB!"
echo