configure.in

fi

AC_SUBST(PTHREAD_CFLAGS)
AC_SUBST(PTHREAD_LIBS)


# This test makes sure that run tests work at all.  Sometimes a shared
# library is found by the linker, but the runtime linker can't find it.
# This check should come after all modifications of compiler or linker
# variables, and before any other run tests.
AC_MSG_CHECKING([test program])
AC_TRY_RUN([int main() { return 0; }],
[AC_MSG_RESULT(ok)],
[AC_MSG_RESULT(failed)
AC_MSG_ERROR([[
*** Could not execute a simple test program.  This may be a problem
*** related to locating shared libraries.  Check the file 'config.log'
*** for the exact reason.]])],
[AC_MSG_RESULT([cross-compiling])])


dnl Check to see if we have a working 64-bit integer type.
dnl This breaks down into two steps:
dnl (1) figure out if the compiler has a 64-bit int type with working
dnl arithmetic, and if so
dnl (2) see whether snprintf() can format the type correctly.  (Currently,
dnl snprintf is the only library routine we really need for int8 support.)
dnl It's entirely possible to have a compiler that handles a 64-bit type
dnl when the C library doesn't; this is fairly likely when using gcc on
dnl an older platform, for example.
dnl If there is no native snprintf() or it does not handle the 64-bit type,
dnl we force our own version of snprintf() to be used instead.
dnl Note this test must be run after our initial check for snprintf/vsnprintf.

PGAC_TYPE_64BIT_INT([long int])

if test x"$HAVE_LONG_INT_64" = x"no" ; then
  PGAC_TYPE_64BIT_INT([long long int])
fi


dnl If we need to use "long long int", figure out whether nnnLL notation works.

if test x"$HAVE_LONG_LONG_INT_64" = xyes ; then
  AC_TRY_COMPILE([
#define INT64CONST(x)  x##LL
long long int foo = INT64CONST(0x1234567890123456);
],
	[],
	[AC_DEFINE(HAVE_LL_CONSTANTS, 1, [Define to 1 if constants of type 'long long int' should have the suffix LL.])],
	[])
fi


# If we found "long int" is 64 bits, assume snprintf handles it.  If
# we found we need to use "long long int", better check.  We cope with
# snprintfs that use %lld, %qd, or %I64d as the format.  If none of these
# work, fall back to our own snprintf emulation (which we know uses %lld).

if test "$HAVE_LONG_LONG_INT_64" = yes ; then
  if test $pgac_need_repl_snprintf = no; then
    PGAC_FUNC_SNPRINTF_LONG_LONG_INT_FORMAT
    if test "$LONG_LONG_INT_FORMAT" = ""; then
      # Force usage of our own snprintf, since system snprintf is broken
      pgac_need_repl_snprintf=yes
      LONG_LONG_INT_FORMAT='%lld'
    fi
  else
    # Here if we previously decided we needed to use our own snprintf
    LONG_LONG_INT_FORMAT='%lld'
  fi
  LONG_LONG_UINT_FORMAT=`echo "$LONG_LONG_INT_FORMAT" | sed 's/d$/u/'`
  INT64_FORMAT="\"$LONG_LONG_INT_FORMAT\""
  UINT64_FORMAT="\"$LONG_LONG_UINT_FORMAT\""
else
  # Here if we are not using 'long long int' at all
  INT64_FORMAT='"%ld"'
  UINT64_FORMAT='"%lu"'
fi

AC_DEFINE_UNQUOTED(INT64_FORMAT, $INT64_FORMAT,
                   [Define to the appropriate snprintf format for 64-bit ints, if any.])

AC_DEFINE_UNQUOTED(UINT64_FORMAT, $UINT64_FORMAT,
                   [Define to the appropriate snprintf format for unsigned 64-bit ints, if any.])

if test $pgac_need_repl_snprintf = yes; then
  AC_LIBOBJ(snprintf)
fi

# Need a #define for the size of Datum (unsigned long)
AC_CHECK_SIZEOF([unsigned long])

# Determine memory alignment requirements for the basic C data types.

PGAC_CHECK_ALIGNOF(short)
PGAC_CHECK_ALIGNOF(int)
PGAC_CHECK_ALIGNOF(long)
if test x"$HAVE_LONG_LONG_INT_64" = x"yes" ; then
  PGAC_CHECK_ALIGNOF(long long int)
fi
PGAC_CHECK_ALIGNOF(double)

# Compute maximum alignment of any basic type.
# We assume long's alignment is at least as strong as char, short, or int;
# but we must check long long (if it exists) and double.

MAX_ALIGNOF=$pgac_cv_alignof_long
if test $MAX_ALIGNOF -lt $pgac_cv_alignof_double ; then
  MAX_ALIGNOF=$pgac_cv_alignof_double
fi
if test x"$HAVE_LONG_LONG_INT_64" = xyes && test $MAX_ALIGNOF -lt $pgac_cv_alignof_long_long_int ; then
  MAX_ALIGNOF="$pgac_cv_alignof_long_long_int"
fi
AC_DEFINE_UNQUOTED(MAXIMUM_ALIGNOF, $MAX_ALIGNOF, [Define as the maximum alignment requirement of any C data type.])


# Some platforms predefine the types int8, int16, etc.  Only check
# a (hopefully) representative subset.
AC_CHECK_TYPES([int8, uint8, int64, uint64], [], [],
[#include <stdio.h>
#ifdef HAVE_SUPPORTDEFS_H
#include <SupportDefs.h>
#endif])

# We also check for sig_atomic_t, which *should* be defined per ANSI
# C, but is missing on some old platforms.
AC_CHECK_TYPES(sig_atomic_t, [], [], [#include <signal.h>])


PGAC_FUNC_POSIX_SIGNALS
if test $ac_cv_func_fseeko = yes; then
AC_SYS_LARGEFILE
fi


# Select semaphore implementation type.
if test x"$USE_NAMED_POSIX_SEMAPHORES" = x"1" ; then
  AC_DEFINE(USE_NAMED_POSIX_SEMAPHORES, 1, [Define to select named POSIX semaphores.])
  SEMA_IMPLEMENTATION="src/backend/port/posix_sema.c"
else
  if test x"$USE_UNNAMED_POSIX_SEMAPHORES" = x"1" ; then
    AC_DEFINE(USE_UNNAMED_POSIX_SEMAPHORES, 1, [Define to select unnamed POSIX semaphores.])
    SEMA_IMPLEMENTATION="src/backend/port/posix_sema.c"
  else
    AC_DEFINE(USE_SYSV_SEMAPHORES, 1, [Define to select SysV-style semaphores.])
    SEMA_IMPLEMENTATION="src/backend/port/sysv_sema.c"
  fi
fi


# Select shared-memory implementation type.
AC_DEFINE(USE_SYSV_SHARED_MEMORY, 1, [Define to select SysV-style shared memory.])
SHMEM_IMPLEMENTATION="src/backend/port/sysv_shmem.c"


if test "$enable_nls" = yes ; then
  PGAC_CHECK_GETTEXT
fi

# Check for Tcl configuration script tclConfig.sh
if test "$with_tcl" = yes; then
    PGAC_PATH_TCLCONFIGSH([$with_tclconfig])
    PGAC_EVAL_TCLCONFIGSH([$TCL_CONFIG_SH],
                          [TCL_INCLUDE_SPEC,TCL_LIB_FILE,TCL_LIBS,TCL_LIB_SPEC,TCL_SHARED_BUILD])
    AC_SUBST(TCL_SHLIB_LD_LIBS)dnl don't want to double-evaluate that one
fi

#
# Check for DocBook and tools
#
PGAC_PROG_NSGMLS
PGAC_PROG_JADE
PGAC_CHECK_DOCBOOK(4.2)
PGAC_PATH_DOCBOOK_STYLESHEETS
PGAC_PATH_COLLATEINDEX
AC_CHECK_PROGS(SGMLSPL, sgmlspl)

# Thread testing

# We have to run the thread test near the end so we have all our symbols
# defined.  Cross compiling throws a warning.
#
if test "$enable_thread_safety" = yes; then
AC_MSG_CHECKING([thread safety of required library functions])

_CFLAGS="$CFLAGS"
_LIBS="$LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS -DIN_CONFIGURE"
LIBS="$LIBS $PTHREAD_LIBS"
AC_TRY_RUN([#include "$srcdir/src/tools/thread/thread_test.c"],
  [AC_MSG_RESULT(yes)],
  [AC_MSG_RESULT(no)
  AC_MSG_ERROR([
*** Thread test program failed.  Your platform is not thread-safe.  
*** Check the file 'config.log'for the exact reason.])],
  [AC_MSG_RESULT(maybe)
  AC_MSG_WARN([
*** Skipping thread test program because of cross-compile build.
*** Run the program in src/tools/thread on the target matchine.
])])
CFLAGS="$_CFLAGS"
LIBS="$_LIBS"
fi

# prepare build tree if outside source tree
# Note 1: test -ef might not exist, but it's more reliable than `pwd`.
# Note 2: /bin/pwd might be better than shell's built-in at getting
#         a symlink-free name.
if ( test "$srcdir" -ef . ) >/dev/null 2>&1 || test "`cd $srcdir && /bin/pwd`" = "`/bin/pwd`"; then
  vpath_build=no
else
  vpath_build=yes
  if test "$no_create" != yes; then
    _AS_ECHO_N([preparing build tree... ])
    pgac_abs_top_srcdir=`cd "$srcdir" && pwd`
    $SHELL "$ac_aux_dir/prep_buildtree" "$pgac_abs_top_srcdir" "." \
      || AC_MSG_ERROR(failed)
    AC_MSG_RESULT(done)
  fi
fi
AC_SUBST(vpath_build)


AC_CONFIG_FILES([GNUmakefile src/Makefile.global])

AC_CONFIG_LINKS([
  src/backend/port/dynloader.c:src/backend/port/dynloader/${template}.c
  src/backend/port/pg_sema.c:${SEMA_IMPLEMENTATION}
  src/backend/port/pg_shmem.c:${SHMEM_IMPLEMENTATION}
  src/include/dynloader.h:src/backend/port/dynloader/${template}.h
  src/include/pg_config_os.h:src/include/port/${template}.h
  src/Makefile.port:src/makefiles/Makefile.${template}
])

case $host_os in mingw*)
AC_CONFIG_COMMANDS([check_win32_symlinks],[
# Links sometimes fail undetected on Mingw - 
# so here we detect it and warn the user
for FILE in $CONFIG_LINKS
 do
	# test -e works for symlinks in the MinGW console
	test -e `expr "$FILE" : '\(^:*\)'` || AC_MSG_WARN([*** link for $FILE - please fix by hand])
 done
])
	;;
esac

AC_CONFIG_HEADERS([src/include/pg_config.h],
[
# Update timestamp for pg_config.h (see Makefile.global)
echo >src/include/stamp-h
])

AC_OUTPUT