|
version 1.1, 2000/06/06 22:00:45
|
version 1.267, 2003/06/23 23:51:59
|
|
Line 1
|
Line 1
|
| dnl Process this file with autoconf to produce a configure script. |
dnl Process this file with autoconf to produce a configure script. |
| AC_INIT(src/backend/access/common/heaptuple.c) |
dnl $Header$ |
| |
dnl |
| |
dnl Developers, please strive to achieve this order: |
| |
dnl |
| |
dnl 0. Initialization and options processing |
| |
dnl 1. Programs |
| |
dnl 2. Libraries |
| |
dnl 3. Header files |
| |
dnl 4. Types |
| |
dnl 5. Structures |
| |
dnl 6. Compiler characteristics |
| |
dnl 7. Functions, global variables |
| |
dnl 8. System services |
| |
dnl |
| |
dnl Read the Autoconf manual for details. |
| |
dnl |
| |
m4_pattern_forbid(^PGAC_)dnl to catch undefined macros |
| |
dnl |
| |
dnl The GNU folks apparently haven't heard that some people don't use |
| |
dnl Texinfo. Use this sorcery to use "docdir" instead of "infodir". |
| |
m4_define([info], [doc]) |
| |
m4_define([infodir], [docdir]) |
| |
AC_INIT([PostgreSQL], [7.4devel], [[email protected]]) |
| |
m4_undefine([infodir]) |
| |
m4_undefine([info]) |
| |
AC_SUBST(docdir) |
| |
|
| |
AC_PREREQ(2.53) |
| |
AC_COPYRIGHT([Copyright 2002 PostgreSQL Global Development Group]) |
| |
AC_CONFIG_SRCDIR([src/backend/access/common/heaptuple.c]) |
| |
AC_CONFIG_AUX_DIR(config) |
| AC_PREFIX_DEFAULT(/usr/local/pgsql) |
AC_PREFIX_DEFAULT(/usr/local/pgsql) |
| AC_CONFIG_HEADER(src/include/config.h) |
AC_SUBST(configure_args, [$ac_configure_args]) |
| |
|
| AC_PREREQ(2.13) |
AC_DEFINE_UNQUOTED(PG_VERSION, "$PACKAGE_VERSION", [PostgreSQL version]) |
| AC_CONFIG_AUX_DIR(config) |
|
| |
|
| AC_CANONICAL_HOST |
AC_CANONICAL_HOST |
| |
|
| tas_file=dummy.s |
template= |
| case "$host_os" in |
AC_MSG_CHECKING([which template to use]) |
| solaris*) |
|
| case "$host_cpu" in |
PGAC_ARG_REQ(with, template, [], |
| sparc) os=solaris_sparc need_tas=yes tas_file=solaris_sparc.s ;; |
[ |
| i386) os=solaris_i386 need_tas=yes tas_file=solaris_i386.s ;; |
case $withval in |
| esac ;; |
list) echo; ls "$srcdir/src/template"; exit;; |
| sunos*) os=sunos4 need_tas=no ;; |
*) if test -f "$srcdir/src/template/$with_template" ; then |
| beos) os=beos need_tas=no ;; |
template=$withval |
| aux*) os=aux need_tas=no ;; |
else |
| linux*) os=linux need_tas=no ;; |
AC_MSG_ERROR(['$withval' is not a valid template name. Use 'list' for a list.]) |
| bsdi*) os=bsdi need_tas=no ;; |
fi;; |
| freebsd1*|freebsd2*) os=freebsd need_tas=no ;; |
esac |
| freebsd*) os=freebsd need_tas=no elf=yes ;; |
], |
| netbsd*) os=netbsd need_tas=no ;; |
[ |
| openbsd*) os=bsd need_tas=no ;; |
# --with-template not given |
| dgux*) os=dgux need_tas=no ;; |
|
| aix*) os=aix need_tas=no ;; |
case $host_os in |
| nextstep*) os=nextstep need_tas=no ;; |
aix*) template=aix ;; |
| ultrix*) os=ultrix4 need_tas=no ;; |
beos*) template=beos ;; |
| irix*) os=irix5 need_tas=no ;; |
bsdi*) template=bsdi ;; |
| hpux*) os=hpux need_tas=yes tas_file=hpux.s ;; |
cygwin*) template=cygwin ;; |
| osf*) os=alpha need_tas=no ;; |
darwin*) template=darwin ;; |
| sco*) os=sco need_tas=no ;; |
dgux*) template=dgux ;; |
| machten*) os=machten need_tas=no ;; |
freebsd*) template=freebsd ;; |
| cygwin*) os=win need_tas=no ;; |
hpux*) template=hpux ;; |
| |
irix*) template=irix5 ;; |
| |
linux*) template=linux ;; |
| |
mingw*) template=win32 ;; |
| |
netbsd*) template=netbsd ;; |
| |
nextstep*) template=nextstep ;; |
| |
openbsd*) template=openbsd ;; |
| |
osf*) template=osf ;; |
| |
qnx*) template=qnx4 ;; |
| |
sco*) template=sco ;; |
| |
solaris*) template=solaris ;; |
| |
sunos*) template=sunos4 ;; |
| sysv4.2*) |
sysv4.2*) |
| case "$host_vendor" in |
case $host_vendor in |
| univel) os=univel need_tas=no ;; |
univel) template=univel ;; |
| *) os=unknown need_tas=no ;; |
esac ;; |
| esac ;; |
sysv4*) template=svr4 ;; |
| sysv4*) os=svr4 need_tas=no ;; |
sysv5*) template=unixware ;; |
| sysv5uw*) os=unixware need_tas=no ;; |
ultrix*) template=ultrix4 ;; |
| unixware*) os=unixware need_tas=no ;; |
|
| qnx*) os=qnx4 need_tas=no ;; |
|
| *) echo "" |
|
| echo "*************************************************************" |
|
| echo "configure does not currently recognize your operating system," |
|
| echo "therefore you must do a manual configuration of:" |
|
| echo "$host_os" |
|
| echo "Please contact [email protected] to see about rectifying this, " |
|
| echo "including the above 'checking host system type...' line " |
|
| echo "*************************************************************" |
|
| echo "" |
|
| exit;; |
|
| esac |
esac |
| |
|
| PORTNAME=${os} |
if test x"$template" = x"" ; then |
| CPU=${host_cpu} |
AC_MSG_ERROR([[ |
| AC_LINK_FILES(src/backend/port/dynloader/${os}.c, src/backend/port/dynloader.c) |
******************************************************************* |
| AC_LINK_FILES(src/backend/port/dynloader/${os}.h, src/include/dynloader.h) |
PostgreSQL has apparently not been ported to your platform yet. |
| AC_LINK_FILES(src/include/port/${os}.h, src/include/os.h) |
To try a manual configuration, look into the src/template directory |
| AC_LINK_FILES(src/makefiles/Makefile.${os}, src/Makefile.port) |
for a similar platform and use the '--with-template=' option. |
| |
|
| |
Please also contact <[email protected]> to see about |
| |
rectifying this. Include the above 'checking host system type...' |
| |
line. |
| |
******************************************************************* |
| |
]]) |
| |
fi |
| |
|
| if test "X$need_tas" = "Xyes" |
]) |
| then |
|
| AC_LINK_FILES(src/backend/port/tas/${tas_file}, src/backend/port/tas.s) |
AC_MSG_RESULT([$template]) |
| TAS=tas.o |
|
| AC_SUBST(TAS) |
PORTNAME=$template |
| |
AC_SUBST(PORTNAME) |
| |
|
| |
# Pick right test-and-set (TAS) code. Most platforms have inline |
| |
# assembler code in src/include/storage/s_lock.h, so we just use |
| |
# a dummy file here. |
| |
case $host in |
| |
*-*-hpux*) need_tas=yes; tas_file=hpux.s ;; |
| |
sparc-*-solaris*) need_tas=yes; tas_file=solaris_sparc.s ;; |
| |
i?86-*-solaris*) need_tas=yes; tas_file=solaris_i386.s ;; |
| |
*) need_tas=no; tas_file=dummy.s ;; |
| |
esac |
| |
AC_CONFIG_LINKS([src/backend/port/tas.s:src/backend/port/tas/${tas_file}]) |
| |
|
| |
if test "$need_tas" = yes ; then |
| |
TAS=tas.o |
| fi |
fi |
| |
AC_SUBST(TAS) |
| |
|
| echo "checking echo setting..." |
|
| if echo '\c' | grep -s c >/dev/null 2>&1 |
|
| then |
## |
| ECHO_N="echo -n" |
## Command line options |
| ECHO_C="" |
## |
| |
|
| |
|
| |
# |
| |
# Add non-standard directories to the include path |
| |
# |
| |
PGAC_ARG_REQ(with, includes, [ --with-includes=DIRS look for additional header files in DIRS]) |
| |
|
| |
|
| |
# |
| |
# Add non-standard directories to the library search path |
| |
# |
| |
PGAC_ARG_REQ(with, libraries, [ --with-libraries=DIRS look for additional libraries in DIRS], |
| |
[LIBRARY_DIRS=$withval]) |
| |
|
| |
PGAC_ARG_REQ(with, libs, [ --with-libs=DIRS alternative spelling of --with-libraries], |
| |
[LIBRARY_DIRS=$withval]) |
| |
|
| |
|
| |
# |
| |
# 64-bit integer date/time storage (--enable-integer-datetimes) |
| |
# |
| |
AC_MSG_CHECKING([whether to build with 64-bit integer date/time support]) |
| |
PGAC_ARG_BOOL(enable, integer-datetimes, no, [ --enable-integer-datetimes enable 64-bit integer date/time support], |
| |
[AC_DEFINE([USE_INTEGER_DATETIMES], 1, |
| |
[Define to 1 if you want 64-bit integer timestamp and interval support. (--enable-integer-datetimes)])]) |
| |
AC_MSG_RESULT([$enable_integer_datetimes]) |
| |
|
| |
|
| |
# Character set recode (--enable-recode) |
| |
# |
| |
AC_MSG_CHECKING([whether to build with recode support]) |
| |
PGAC_ARG_BOOL(enable, recode, no, [ --enable-recode enable single-byte recode support], |
| |
[AC_DEFINE([CYR_RECODE], 1, |
| |
[Define to 1 if you want single-byte recode support. (--enable-recode)])]) |
| |
AC_MSG_RESULT([$enable_recode]) |
| |
|
| |
|
| |
# |
| |
# NLS |
| |
# |
| |
AC_MSG_CHECKING([whether NLS is wanted]) |
| |
PGAC_ARG_OPTARG(enable, nls, |
| |
[[ --enable-nls[=LANGUAGES] enable Native Language Support]], |
| |
[], |
| |
[WANTED_LANGUAGES=$enableval], |
| |
[AC_DEFINE(ENABLE_NLS, 1, |
| |
[Define to 1 if you want National Language Support. (--enable-nls)])]) |
| |
AC_MSG_RESULT([$enable_nls]) |
| |
AC_SUBST(enable_nls) |
| |
AC_SUBST(WANTED_LANGUAGES) |
| |
|
| |
# |
| |
# Default port number (--with-pgport), default 5432 |
| |
# |
| |
AC_MSG_CHECKING([for default port number]) |
| |
PGAC_ARG_REQ(with, pgport, [ --with-pgport=PORTNUM change default port number [5432]], |
| |
[default_port=$withval], |
| |
[default_port=5432]) |
| |
AC_MSG_RESULT([$default_port]) |
| |
# Need both of these because some places want an integer and some a string |
| |
AC_DEFINE_UNQUOTED(DEF_PGPORT, ${default_port}, |
| |
[Define to the default TCP port number on which the server listens and |
| |
to which clients will try to connect to. This can be overridden at |
| |
run-time, but it's convenient if your clients have the right default |
| |
compiled in. (--with-pgport=PORTNUM)]) |
| |
AC_DEFINE_UNQUOTED(DEF_PGPORT_STR, "${default_port}", |
| |
[Define to the default TCP port number as string constant.]) |
| |
AC_SUBST(default_port) |
| |
|
| |
# |
| |
# Option to disable shared libraries |
| |
# |
| |
PGAC_ARG_BOOL(enable, shared, yes, |
| |
[ --disable-shared do not build shared libraries]) |
| |
AC_SUBST(enable_shared) |
| |
|
| |
# |
| |
# '-rpath'-like feature can be disabled |
| |
# |
| |
PGAC_ARG_BOOL(enable, rpath, yes, |
| |
[ --disable-rpath do not embed shared library search path in executables]) |
| |
AC_SUBST(enable_rpath) |
| |
|
| |
|
| |
# |
| |
# --enable-debug adds -g to compiler flags |
| |
# |
| |
PGAC_ARG_BOOL(enable, debug, no, |
| |
[ --enable-debug build with debugging symbols (-g)]) |
| |
AC_SUBST(enable_debug) |
| |
|
| |
# |
| |
# C compiler |
| |
# |
| |
|
| |
# For historical reasons you can also use --with-CC to specify the C compiler |
| |
# to use, although the standard way to do this is to set the CC environment |
| |
# variable. |
| |
PGAC_ARG_REQ(with, CC, [], [CC=$with_CC]) |
| |
|
| |
case $template in |
| |
aix) pgac_cc_list="gcc xlc";; |
| |
irix) pgac_cc_list="cc";; # no gcc |
| |
*) pgac_cc_list="gcc cc";; |
| |
esac |
| |
|
| |
AC_PROG_CC([$pgac_cc_list]) |
| |
# Read the template |
| |
. "$srcdir/src/template/$template" || exit |
| |
|
| |
if test "$ac_env_CFLAGS_set" = set; then |
| |
CFLAGS=$ac_env_CFLAGS_value |
| |
fi |
| |
if test "$enable_debug" = yes && test "$ac_cv_prog_cc_g" = yes; then |
| |
CFLAGS="$CFLAGS -g" |
| |
fi |
| |
AC_MSG_NOTICE([using CFLAGS=$CFLAGS]) |
| |
|
| |
# Check if the compiler still works with the template settings |
| |
AC_MSG_CHECKING([whether the C compiler still works]) |
| |
AC_TRY_LINK([], [return 0;], |
| |
[AC_MSG_RESULT(yes)], |
| |
[AC_MSG_RESULT(no) |
| |
AC_MSG_ERROR([cannot proceed])]) |
| |
|
| |
# Defend against gcc -ffastmath |
| |
if test "$GCC" = yes; then |
| |
AC_TRY_COMPILE([], [@%:@ifdef __FAST_MATH__ |
| |
choke me |
| |
@%:@endif], [], [AC_MSG_ERROR([do not put -ffast-math in CFLAGS])]) |
| |
fi |
| |
|
| |
AC_PROG_CPP |
| |
AC_SUBST(GCC) |
| |
|
| |
# Create compiler version string |
| |
if test x"$GCC" = x"yes" ; then |
| |
cc_string="GCC `${CC} --version | sed q`" |
| else |
else |
| ECHO_N="echo" |
cc_string=$CC |
| ECHO_C='\c' |
|
| fi |
fi |
| |
AC_DEFINE_UNQUOTED(PG_VERSION_STR, |
| |
["PostgreSQL $PACKAGE_VERSION on $host, compiled by $cc_string"], |
| |
[A string containing the version number, platform, and C compiler]) |
| |
|
| |
|
| |
# |
| |
# Automatic dependency tracking |
| |
# |
| |
PGAC_ARG_BOOL(enable, depend, no, [ --enable-depend turn on automatic dependency tracking], |
| |
[autodepend=yes]) |
| |
AC_SUBST(autodepend) |
| |
|
| |
|
| |
# |
| |
# Enable assert checks |
| |
# |
| |
PGAC_ARG_BOOL(enable, cassert, no, [ --enable-cassert enable assertion checks (for debugging)], |
| |
[AC_DEFINE([USE_ASSERT_CHECKING], 1, |
| |
[Define to 1 to build with assertion checks. (--enable-cassert)])]) |
| |
|
| |
|
| |
# |
| |
# Include directories |
| |
# |
| |
ac_save_IFS=$IFS |
| |
IFS="${IFS}:" |
| |
# SRCH_INC comes from the template file |
| |
for dir in $with_includes $SRCH_INC; do |
| |
if test -d "$dir"; then |
| |
INCLUDES="$INCLUDES -I$dir" |
| |
else |
| |
AC_MSG_WARN([*** Include directory $dir does not exist.]) |
| |
fi |
| |
done |
| |
IFS=$ac_save_IFS |
| |
AC_SUBST(INCLUDES) |
| |
|
| |
|
| dnl this part selects the template from the ones in the template directory. |
# |
| |
# Library directories |
| |
# |
| |
ac_save_IFS=$IFS |
| |
IFS="${IFS}:" |
| |
# LIBRARY_DIRS comes from command line, SRCH_LIB from template file. |
| |
for dir in $LIBRARY_DIRS $SRCH_LIB; do |
| |
if test -d "$dir"; then |
| |
LIBDIRS="$LIBDIRS -L$dir" |
| |
else |
| |
AC_MSG_WARN([*** Library directory $dir does not exist.]) |
| |
fi |
| |
done |
| |
IFS=$ac_save_IFS |
| |
|
| AC_MSG_CHECKING(setting template to) |
# |
| AC_ARG_WITH(template, |
# Enable libpq to be thread-safe |
| [ --with-template=TEMPLATE |
# |
| use operating system template file |
AC_MSG_CHECKING([allow threaded libpq]) |
| see template directory], |
PGAC_ARG_BOOL(with, threads, no, [ --with-threads allow libpq and ecpg to be thread-safe], |
| [ TEMPLATE=$withval ], |
[AC_DEFINE([USE_THREADS], 1, [Define to 1 to build libpq and ecpg to be thread-safe. (--with-threads)])]) |
| [ |
|
| |
AC_MSG_RESULT([$with_threads]) |
| # lowercase $host |
AC_SUBST(with_threads) |
| host="`echo $host | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`" |
|
| |
# |
| # First, try for a template exactly matching $host |
# Tcl/Tk |
| if test -f "src/template/$host" |
# |
| then TEMPLATE="$host" |
AC_MSG_CHECKING([whether to build with Tcl]) |
| |
PGAC_ARG_BOOL(with, tcl, no, [ --with-tcl build Tcl and Tk interfaces]) |
| |
AC_MSG_RESULT([$with_tcl]) |
| |
AC_SUBST([with_tcl]) |
| |
|
| |
# If Tcl is enabled (above) then Tk is also, unless the user disables it using --without-tk |
| |
AC_MSG_CHECKING([whether to build with Tk]) |
| |
if test "$with_tcl" = yes; then |
| |
PGAC_ARG_BOOL(with, tk, yes, [ --without-tk do not build Tk interfaces if Tcl is enabled]) |
| else |
else |
| # Scan template/.similar for a rule that tells us which template to use. |
with_tk=no |
| # The format of each line of the file is |
|
| # hostnamepattern=templatefilename |
|
| # where the hostnamepattern is evaluated per the rules of expr(1) --- |
|
| # namely, it is a standard regular expression with an implicit ^ at the |
|
| # start. If multiple lines match, we will end up using the last match. |
|
| # |
|
| # The tempfile hackery is needed because some shells will run the loop |
|
| # inside a subshell, whereupon shell variables set therein aren't seen |
|
| # outside the loop :-( |
|
| TMPFILE="guesses.$$" |
|
| cat /dev/null > $TMPFILE |
|
| while read LINE |
|
| do |
|
| SIMHOST=`expr "$LINE" : '\(.*\)='` |
|
| MATCH=`expr "$host" : "$SIMHOST"` |
|
| if test "$MATCH" != 0 |
|
| then |
|
| echo "$LINE" | sed 's/^.*=//' > $TMPFILE |
|
| fi |
|
| done <src/template/.similar |
|
| GUESS=`cat $TMPFILE` |
|
| rm -f $TMPFILE |
|
| if test "$GUESS" |
|
| then TEMPLATE="$GUESS" |
|
| else |
|
| # Last chance ... maybe uname -s will match an entry. |
|
| TEMPLATE=`uname -s | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` |
|
| fi |
|
| fi |
fi |
| ]) |
AC_MSG_RESULT([$with_tk]) |
| AC_MSG_RESULT($TEMPLATE) |
AC_SUBST([with_tk]) |
| |
|
| export TEMPLATE |
|
| if test ! -f "src/template/$TEMPLATE"; then |
|
| echo "" |
|
| echo "$TEMPLATE does not exist" |
|
| echo "" |
|
| echo "Available Templates (select one using --with-template):" |
|
| echo "" |
|
| ls template |
|
| echo "" |
|
| exit |
|
| fi |
|
| |
|
| dnl Read the selected template file. |
|
| dnl For reasons of backwards compatibility, lines of the form |
|
| dnl IDENTIFIER: something |
|
| dnl should be treated as variable assignments. However, we also want to |
|
| dnl allow other shell commands in the template file (in case the file |
|
| dnl needs to make conditional tests, etc). So, generate a temp file with |
|
| dnl the IDENTIFIER: lines translated, then source it. |
|
| |
|
| |
# We see if the path to the Tcl/Tk configuration scripts is specified. |
| |
# This will override the use of tclsh to find the paths to search. |
| |
|
| |
PGAC_ARG_REQ(with, tclconfig, [ --with-tclconfig=DIR tclConfig.sh and tkConfig.sh are in DIR]) |
| |
|
| |
# We see if the path to the Tk configuration scripts is specified. |
| |
# This will override the use of tclsh to find the paths to search. |
| |
|
| |
PGAC_ARG_REQ(with, tkconfig, [ --with-tkconfig=DIR tkConfig.sh is in DIR]) |
| |
|
| |
# |
| |
# Optionally build Perl modules (PL/Perl) |
| |
# |
| |
AC_MSG_CHECKING([whether to build Perl modules]) |
| |
PGAC_ARG_BOOL(with, perl, no, [ --with-perl build Perl modules (PL/Perl)]) |
| |
AC_MSG_RESULT([$with_perl]) |
| |
AC_SUBST(with_perl) |
| |
|
| |
# |
| |
# Optionally build Python interface module |
| |
# |
| |
AC_MSG_CHECKING([whether to build Python modules]) |
| |
PGAC_ARG_BOOL(with, python, no, [ --with-python build Python interface module]) |
| |
AC_MSG_RESULT([$with_python]) |
| |
AC_SUBST(with_python) |
| |
|
| |
# |
| |
# Optionally build the Java/JDBC tools |
| |
# |
| |
AC_MSG_CHECKING([whether to build Java/JDBC tools]) |
| |
PGAC_ARG_BOOL(with, java, no, [ --with-java build JDBC interface and Java tools], |
| |
[AC_MSG_RESULT(yes) |
| |
PGAC_PATH_ANT |
| |
if test -z "$ANT"; then |
| |
AC_MSG_ERROR([Ant is required to build Java components |
| |
If you have Ant already installed, see config.log for details on the failure.]) |
| |
fi |
| |
if "$ANT" -version | sed q | egrep -v ' 1\.[[5-9]]| [[2-9]]\.' >/dev/null ; then |
| |
AC_MSG_ERROR([Ant version >= 1.5 is required to build Java components]) |
| |
fi], |
| |
[AC_MSG_RESULT(no)]) |
| |
AC_SUBST(with_java) |
| |
|
| |
dnl A note on the Kerberos and OpenSSL options: |
| |
dnl |
| |
dnl The user can give an argument to the option in order the specify |
| |
dnl the base path of the respective installation (what he specified |
| |
dnl perhaps as --prefix). If no argument is given ($withval is "yes") |
| |
dnl then we take the path where the package installs by default. This |
| |
dnl way the user doesn't have to use redundant --with-includes and |
| |
dnl --with-libraries options, but he can still use them if the layout |
| |
dnl is non-standard. |
| |
|
| |
# |
| |
# Kerberos 4 |
| |
# |
| |
AC_MSG_CHECKING([whether to build with Kerberos 4 support]) |
| |
PGAC_ARG_OPTARG(with, krb4, [[ --with-krb4[=DIR] build with Kerberos 4 support [/usr/athena]]], |
| |
[krb4_prefix=/usr/athena], |
| |
[krb4_prefix=$withval], |
| [ |
[ |
| rm -f conftest.sh |
AC_MSG_RESULT(yes) |
| sed 's/^\([A-Za-z_]*\):\(.*\)$/\1="\2"/' "src/template/$TEMPLATE" >conftest.sh |
AC_DEFINE(KRB4, 1, [Define to build with Kerberos 4 support. (--with-krb4)]) |
| . ./conftest.sh |
|
| rm -f conftest.sh |
|
| ] |
|
| |
|
| |
|
| AC_ARG_WITH(includes, |
|
| [ --with-includes=DIRS look for header files for tcl/tk, etc in DIRS], |
|
| [ |
|
| case "$withval" in |
|
| "" | y | ye | yes | n | no) |
|
| AC_MSG_ERROR([*** You must supply an argument to the --with-includes option.]) |
|
| ;; |
|
| esac |
|
| INCLUDE_DIRS="$withval" |
|
| ]) |
|
| |
|
| dnl INCLUDE_DIRS comes from command line, SRCH_INC from template file. |
|
| dnl Each can name one or more directories. |
|
| if test "$INCLUDE_DIRS" -o "$SRCH_INC"; then |
|
| for dir in $INCLUDE_DIRS $SRCH_INC; do |
|
| if test -d "$dir"; then |
|
| PGSQL_INCLUDES="$PGSQL_INCLUDES -I$dir" |
|
| else |
|
| AC_MSG_WARN([*** Include directory $dir does not exist.]) |
|
| fi |
|
| done |
|
| fi |
|
| |
|
| AC_ARG_WITH(libraries, |
|
| [ --with-libraries=DIRS look for additional libraries in DIRS], |
|
| [ |
|
| case "$withval" in |
|
| "" | y | ye | yes | n | no) |
|
| AC_MSG_ERROR([*** You must supply an argument to the --with-libraries option.]) |
|
| ;; |
|
| esac |
|
| LIBRARY_DIRS="$withval" |
|
| ]) |
|
| |
|
| AC_ARG_WITH(libs, |
|
| [ --with-libs=DIRS alternate spelling of --with-libraries], |
|
| [ |
|
| case "$withval" in |
|
| "" | y | ye | yes | n | no) |
|
| AC_MSG_ERROR([*** You must supply an argument to the --with-libs option.]) |
|
| ;; |
|
| esac |
|
| LIBRARY_DIRS="$withval" |
|
| ]) |
|
| |
|
| dnl LIBRARY_DIRS comes from command line, SRCH_LIB from template file. |
|
| dnl Each can name one or more directories. |
|
| if test "$LIBRARY_DIRS" -o "$SRCH_LIB"; then |
|
| for dir in $LIBRARY_DIRS $SRCH_LIB; do |
|
| if test -d "$dir"; then |
|
| PGSQL_LDFLAGS="$PGSQL_LDFLAGS -L$dir" |
|
| else |
|
| AC_MSG_WARN([*** Library directory $dir does not exist.]) |
|
| fi |
|
| done |
|
| fi |
|
| |
|
| dnl We have read the default value of USE_LOCALE from the template |
|
| dnl file. We have a further option of using |
|
| dnl --enable-locale to explicitly enable it |
|
| dnl It defaults to disabled |
|
| AC_MSG_CHECKING(whether to support locale) |
|
| AC_ARG_ENABLE( |
|
| locale, |
|
| [ --enable-locale enable locale support ], |
|
| AC_DEFINE(USE_LOCALE) AC_MSG_RESULT(enabled), |
|
| AC_MSG_RESULT(disabled) |
|
| ) |
|
| |
|
| dnl We exclude cyrillic recode support unless we override it with |
|
| dnl --enable-recode to explicitly enable it |
|
| dnl It defaults to disabled |
|
| AC_MSG_CHECKING(whether to support cyrillic recode) |
|
| AC_ARG_ENABLE( |
|
| recode, |
|
| [ --enable-recode enable cyrillic recode support ], |
|
| AC_DEFINE(CYR_RECODE) AC_MSG_RESULT(enabled), |
|
| AC_MSG_RESULT(disabled) |
|
| ) |
|
| |
|
| dnl Multibyte support |
|
| |
|
| AC_MSG_CHECKING(whether to support multibyte) |
|
| AC_ARG_ENABLE(multibyte, |
|
| [ --enable-multibyte enable multibyte character support ], |
|
| [ |
|
| MULTIBYTE=SQL_ASCII |
|
| if test "$enableval" != "yes"; then |
|
| case "$enableval" in |
|
| SQL_ASCII|EUC_JP|EUC_CN|EUC_KR|EUC_TW|UNICODE|MULE_INTERNAL|LATIN1|LATIN2|LATIN3|LATIN4|LATIN5|KOI8|WIN|ALT) |
|
| # ok |
|
| ;; |
|
| *) |
|
| AC_MSG_ERROR( |
|
| [Argument to --enable-multibyte must be one of: |
|
| SQL_ASCII, EUC_JP, EUC_CN, EUC_KR, EUC_TW, |
|
| UNICODE, MULE_INTERNAL, |
|
| LATIN1, LATIN2, LATIN3, LATIN4, LATIN5, |
|
| KOI8, WIN, ALT |
|
| Or do not specify an argument to the option to use the default.]) |
|
| esac |
|
| MULTIBYTE=$enableval |
|
| fi |
|
| AC_DEFINE(MULTIBYTE) |
|
| AC_MSG_RESULT(enabled) |
|
| ], |
|
| AC_MSG_RESULT("disabled") |
|
| ) |
|
| |
|
| dnl Old option variant |
|
| if test "${with_mb}"; then |
|
| AC_MSG_ERROR([--with-mb is not supported anymore. Use --enable-multibyte instead.]) |
|
| fi |
|
| |
|
| |
|
| dnl We use the default value of 5432 for the DEF_PGPORT value. If |
|
| dnl we over-ride it with --with-pgport=port then we bypass this piece |
|
| AC_MSG_CHECKING(setting DEF_PGPORT) |
|
| AC_ARG_WITH( |
|
| pgport, |
|
| [ --with-pgport=PORTNUM change default postmaster port ], |
|
| [default_port="$withval"], |
|
| [default_port=5432] |
|
| ) |
|
| dnl Need to do this twice because backend wants an integer and frontend a string |
|
| AC_DEFINE_UNQUOTED(DEF_PGPORT, ${default_port}) |
|
| AC_DEFINE_UNQUOTED(DEF_PGPORT_STR, "${default_port}") |
|
| AC_MSG_RESULT(${default_port}) |
|
| |
|
| |
|
| dnl DEF_MAXBACKENDS can be set by --with-maxbackends. Default value is 32. |
|
| AC_MSG_CHECKING(setting DEF_MAXBACKENDS) |
|
| AC_ARG_WITH( |
|
| maxbackends, |
|
| [ --with-maxbackends=N set default maximum number of server processes ], |
|
| AC_DEFINE_UNQUOTED(DEF_MAXBACKENDS, ${withval}) AC_MSG_RESULT($with_maxbackends), |
|
| AC_DEFINE_UNQUOTED(DEF_MAXBACKENDS, 32) AC_MSG_RESULT(32) |
|
| ) |
|
| |
|
| dnl We exclude tcl support unless user says --with-tcl |
|
| AC_MSG_CHECKING(setting USE_TCL) |
|
| AC_ARG_WITH( |
|
| tcl, |
|
| [ --with-tcl build Tcl interfaces and pgtclsh ], |
|
| [ |
|
| case "$withval" in |
|
| y | ye | yes) USE_TCL=true; USE_TK=true; AC_MSG_RESULT(enabled) ;; |
|
| *) USE_TCL=; USE_TK=; AC_MSG_RESULT(disabled) ;; |
|
| esac |
|
| ], |
|
| [ USE_TCL=; USE_TK=; AC_MSG_RESULT(disabled) ] |
|
| ) |
|
| |
|
| export USE_TCL |
|
| export USE_TK |
|
| |
|
| dnl We see if the path to the TCL/TK configuration scripts is specified. |
|
| dnl This will override the use of tclsh to find the paths to search. |
|
| |
|
| AC_ARG_WITH(tclconfig, |
|
| [ --with-tclconfig=DIR tclConfig.sh and tkConfig.sh are in DIR], |
|
| [ |
|
| case "$withval" in |
|
| "" | y | ye | yes | n | no) |
|
| AC_MSG_ERROR([*** You must supply an argument to the --with-tclconfig option.]) |
|
| ;; |
|
| esac |
|
| TCL_DIRS="$withval" |
|
| ] |
|
| ) |
|
| |
|
| dnl We see if the path to the TK configuration scripts is specified. |
|
| dnl This will override the use of tclsh to find the paths to search. |
|
| |
|
| AC_ARG_WITH(tkconfig, |
|
| [ --with-tkconfig=DIR tkConfig.sh is in DIR], |
|
| [ |
|
| case "$withval" in |
|
| "" | y | ye | yes | n | no) |
|
| AC_MSG_ERROR([*** You must supply an argument to the --with-tkconfig option.]) |
|
| ;; |
|
| esac |
|
| TK_DIRS="$withval" |
|
| ] |
|
| ) |
|
| |
|
| dnl We exclude perl support unless we override it with --with-perl |
|
| AC_MSG_CHECKING(setting USE_PERL) |
|
| AC_ARG_WITH( |
|
| perl, |
|
| [ --with-perl build Perl interface and plperl ], |
|
| [ |
|
| case "$withval" in |
|
| y | ye | yes) USE_PERL=true; AC_MSG_RESULT(enabled) ;; |
|
| *) USE_PERL=false; AC_MSG_RESULT(disabled) ;; |
|
| esac |
|
| ], |
|
| [ USE_PERL=false; AC_MSG_RESULT(disabled) ] |
|
| ) |
|
| |
|
| dnl We include odbc support unless we disable it with --with-odbc=false |
|
| AC_MSG_CHECKING(setting USE_ODBC) |
|
| AC_ARG_WITH( |
|
| odbc, |
|
| [ --with-odbc build ODBC driver package ], |
|
| [ |
|
| case "$withval" in |
|
| y | ye | yes) USE_ODBC=true; AC_MSG_RESULT(enabled) ;; |
|
| *) USE_ODBC=false; AC_MSG_RESULT(disabled) ;; |
|
| esac |
|
| ], |
|
| [ USE_ODBC=false; AC_MSG_RESULT(disabled) ] |
|
| ) |
|
| export USE_ODBC |
|
| |
|
| |
|
| dnl Allow for overriding the default location of the odbcinst.ini |
|
| dnl file which is normally ${prefix}/share or ${prefix} if this is |
|
| dnl being compiled inside the postgres distribution. |
|
| dnl Link in the port and template directories |
|
| dnl to help build a "standalone ODBC" tar file |
|
| if test "X$USE_ODBC" = "Xtrue" |
|
| then |
|
| AC_LINK_FILES(src/include/port, src/interfaces/odbc/port) |
|
| AC_LINK_FILES(src/makefiles, src/interfaces/odbc/makefiles) |
|
| AC_LINK_FILES(src/template, src/interfaces/odbc/template) |
|
| AC_LINK_FILES(src/include/config.h, src/interfaces/odbc/config.h) |
|
| |
|
| AC_MSG_CHECKING(setting ODBCINST) |
|
| AC_ARG_WITH( |
|
| odbcinst, |
|
| [ --with-odbcinst=DIR change default directory for odbcinst.ini], |
|
| AC_DEFINE_UNQUOTED(ODBCINST, ${with_odbcinst}) AC_MSG_RESULT($with_odbcinst), |
|
| AC_DEFINE_UNQUOTED(ODBCINST, ${ODBCINSTDIR}) AC_MSG_RESULT(${ODBCINSTDIR}) |
|
| ) |
|
| fi |
|
| if test "X$with_odbcinst" != "X" |
|
| then |
|
| ODBCINSTDIR=$with_odbcinst |
|
| fi |
|
| AC_SUBST(ODBCINSTDIR) |
|
| |
|
| dnl Unless we specify the command line options |
if test -d "$krb4_prefix/include"; then |
| dnl --enable cassert to explicitly enable it |
INCLUDES="$INCLUDES -I$krb4_prefix/include" |
| dnl If you do not explicitly do it, it defaults to disabled |
fi |
| AC_MSG_CHECKING(setting ASSERT CHECKING) |
if test -d "$krb4_prefix/lib"; then |
| AC_ARG_ENABLE( |
LIBDIRS="$LIBDIRS -L$krb4_prefix/lib" |
| cassert, |
fi |
| [ --enable-cassert enable assertion checks (for debugging) ], |
|
| AC_DEFINE(USE_ASSERT_CHECKING) AC_MSG_RESULT(enabled), |
|
| AC_MSG_RESULT(disabled) |
|
| ) |
|
| |
|
| dnl Check for C support (allow override if needed) |
|
| dnl Note: actually, setting CC environment variable works just as well. |
|
| AC_ARG_WITH(CC, |
|
| [ --with-CC=compiler use specific C compiler], |
|
| [ |
|
| case "$withval" in |
|
| "" | y | ye | yes | n | no) |
|
| AC_MSG_ERROR([*** You must supply an argument to the --with-CC option.]) |
|
| ;; |
|
| esac |
|
| CC="$withval" |
|
| ]) |
|
| |
|
| dnl Find a compiler if CC is not already set. |
|
| AC_PROG_CC |
|
| dnl Find CPP, then check traditional. |
|
| dnl Caution: these macros must be called in this order... |
|
| AC_PROG_CPP |
|
| AC_PROG_GCC_TRADITIONAL |
|
| |
|
| if test "$CC" = "gcc" |
krb_srvtab="/etc/srvtab" |
| then |
], |
| CC_VERSION=`${CC} --version` |
[AC_MSG_RESULT(no)]) |
| else |
|
| CC_VERSION="" |
|
| fi |
|
| AC_SUBST(CC_VERSION) |
|
| |
|
| CPPFLAGS="$CPPFLAGS $PGSQL_INCLUDES" |
AC_SUBST(with_krb4) |
| echo "- setting CPPFLAGS=$CPPFLAGS" |
|
| |
|
| LDFLAGS="$LDFLAGS $PGSQL_LDFLAGS" |
|
| echo "- setting LDFLAGS=$LDFLAGS" |
# |
| |
# Kerberos 5 |
| dnl --enable-debug adds -g to compiler flags |
# |
| dnl --disable-debug will forcefully remove it |
AC_MSG_CHECKING([whether to build with Kerberos 5 support]) |
| AC_MSG_CHECKING(setting debug compiler flag) |
PGAC_ARG_OPTARG(with, krb5, [[ --with-krb5[=DIR] build with Kerberos 5 support [/usr/athena]]], |
| AC_ARG_ENABLE( |
[krb5_prefix=/usr/athena], |
| debug, |
[krb5_prefix=$withval], |
| [ --enable-debug build with debugging symbols (-g) ], |
[ |
| [ |
AC_MSG_RESULT([yes]) |
| case "$enableval" in |
AC_DEFINE(KRB5, 1, [Define to build with Kerberos 5 support. (--with-krb5)]) |
| y | ye | yes) |
|
| CFLAGS="$CFLAGS -g" |
if test -d "$krb5_prefix/include"; then |
| AC_MSG_RESULT(enabled) |
INCLUDES="$INCLUDES -I$krb5_prefix/include" |
| ;; |
fi |
| *) |
if test -d "$krb5_prefix/lib"; then |
| CFLAGS=`echo "$CFLAGS" | sed -e 's/ -g/ /g' | sed -e 's/^-g//'` |
LIBDIRS="$LIBDIRS -L$krb5_prefix/lib" |
| AC_MSG_RESULT(disabled) |
fi |
| ;; |
|
| esac |
krb_srvtab="FILE:\$(sysconfdir)/krb5.keytab" |
| ], |
], |
| AC_MSG_RESULT(using default) |
[AC_MSG_RESULT(no)]) |
| ) |
|
| |
AC_SUBST(with_krb5) |
| |
|
| |
|
| |
# Using both Kerberos 4 and Kerberos 5 at the same time isn't going to work. |
| |
if test "$with_krb4" = yes && test "$with_krb5" = yes ; then |
| |
AC_MSG_ERROR([Kerberos 4 and Kerberos 5 support cannot be combined]) |
| |
fi |
| |
|
| |
AC_SUBST(krb_srvtab) |
| |
|
| |
|
| |
# |
| |
# Kerberos configuration parameters |
| |
# |
| |
PGAC_ARG_REQ(with, krb-srvnam, |
| |
[ --with-krb-srvnam=NAME name of the service principal in Kerberos [postgres]], |
| |
[], |
| |
[with_krb_srvnam="postgres"]) |
| |
AC_DEFINE_UNQUOTED([PG_KRB_SRVNAM], ["$with_krb_srvnam"], |
| |
[Define to the name of the PostgreSQL service principal in Kerberos. (--with-krb-srvnam=NAME)]) |
| |
|
| |
|
| |
# |
| |
# PAM |
| |
# |
| |
AC_MSG_CHECKING([whether to build with PAM support]) |
| |
PGAC_ARG_BOOL(with, pam, no, |
| |
[ --with-pam build with PAM support], |
| |
[AC_DEFINE([USE_PAM], 1, [Define to 1 to build with PAM support. (--with-pam)])]) |
| |
AC_MSG_RESULT([$with_pam]) |
| |
AC_SUBST(with_pam) |
| |
|
| |
|
| |
# |
| |
# Rendezvous |
| |
# |
| |
AC_MSG_CHECKING([whether to build with Rendezvous support]) |
| |
PGAC_ARG_BOOL(with, rendezvous, no, |
| |
[ --with-rendezvous build with Rendezvous support], |
| |
[AC_DEFINE([USE_RENDEZVOUS], 1, [Define to 1 to build with Rendezvous support. (--with-rendezvous)])]) |
| |
AC_MSG_RESULT([$with_rendezvous]) |
| |
AC_SUBST(with_rendezvous) |
| |
|
| |
|
| |
# |
| |
# OpenSSL |
| |
# |
| |
PGAC_ARG_OPTARG(with, openssl, |
| |
[[ --with-openssl[=DIR] build with OpenSSL support [/usr/local/ssl]]], |
| |
[openssl_prefix=/usr/local/ssl], |
| |
[openssl_prefix=$withval], |
| |
[ |
| |
AC_MSG_RESULT([building with OpenSSL support]) |
| |
AC_DEFINE([USE_SSL], 1, [Define to build with (Open)SSL support. (--with-openssl)]) |
| |
|
| |
if test -d "${openssl_prefix}/include" ; then |
| |
INCLUDES="$INCLUDES -I${openssl_prefix}/include" |
| |
fi |
| |
if test -d "${openssl_prefix}/lib" ; then |
| |
LIBDIRS="$LIBDIRS -L${openssl_prefix}/lib" |
| |
fi |
| |
]) |
| |
|
| |
AC_SUBST(with_openssl) |
| |
|
| |
|
| |
# |
| |
# Readline |
| |
# |
| |
PGAC_ARG_BOOL(with, readline, yes, |
| |
[ --without-readline do not use Readline]) |
| |
|
| |
# |
| |
# Zlib |
| |
# |
| |
PGAC_ARG_BOOL(with, zlib, yes, |
| |
[ --without-zlib do not use Zlib]) |
| |
|
| |
|
| |
# |
| |
# Elf |
| |
# |
| |
|
| # Assume system is ELF if it predefines __ELF__ as 1, |
# Assume system is ELF if it predefines __ELF__ as 1, |
| # otherwise believe "elf" setting from check of host_os above. |
# otherwise believe host_os based default. |
| |
case $host_os in |
| |
freebsd1*|freebsd2*) elf=no;; |
| |
freebsd3*|freebsd4*) elf=yes;; |
| |
esac |
| |
|
| AC_EGREP_CPP(yes, |
AC_EGREP_CPP(yes, |
| [#if __ELF__ |
[#if __ELF__ |
| yes |
yes |
| #endif |
#endif |
| ], |
], |
| ELF_SYS=true, |
[ELF_SYS=true], |
| [if test "X$elf" = "Xyes" |
[if test "X$elf" = "Xyes" ; then |
| then |
ELF_SYS=true |
| ELF_SYS=true |
|
| else |
else |
| ELF_SYS= |
ELF_SYS= |
| fi |
fi]) |
| ]) |
|
| |
|
| AC_SUBST(ELF_SYS) |
AC_SUBST(ELF_SYS) |
| AC_SUBST(PORTNAME) |
|
| AC_SUBST(CPU) |
|
| AC_SUBST(SRCDIR) |
|
| AC_SUBST(LDFLAGS) |
|
| AC_SUBST(CPPFLAGS) |
|
| AC_SUBST(PGSQL_INCLUDES) |
|
| AC_SUBST(AROPT) |
|
| AC_SUBST(SHARED_LIB) |
|
| AC_SUBST(CFLAGS) |
|
| AC_SUBST(DLSUFFIX) |
|
| AC_SUBST(DL_LIB) |
|
| AC_SUBST(USE_TCL) |
|
| AC_SUBST(USE_TK) |
|
| AC_SUBST(WISH) |
|
| AC_SUBST(USE_PERL) |
|
| AC_SUBST(USE_ODBC) |
|
| AC_SUBST(MULTIBYTE) |
|
| |
|
| dnl Check for C++ support (allow override if needed) |
|
| dnl XXX: probably should default to HAVECXX='false' |
|
| HAVECXX='true' |
|
| AC_ARG_WITH(CXX, |
|
| [ --with-CXX=compiler use specific C++ compiler |
|
| --without-CXX prevent building C++ code ], |
|
| [ |
|
| case "$withval" in |
|
| "" | y | ye | yes) |
|
| HAVECXX='true' |
|
| # allow configure to choose C++ compiler |
|
| ;; |
|
| n | no) |
|
| HAVECXX='false' |
|
| ;; |
|
| *) |
|
| HAVECXX='true' |
|
| CXX="$withval" |
|
| ;; |
|
| esac |
|
| ]) |
|
| AC_SUBST(HAVECXX) |
|
| |
|
| if test "$HAVECXX" = 'true' ; then |
|
| dnl Even if CXX value was given to us, need to run AC_PROG_CXX ... |
|
| AC_PROG_CXX |
|
| AC_LANG_CPLUSPLUS |
|
| |
|
| dnl check whether "#include <string>" works on this C++ compiler |
|
| AC_MSG_CHECKING([for include <string> in C++]) |
|
| AC_TRY_COMPILE([#include <stdio.h> |
|
| #include <stdlib.h> |
|
| #include <string> |
|
| ], [], |
|
| [AC_DEFINE(HAVE_CXX_STRING_HEADER) AC_MSG_RESULT(yes)], |
|
| [AC_MSG_RESULT(no) |
|
| |
|
| dnl If we found a <string> header then it's probably safe to assume |
|
| dnl class string exists. But if not, check to make sure that <string.h> |
|
| dnl defines class string; libpq++ can't build without class string. |
|
| AC_MSG_CHECKING([for class string in C++]) |
|
| AC_TRY_COMPILE([#include <stdio.h> |
|
| #include <stdlib.h> |
|
| #include <string.h> |
|
| ], [string foo = "test"], |
|
| [AC_MSG_RESULT(yes)], |
|
| [AC_MSG_RESULT(no) |
|
| AC_MSG_WARN([ |
|
| *** |
|
| Disabling build of libpq++ because we cannot find class string in the |
|
| system's C++ header files. |
|
| ***]) |
|
| HAVECXX='false' |
|
| ]) |
|
| ]) |
|
| fi |
|
| |
|
| if test "$HAVECXX" = 'true' ; then |
|
| dnl check whether "using namespace std" works on this C++ compiler. |
|
| dnl NOTE: on at least some compilers, it will not work until you've |
|
| dnl included a header that mentions namespace std. Thus, include |
|
| dnl the usual suspects before trying it. |
|
| AC_MSG_CHECKING([for namespace std in C++]) |
|
| AC_TRY_COMPILE([#include <stdio.h> |
|
| #include <stdlib.h> |
|
| #ifdef HAVE_CXX_STRING_HEADER |
|
| #include <string> |
|
| #endif |
|
| using namespace std; |
|
| ], [], |
|
| [AC_DEFINE(HAVE_NAMESPACE_STD) AC_MSG_RESULT(yes)], |
|
| [AC_MSG_RESULT(no)]) |
|
| fi |
|
| |
|
| dnl make sure we revert to C compiler, not C++, for subsequent tests |
# |
| AC_LANG_C |
# Assignments |
| |
# |
| |
|
| dnl Figure out how to invoke "install" and what install options to use. |
CPPFLAGS="$CPPFLAGS $INCLUDES" |
| |
LDFLAGS="$LDFLAGS $LIBDIRS" |
| |
|
| AC_PROG_INSTALL |
AC_MSG_NOTICE([using CPPFLAGS=$CPPFLAGS]) |
| |
AC_MSG_NOTICE([using LDFLAGS=$LDFLAGS]) |
| |
|
| INSTLOPTS="-m 444" |
|
| INSTL_EXE_OPTS="-m 555" |
|
| INSTL_LIB_OPTS="-m 644" |
|
| INSTL_SHLIB_OPTS="-m 644" |
|
| |
|
| dnl HPUX wants shared libs to be mode 555. |
AC_PROG_AWK |
| case "$host_os" in |
PGAC_PATH_FLEX |
| hpux*) |
|
| INSTL_SHLIB_OPTS="-m 555" ;; |
|
| esac |
|
| |
|
| AC_SUBST(INSTALL) |
|
| AC_SUBST(INSTLOPTS) |
|
| AC_SUBST(INSTL_LIB_OPTS) |
|
| AC_SUBST(INSTL_SHLIB_OPTS) |
|
| AC_SUBST(INSTL_EXE_OPTS) |
|
| |
|
| dnl Check the option to echo to inhibit newlines. |
|
| ECHO_N_OUT=`echo -n "" | wc -c` |
|
| ECHO_C_OUT=`echo "\c" | wc -c` |
|
| if test "$ECHO_N_OUT" -eq 0; then |
|
| DASH_N='-n' |
|
| BACKSLASH_C= |
|
| else |
|
| if test "ECHO_C_OUT" -eq 0; then |
|
| DASH_N= |
|
| BACKSLASH_C='\\\\c' |
|
| else |
|
| AC_MSG_ERROR("echo behaviour undetermined") |
|
| fi |
|
| fi |
|
| AC_SUBST(DASH_N) |
|
| AC_SUBST(BACKSLASH_C) |
|
| |
|
| AC_PROG_LEX |
|
| if test "$LEX" = "flex"; then |
|
| $LEX --version 2> /dev/null | grep -s '2\.5\.3' > /dev/null 2>&1 |
|
| if test $? -eq 0 ; then |
|
| AC_MSG_WARN([ |
|
| *** |
|
| You have flex version 2.5.3, which is broken. Get version 2.5.4 or |
|
| a different lex. |
|
| (If you are using the official distribution of PostgreSQL then you |
|
| do not need to worry about this because the lexer files are |
|
| pre-generated. However, other software using flex is likely to be |
|
| broken as well.) |
|
| ***]) |
|
| fi |
|
| fi |
|
| AC_PROG_LN_S |
AC_PROG_LN_S |
| AC_PROG_MAKE_SET |
AC_PROG_LD |
| |
AC_SUBST(LD) |
| |
AC_SUBST(with_gnu_ld) |
| |
case $host_os in sysv5*) |
| |
AC_CACHE_CHECK([whether ld -R works], [pgac_cv_prog_ld_R], |
| |
[ |
| |
pgac_save_LDFLAGS=$LDFLAGS; LDFLAGS="$LDFLAGS -Wl,-R/usr/lib" |
| |
AC_TRY_LINK([], [], [pgac_cv_prog_ld_R=yes], [pgac_cv_prog_ld_R=no]) |
| |
LDFLAGS=$pgac_save_LDFLAGS |
| |
]) |
| |
ld_R_works=$pgac_cv_prog_ld_R |
| |
AC_SUBST(ld_R_works) |
| |
esac |
| AC_PROG_RANLIB |
AC_PROG_RANLIB |
| AC_PATH_PROG(find, find) |
AC_CHECK_PROGS(LORDER, lorder) |
| AC_PATH_PROG(tar, tar) |
AC_PATH_PROG(TAR, tar) |
| AC_PATH_PROG(split, split) |
PGAC_CHECK_STRIP |
| AC_PATH_PROG(etags, etags) |
|
| AC_PATH_PROG(xargs, xargs) |
AC_CHECK_PROGS(YACC, ['bison -y']) |
| AC_PATH_PROGS(GZCAT, gzcat zcat, gzcat) |
|
| AC_CHECK_PROGS(PERL, perl,) |
if test "$YACC"; then |
| |
if $YACC --version | sed q | $AWK '{ if ($4 < 1.875) exit 0; else exit 1;}'; then |
| dnl Changes to look for YACC. We have three choices (in order of pref.) |
AC_MSG_WARN([ |
| dnl (1) We specify in YACC and YFLAGS what we want |
*** The installed version of Bison is too old. PostgreSQL needs |
| dnl (2) We have bison and we use bison -y |
*** Bison version 1.875 or later.]) |
| dnl (3) We have yacc and use it |
fi |
| |
fi |
| |
|
| if test -f "$YACC" |
if test -z "$YACC"; then |
| then |
AC_MSG_WARN([ |
| echo "- Using $YACC $YFLAGS" |
*** Without Bison you will not be able to build PostgreSQL from CVS or |
| else |
*** change any of the parser definition files. You can obtain Bison from |
| AC_PATH_PROG(bison, bison) |
*** a GNU mirror site. (If you are using the official distribution of |
| if test -f "$bison" |
*** PostgreSQL then you do not need to worry about this because the Bison |
| then |
*** output is pre-generated.) To use a different yacc program (possible, |
| echo "- Using $bison -y $YFLAGS" |
*** but not recommended), set the environment variable YACC before running |
| YACC="$bison" |
*** 'configure'.]) |
| YFLAGS="-y $YFLAGS" |
|
| else |
|
| AC_PATH_PROG(yacc, yacc) |
|
| echo "- Using $yacc $YFLAGS" |
|
| YACC="$yacc" |
|
| fi |
|
| fi |
fi |
| AC_SUBST(YACC) |
|
| AC_SUBST(YFLAGS) |
AC_SUBST(YFLAGS) |
| |
|
| AC_CHECK_LIB(sfio, main) |
PGAC_PATH_PERL |
| for curses in ncurses curses ; do |
if test "$with_perl" = yes; then |
| AC_CHECK_LIB(${curses}, main, |
PGAC_CHECK_PERL_CONFIGS([archlibexp,privlibexp,useshrplib]) |
| [LIBS="-l${curses} $LIBS"; break]) |
PGAC_CHECK_PERL_EMBED_LDFLAGS |
| done |
fi |
| AC_CHECK_LIB(termcap, main) |
|
| AC_CHECK_LIB(readline, main) |
if test "$with_python" = yes; then |
| AC_CHECK_LIB(readline, using_history, AC_DEFINE(HAVE_HISTORY_IN_READLINE), |
PGAC_PATH_PYTHON |
| AC_CHECK_LIB(history, main) ) |
PGAC_CHECK_PYTHON_MODULE_SETUP |
| |
PGAC_CHECK_PYTHON_EMBED_SETUP |
| |
fi |
| |
|
| |
|
| |
## |
| |
## Libraries |
| |
## |
| |
|
| if test "$PORTNAME" != "aix" -a "$PORTNAME" != "alpha" |
if test "$PORTNAME" != "aix" -a "$PORTNAME" != "alpha" |
| then |
then |
| AC_CHECK_LIB(bsd, main) |
AC_CHECK_LIB(bsd, main) |
| fi |
fi |
| AC_CHECK_LIB(util, main) |
AC_CHECK_LIB(util, setproctitle) |
| AC_CHECK_LIB(m, main) |
AC_CHECK_LIB(m, main) |
| AC_CHECK_LIB(dl, main) |
AC_CHECK_LIB(dl, main) |
| AC_CHECK_LIB(socket, main) |
|
| AC_CHECK_LIB(nsl, main) |
AC_CHECK_LIB(nsl, main) |
| |
AC_CHECK_LIB(socket, main) |
| AC_CHECK_LIB(ipc, main) |
AC_CHECK_LIB(ipc, main) |
| AC_CHECK_LIB(IPC, main) |
AC_CHECK_LIB(IPC, main) |
| AC_CHECK_LIB(lc, main) |
AC_CHECK_LIB(lc, main) |
| AC_CHECK_LIB(dld, main) |
AC_CHECK_LIB(dld, main) |
| AC_CHECK_LIB(ln, main) |
|
| AC_CHECK_LIB(ld, main) |
AC_CHECK_LIB(ld, main) |
| AC_CHECK_LIB(compat, main) |
AC_CHECK_LIB(compat, main) |
| AC_CHECK_LIB(BSD, main) |
AC_CHECK_LIB(BSD, main) |
| AC_CHECK_LIB(crypt, main) |
|
| AC_CHECK_LIB(gen, main) |
AC_CHECK_LIB(gen, main) |
| AC_CHECK_LIB(PW, main) |
AC_CHECK_LIB(PW, main) |
| |
AC_CHECK_LIB(resolv, main) |
| |
AC_CHECK_LIB(wsock32, main) |
| |
AC_SEARCH_LIBS(getopt_long, [getopt gnugetopt]) |
| |
# QNX: |
| |
AC_CHECK_LIB(unix, main) |
| |
AC_SEARCH_LIBS(crypt, crypt) |
| |
# BeOS: |
| |
AC_CHECK_LIB(bind, __inet_ntoa) |
| |
# Solaris: |
| |
AC_SEARCH_LIBS(fdatasync, [rt posix4]) |
| |
# Cygwin: |
| |
AC_CHECK_LIB(cygipc, shmget) |
| |
|
| |
if test "$with_readline" = yes; then |
| |
PGAC_CHECK_READLINE |
| |
if test x"$pgac_cv_check_readline" = x"no"; then |
| |
AC_MSG_ERROR([readline library not found |
| |
If you have readline already installed, see config.log for details on the |
| |
failure. It is possible the compiler isn't looking in the proper directory. |
| |
Use --without-readline to disable readline support.]) |
| |
fi |
| |
fi |
| |
|
| |
if test "$with_zlib" = yes; then |
| |
AC_CHECK_LIB(z, inflate, [], |
| |
[AC_MSG_ERROR([zlib library not found |
| |
If you have zlib already installed, see config.log for details on the |
| |
failure. It is possible the compiler isn't looking in the proper directory. |
| |
Use --without-zlib to disable zlib support.])]) |
| |
fi |
| |
|
| |
if test "$with_krb4" = yes ; then |
| |
AC_CHECK_LIB(des, des_encrypt, [], [AC_MSG_ERROR([library 'des' is required for Kerberos 4])]) |
| |
AC_CHECK_LIB(krb, krb_sendauth, [], [AC_MSG_ERROR([library 'krb' is required for Kerberos 4])]) |
| |
AC_REPLACE_FUNCS([gethostname]) |
| |
fi |
| |
|
| |
if test "$with_krb5" = yes ; then |
| |
AC_SEARCH_LIBS(com_err, [krb5 'krb5 -ldes -lasn1 -lroken' com_err], [], |
| |
[AC_MSG_ERROR([could not find function 'com_err' required for Kerberos 5])]) |
| |
AC_SEARCH_LIBS(krb5_encrypt, [krb5 'krb5 -ldes -lasn1 -lroken' crypto k5crypto], [], |
| |
[AC_MSG_ERROR([could not find function 'krb5_encrypt' required for Kerberos 5])]) |
| |
AC_SEARCH_LIBS(krb5_sendauth, [krb5 'krb5 -ldes -lasn1 -lroken'], [], |
| |
[AC_MSG_ERROR([could not find function 'krb5_sendauth' required for Kerberos 5])]) |
| |
fi |
| |
|
| |
if test "$with_openssl" = yes ; then |
| |
dnl Order matters! |
| |
AC_CHECK_LIB(crypto, CRYPTO_new_ex_data, [], [AC_MSG_ERROR([library 'crypto' is required for OpenSSL])]) |
| |
AC_CHECK_LIB(ssl, SSL_library_init, [], [AC_MSG_ERROR([library 'ssl' is required for OpenSSL])]) |
| |
fi |
| |
|
| |
if test "$with_pam" = yes ; then |
| |
AC_CHECK_LIB(pam, pam_start, [], [AC_MSG_ERROR([library 'pam' is required for PAM])]) |
| |
fi |
| |
|
| |
|
| dnl Checks for header files. |
## |
| AC_HEADER_STDC |
## Header files |
| AC_HEADER_SYS_WAIT |
## |
| AC_CHECK_HEADERS(arpa/inet.h) |
|
| AC_CHECK_HEADERS(crypt.h) |
dnl sys/socket.h is required by AC_FUNC_ACCEPT_ARGTYPES |
| AC_CHECK_HEADERS(dld.h) |
AC_CHECK_HEADERS([crypt.h dld.h endian.h fp_class.h getopt.h ieeefp.h poll.h pwd.h sys/ipc.h sys/poll.h sys/pstat.h sys/select.h sys/sem.h sys/socket.h sys/shm.h sys/un.h termios.h utime.h kernel/OS.h kernel/image.h SupportDefs.h]) |
| AC_CHECK_HEADERS(endian.h) |
|
| AC_CHECK_HEADERS(float.h) |
# At least on IRIX, cpp test for netinet/tcp.h will fail unless |
| AC_CHECK_HEADERS(fp_class.h) |
# netinet/in.h is included first. |
| AC_CHECK_HEADERS(getopt.h) |
|
| AC_CHECK_HEADERS(history.h) |
|
| AC_CHECK_HEADERS(ieeefp.h) |
|
| AC_CHECK_HEADERS(limits.h) |
|
| AC_CHECK_HEADERS(netdb.h) |
|
| AC_CHECK_HEADERS(netinet/in.h) |
AC_CHECK_HEADERS(netinet/in.h) |
| AC_CHECK_HEADERS(readline.h) |
AC_CHECK_HEADERS(netinet/tcp.h, [], [], |
| AC_CHECK_HEADERS(readline/history.h) |
[AC_INCLUDES_DEFAULT |
| AC_CHECK_HEADERS(readline/readline.h) |
#ifdef HAVE_NETINET_IN_H |
| AC_CHECK_HEADERS(sys/select.h) |
#include <netinet/in.h> |
| AC_CHECK_HEADERS(termios.h) |
#endif |
| AC_CHECK_HEADERS(unistd.h) |
]) |
| AC_CHECK_HEADERS(values.h) |
|
| AC_CHECK_HEADERS(sys/exec.h sys/pstat.h machine/vmparam.h) |
if test "$with_readline" = yes; then |
| dnl ODBC headers... |
AC_CHECK_HEADERS(readline/readline.h, [], |
| AC_CHECK_HEADERS(sys/param.h pwd.h) |
[AC_CHECK_HEADERS(editline/readline.h, [], |
| dnl |
[AC_CHECK_HEADERS(readline.h, [], |
| |
[AC_MSG_ERROR([readline header not found |
| |
If you have readline already installed, see config.log for details on the |
| |
failure. It is possible the compiler isn't looking in the proper directory. |
| |
Use --without-readline to disable readline support.])])])]) |
| |
AC_CHECK_HEADERS(readline/history.h, [], |
| |
[AC_CHECK_HEADERS(editline/history.h, [], |
| |
[AC_CHECK_HEADERS(history.h, [], |
| |
[AC_MSG_ERROR([history header not found |
| |
If you have readline already installed, see config.log for details on the |
| |
failure. It is possible the compiler isn't looking in the proper directory. |
| |
Use --without-readline to disable readline support.])])])]) |
| |
fi |
| |
|
| |
if test "$with_zlib" = yes; then |
| |
AC_CHECK_HEADER(zlib.h, [], [AC_MSG_ERROR([zlib header not found |
| |
If you have zlib already installed, see config.log for details on the |
| |
failure. It is possible the compiler isn't looking in the proper directory. |
| |
Use --without-zlib to disable zlib support.])]) |
| |
fi |
| |
|
| |
if test "$with_krb4" = yes ; then |
| |
AC_CHECK_HEADER(krb.h, [], [AC_MSG_ERROR([header file <krb.h> is required for Kerberos 4])]) |
| |
fi |
| |
|
| |
if test "$with_krb5" = yes ; then |
| |
AC_CHECK_HEADER(krb5.h, [], [AC_MSG_ERROR([header file <krb5.h> is required for Kerberos 5])]) |
| |
AC_CHECK_HEADER(com_err.h, [], [AC_MSG_ERROR([header file <com_err.h> is required for Kerberos 5])]) |
| |
fi |
| |
|
| |
if test "$with_openssl" = yes ; then |
| |
AC_CHECK_HEADER(openssl/ssl.h, [], [AC_MSG_ERROR([header file <openssl/ssl.h> is required for OpenSSL])]) |
| |
AC_CHECK_HEADER(openssl/err.h, [], [AC_MSG_ERROR([header file <openssl/err.h> is required for OpenSSL])]) |
| |
fi |
| |
|
| dnl Checks for typedefs, structures, and compiler characteristics. |
if test "$with_pam" = yes ; then |
| |
AC_CHECK_HEADERS(security/pam_appl.h, [], |
| |
[AC_CHECK_HEADERS(pam/pam_appl.h, [], |
| |
[AC_MSG_ERROR([header file <security/pam_appl.h> or <pam/pam_appl.h> is required for PAM.])])]) |
| |
fi |
| |
|
| |
if test "$with_rendezvous" = yes ; then |
| |
AC_CHECK_HEADER(DNSServiceDiscovery/DNSServiceDiscovery.h, [], [AC_MSG_ERROR([header file <DNSServiceDiscovery/DNSServiceDiscovery.h> is required for Rendezvous])]) |
| |
fi |
| |
|
| |
|
| |
## |
| |
## Types, structures, compiler characteristics |
| |
## |
| |
|
| |
m4_defun([AC_PROG_CC_STDC], []) dnl We don't want that. |
| AC_C_CONST |
AC_C_CONST |
| AC_C_INLINE |
AC_C_INLINE |
| AC_C_STRINGIZE |
AC_C_STRINGIZE |
| AC_TYPE_UID_T |
PGAC_C_SIGNED |
| AC_TYPE_MODE_T |
AC_C_VOLATILE |
| AC_TYPE_OFF_T |
PGAC_C_FUNCNAME_SUPPORT |
| AC_TYPE_SIZE_T |
PGAC_STRUCT_TIMEZONE |
| AC_HEADER_TIME |
PGAC_UNION_SEMUN |
| AC_STRUCT_TM |
PGAC_STRUCT_SOCKADDR_UN |
| AC_STRUCT_TIMEZONE |
PGAC_STRUCT_SOCKADDR_STORAGE |
| |
PGAC_STRUCT_SOCKADDR_STORAGE_SS_FAMILY |
| AC_MSG_CHECKING(for signed types) |
PGAC_STRUCT_ADDRINFO |
| AC_TRY_COMPILE([], |
|
| [signed char c; signed short s; signed int i;], |
|
| [AC_MSG_RESULT(yes)], |
|
| [AC_DEFINE(signed, ) AC_MSG_RESULT(no)]) |
|
| |
|
| AC_MSG_CHECKING(for volatile) |
|
| AC_TRY_COMPILE([], |
|
| [extern volatile int i;], |
|
| [AC_MSG_RESULT(yes)], |
|
| [AC_DEFINE(volatile, ) AC_MSG_RESULT(no)]) |
|
| |
|
| AC_MSG_CHECKING(for type of last arg to accept) |
AC_CHECK_TYPES([struct cmsgcred, struct fcred, struct sockcred], [], [], |
| AC_TRY_COMPILE([#include <stdlib.h> |
[#include <sys/param.h> |
| #include <sys/types.h> |
#include <sys/types.h> |
| #include <sys/socket.h> |
#include <sys/socket.h> |
| ], |
#include <sys/ucred.h>]) |
| [int a = accept(1, (struct sockaddr *) 0, (size_t *) 0);], |
|
| [AC_DEFINE(SOCKET_SIZE_TYPE, size_t) AC_MSG_RESULT(size_t)], |
|
| [AC_DEFINE(SOCKET_SIZE_TYPE, int) AC_MSG_RESULT(int)]) |
|
| |
|
| dnl Check for any "odd" conditions |
|
| AC_MSG_CHECKING(for int timezone) |
|
| AC_TRY_LINK([#include <time.h>], |
|
| [int res = timezone / 60; ], |
|
| [AC_DEFINE(HAVE_INT_TIMEZONE) AC_MSG_RESULT(yes)], |
|
| AC_MSG_RESULT(no)) |
|
| |
|
| AC_MSG_CHECKING(for gettimeofday args) |
|
| AC_TRY_LINK([#include <sys/time.h>], |
|
| [struct timeval *tp; struct timezone *tzp; gettimeofday(tp,tzp); ], |
|
| [AC_DEFINE(HAVE_GETTIMEOFDAY_2_ARGS) AC_MSG_RESULT(2 args)], |
|
| AC_MSG_RESULT(no)) |
|
| |
|
| AC_MSG_CHECKING(for union semun) |
|
| AC_TRY_LINK([#include <sys/types.h> |
|
| #include <sys/ipc.h> |
|
| #include <sys/sem.h>], |
|
| [union semun semun;], |
|
| [AC_DEFINE(HAVE_UNION_SEMUN) AC_MSG_RESULT(yes)], |
|
| AC_MSG_RESULT(no)) |
|
| |
|
| AC_MSG_CHECKING(for fcntl(F_SETLK)) |
|
| AC_TRY_LINK([#include <fcntl.h>], |
|
| [struct flock lck; |
|
| lck.l_whence = SEEK_SET; lck.l_start = lck.l_len = 0; |
|
| lck.l_type = F_WRLCK; |
|
| fcntl(0, F_SETLK, &lck);], |
|
| [AC_DEFINE(HAVE_FCNTL_SETLK) AC_MSG_RESULT(yes)], |
|
| AC_MSG_RESULT(no)) |
|
| |
|
| dnl Checks for library functions. |
if test "$with_zlib" = yes; then |
| |
# Check that <zlib.h> defines z_streamp (versions before about 1.0.4 |
| |
# did not). While we could work around the lack of z_streamp, it |
| |
# seems unwise to encourage people to use such old zlib versions... |
| |
AC_CHECK_TYPE(z_streamp, [], [AC_MSG_ERROR([zlib version is too old |
| |
Use --without-zlib to disable zlib support.])], |
| |
[#include <zlib.h>]) |
| |
fi |
| |
|
| |
if test "$with_krb5" = yes; then |
| |
# Check for differences between MIT and Heimdal (KTH) releases |
| |
AC_CHECK_MEMBERS(krb5_ticket.enc_part2, [], |
| |
[AC_CHECK_MEMBERS(krb5_ticket.client, [], |
| |
[AC_MSG_ERROR([could not determine how to get client name from Kerberos 5 ticket])], |
| |
[#include <krb5.h>])], |
| |
[#include <krb5.h>]) |
| |
AC_CHECK_MEMBERS(krb5_error.text.data, [], |
| |
[AC_CHECK_MEMBERS(krb5_error.e_data, [], |
| |
[AC_MSG_ERROR([could not determine how to extract Kerberos 5 error messages])], |
| |
[#include <krb5.h>])], |
| |
[#include <krb5.h>]) |
| |
fi |
| |
|
| |
|
| |
## |
| |
## Functions, global variables |
| |
## |
| |
|
| |
PGAC_VAR_INT_TIMEZONE |
| |
AC_FUNC_ACCEPT_ARGTYPES |
| |
PGAC_FUNC_GETTIMEOFDAY_1ARG |
| |
|
| |
# SunOS doesn't handle negative byte comparisons properly with +/- return |
| AC_FUNC_MEMCMP |
AC_FUNC_MEMCMP |
| AC_TYPE_SIGNAL |
|
| AC_FUNC_VPRINTF |
AC_CHECK_FUNCS([cbrt dlopen fcvt fdatasync getpeereid memmove poll pstat setproctitle setsid sigprocmask symlink sysconf utime utimes waitpid]) |
| AC_CHECK_FUNCS(memmove sysconf) |
|
| AC_CHECK_FUNCS(sigprocmask waitpid setsid fcvt) |
AC_CHECK_DECLS(fdatasync, [], [], [#include <unistd.h>]) |
| AC_CHECK_FUNCS(setproctitle pstat) |
|
| |
AC_CHECK_TYPE([struct sockaddr_in6], |
| AC_MSG_CHECKING(for PS_STRINGS) |
[AC_CHECK_FUNC(inet_ntop, |
| AC_TRY_LINK( |
[AC_DEFINE(HAVE_IPV6, 1, [Define to 1 if you have support for IPv6.])])], |
| [#ifdef HAVE_MACHINE_VMPARAM_H |
[], |
| # include <machine/vmparam.h> |
[$ac_includes_default |
| #endif |
#include <netinet/in.h>]) |
| #ifdef HAVE_SYS_EXEC_H |
|
| # include <sys/exec.h> |
AC_CACHE_CHECK([for PS_STRINGS], [pgac_cv_var_PS_STRINGS], |
| #endif], |
[AC_TRY_LINK( |
| |
[#include <machine/vmparam.h> |
| |
#include <sys/exec.h> |
| |
], |
| [PS_STRINGS->ps_nargvstr = 1; |
[PS_STRINGS->ps_nargvstr = 1; |
| PS_STRINGS->ps_argvstr = "foo";], |
PS_STRINGS->ps_argvstr = "foo";], |
| [AC_MSG_RESULT(yes) AC_DEFINE(HAVE_PS_STRINGS)], |
[pgac_cv_var_PS_STRINGS=yes], |
| AC_MSG_RESULT(no)) |
[pgac_cv_var_PS_STRINGS=no])]) |
| |
if test "$pgac_cv_var_PS_STRINGS" = yes ; then |
| |
AC_DEFINE([HAVE_PS_STRINGS], [], [Define to 1 if the PS_STRINGS thing exists.]) |
| |
fi |
| |
|
| AC_CHECK_FUNCS(fpclass fp_class fp_class_d class) |
|
| dnl We use our snprintf.c emulation if either snprintf() or vsnprintf() |
# We use our snprintf.c emulation if either snprintf() or vsnprintf() |
| dnl is missing. Yes, there are machines that have only one. |
# is missing. Yes, there are machines that have only one. We may |
| dnl We may also decide to use snprintf.c if snprintf() is present but does |
# also decide to use snprintf.c if snprintf() is present but does not |
| dnl not have working "long long int" support -- see below. |
# have working "long long int" support -- see below. |
| SNPRINTF='' |
|
| AC_CHECK_FUNC(snprintf, |
pgac_need_repl_snprintf=no |
| AC_DEFINE(HAVE_SNPRINTF), |
AC_CHECK_FUNCS(snprintf, [], pgac_need_repl_snprintf=yes) |
| SNPRINTF='snprintf.o') |
AC_CHECK_FUNCS(vsnprintf, [], pgac_need_repl_snprintf=yes) |
| AC_CHECK_FUNC(vsnprintf, |
|
| AC_DEFINE(HAVE_VSNPRINTF), |
|
| SNPRINTF='snprintf.o') |
# Check whether <stdio.h> declares snprintf() and vsnprintf(); if not, |
| AC_SUBST(SNPRINTF) |
# include/c.h will provide declarations. Note this is a separate test |
| dnl Check whether <stdio.h> declares snprintf() and vsnprintf(); if not, |
# from whether the functions exist in the C library --- there are |
| dnl include/c.h will provide declarations. Note this is a separate test |
# systems that have the functions but don't bother to declare them :-( |
| dnl from whether the functions exist in the C library --- there are systems |
|
| dnl that have the functions but don't bother to declare them :-( |
AC_CHECK_DECLS([snprintf, vsnprintf]) |
| dnl Note: simple-minded pattern here will do wrong thing if stdio.h |
|
| dnl declares vsnprintf() but not snprintf(). Hopefully there are no |
|
| dnl systems that are *that* brain-damaged... |
# do this one the hard way in case isinf() is a macro |
| AC_EGREP_HEADER(snprintf, stdio.h, AC_DEFINE(HAVE_SNPRINTF_DECL)) |
AC_CACHE_CHECK([for isinf], ac_cv_func_isinf, |
| AC_EGREP_HEADER(vsnprintf, stdio.h, AC_DEFINE(HAVE_VSNPRINTF_DECL)) |
|
| dnl |
|
| dnl do this one the hard way in case isinf() is a macro |
|
| AC_MSG_CHECKING(for isinf) |
|
| AC_CACHE_VAL(ac_cv_func_or_macro_isinf, |
|
| [AC_TRY_LINK( |
[AC_TRY_LINK( |
| [#include <math.h>], |
[#include <math.h> |
| |
], |
| [double x = 0.0; int res = isinf(x);], |
[double x = 0.0; int res = isinf(x);], |
| [ac_cv_func_or_macro_isinf=yes], |
[ac_cv_func_isinf=yes], |
| [ac_cv_func_or_macro_isinf=no])]) |
[ac_cv_func_isinf=no])]) |
| if [[ $ac_cv_func_or_macro_isinf = yes ]]; then |
|
| AC_MSG_RESULT(yes) |
if test $ac_cv_func_isinf = yes ; then |
| AC_DEFINE(HAVE_ISINF) |
AC_DEFINE(HAVE_ISINF, 1, [Define to 1 if you have isinf().]) |
| ISINF='' |
|
| else |
else |
| AC_MSG_RESULT(no) |
AC_LIBOBJ(isinf) |
| ISINF='isinf.o' |
# Look for a way to implement a substitute for isinf() |
| |
AC_CHECK_FUNCS([fpclass fp_class fp_class_d class], [break]) |
| fi |
fi |
| AC_SUBST(ISINF) |
|
| AC_CHECK_FUNC(getrusage, |
AC_REPLACE_FUNCS([crypt fseeko getopt getopt_long getrusage inet_aton random rint srandom strcasecmp strdup strerror strtol strtoul]) |
| AC_DEFINE(HAVE_GETRUSAGE), |
|
| GETRUSAGE='getrusage.o') |
# system's version of getaddrinfo(), if any, may be used only if we found |
| AC_SUBST(GETRUSAGE) |
# a definition for struct addrinfo; see notes in src/include/getaddrinfo.h |
| AC_CHECK_FUNC(srandom, |
if test x"$ac_cv_type_struct_addrinfo" = xyes ; then |
| AC_DEFINE(HAVE_SRANDOM), |
AC_REPLACE_FUNCS([getaddrinfo]) |
| SRANDOM='srandom.o') |
else |
| AC_SUBST(SRANDOM) |
AC_LIBOBJ(getaddrinfo) |
| AC_CHECK_FUNC(gethostname, |
fi |
| AC_DEFINE(HAVE_GETHOSTNAME), |
|
| GETHOSTNAME='gethostname.o') |
# BSD/OS & NetBSD use a custom fseeko/ftello built on fsetpos/fgetpos |
| AC_SUBST(GETHOSTNAME) |
# We override the previous test that said fseeko/ftello didn't exist |
| AC_CHECK_FUNC(random, |
# OS tests are also done in include/c.h and port/fseeko.c |
| AC_DEFINE(HAVE_RANDOM), |
case $host_os in bsdi*|netbsd*) |
| MISSING_RANDOM='random.o') |
ac_cv_func_fseeko=yes |
| AC_SUBST(MISSING_RANDOM) |
|
| AC_CHECK_FUNC(inet_aton, |
|
| AC_DEFINE(HAVE_INET_ATON), |
|
| INET_ATON='inet_aton.o') |
|
| AC_SUBST(INET_ATON) |
|
| AC_CHECK_FUNC(strerror, |
|
| AC_DEFINE(HAVE_STRERROR), |
|
| [STRERROR='strerror.o' STRERROR2='../../backend/port/strerror.o']) |
|
| AC_SUBST(STRERROR) |
|
| AC_SUBST(STRERROR2) |
|
| AC_CHECK_FUNC(strdup, |
|
| AC_DEFINE(HAVE_STRDUP), |
|
| STRDUP='../../utils/strdup.o') |
|
| AC_SUBST(STRDUP) |
|
| AC_CHECK_FUNC(strtol, |
|
| AC_DEFINE(HAVE_STRTOL), |
|
| STRTOL='strtol.o') |
|
| AC_SUBST(STRTOL) |
|
| AC_CHECK_FUNC(strtoul, |
|
| AC_DEFINE(HAVE_STRTOUL), |
|
| STRTOL='strtoul.o') |
|
| AC_SUBST(STRTOUL) |
|
| AC_CHECK_FUNC(strcasecmp, |
|
| AC_DEFINE(HAVE_STRCASECMP), |
|
| STRCASECMP='strcasecmp.o') |
|
| AC_SUBST(STRCASECMP) |
|
| AC_CHECK_FUNC(cbrt, |
|
| AC_DEFINE(HAVE_CBRT), |
|
| AC_CHECK_LIB(m, cbrt, AC_DEFINE(HAVE_CBRT))) |
|
| |
|
| # On HPUX 9, rint() is not in regular libm.a but in /lib/pa1.1/libm.a; |
|
| # this hackery with HPUXMATHLIB allows us to cope. |
|
| HPUXMATHLIB="" |
|
| case "$host_cpu" in |
|
| hppa1.1) |
|
| if [[ -r /lib/pa1.1/libm.a ]] ; then |
|
| HPUXMATHLIB="-L /lib/pa1.1 -lm" |
|
| fi ;; |
|
| esac |
esac |
| AC_SUBST(HPUXMATHLIB) |
|
| |
|
| AC_CHECK_FUNC(rint, |
# Solaris has a very slow qsort in certain cases, so we replace it. |
| AC_DEFINE(HAVE_RINT), |
case $host_os in solaris*) |
| AC_CHECK_LIB(m, rint, AC_DEFINE(HAVE_RINT), , $HPUXMATHLIB)) |
AC_LIBOBJ(qsort) ;; |
| |
esac |
| dnl Some old versions of libreadline don't have rl_completion_append_character |
|
| AC_EGREP_HEADER(rl_completion_append_character, readline.h, |
# Win32 can't to rename or unlink on an open file |
| AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER), |
case $host_os in mingw*) |
| [AC_EGREP_HEADER(rl_completion_append_character, readline/readline.h, |
AC_LIBOBJ(dirmod) |
| AC_DEFINE(HAVE_RL_COMPLETION_APPEND_CHARACTER))]) |
AC_LIBOBJ(copydir) |
| AC_SUBST(HAVE_RL_COMPLETION_APPEND_CHARACTER) |
AC_LIBOBJ(gettimeofday) ;; |
| |
esac |
| dnl Check for readline's filename_completion_function. |
|
| dnl Some versions have it but it's not in the headers, so we have to take |
if test "$with_readline" = yes; then |
| dnl care of that, too. |
PGAC_VAR_RL_COMPLETION_APPEND_CHARACTER |
| AC_CHECK_FUNCS(filename_completion_function, |
AC_CHECK_FUNCS([rl_completion_matches rl_filename_completion_function]) |
| AC_EGREP_HEADER(filename_completion_function, readline.h, |
AC_CHECK_FUNCS([replace_history_entry]) |
| AC_DEFINE(HAVE_FILENAME_COMPLETION_FUNCTION_DECL), |
fi |
| [AC_EGREP_HEADER(filename_completion_function, readline/readline.h, |
|
| AC_DEFINE(HAVE_FILENAME_COMPLETION_FUNCTION_DECL))]) |
|
| ) |
|
| AC_SUBST(HAVE_FILENAME_COMPLETION_FUNCTION) |
|
| AC_SUBST(HAVE_FILENAME_COMPLETION_FUNCTION_DECL) |
|
| |
|
| dnl Check for GNU style long options support (getopt_long) |
|
| AC_CHECK_FUNCS(getopt_long) |
|
| |
|
| dnl Cannot use AC_CHECK_FUNC because finite may be a macro |
dnl Cannot use AC_CHECK_FUNC because finite may be a macro |
| AC_MSG_CHECKING(for finite) |
AC_MSG_CHECKING(for finite) |
| AC_TRY_LINK([#include <math.h>], |
AC_TRY_LINK([#include <math.h>], |
| [int dummy=finite(1.0);], |
[int dummy=finite(1.0);], |
| [AC_DEFINE(HAVE_FINITE) AC_MSG_RESULT(yes)], |
[AC_DEFINE(HAVE_FINITE, 1, [Define to 1 if you have finite().]) |
| AC_MSG_RESULT(no)) |
AC_MSG_RESULT(yes)], |
| |
[AC_MSG_RESULT(no)]) |
| |
|
| dnl Cannot use AC_CHECK_FUNC because sigsetjmp may be a macro |
dnl Cannot use AC_CHECK_FUNC because sigsetjmp may be a macro |
| dnl (especially on GNU libc) |
dnl (especially on GNU libc) |
| dnl See also comments in config.h. |
dnl See also comments in c.h. |
| AC_MSG_CHECKING(for sigsetjmp) |
AC_MSG_CHECKING(for sigsetjmp) |
| AC_TRY_LINK([#include <setjmp.h>], |
AC_TRY_LINK([#include <setjmp.h>], |
| [sigjmp_buf x; sigsetjmp(x, 1);], |
[sigjmp_buf x; sigsetjmp(x, 1);], |
| [AC_DEFINE(HAVE_SIGSETJMP) AC_MSG_RESULT(yes)], |
[AC_DEFINE(HAVE_SIGSETJMP, 1, [Define to 1 if you have sigsetjmp().]) |
| AC_MSG_RESULT(no)) |
AC_MSG_RESULT(yes)], |
| |
[AC_MSG_RESULT(no)]) |
| AC_ARG_ENABLE(syslog, [ --enable-syslog enable logging to syslog], |
|
| [case $enableval in y|ye|yes) |
AC_CHECK_FUNC(syslog, |
| AC_CHECK_FUNC(syslog, [AC_DEFINE(ENABLE_SYSLOG)], [AC_MSG_ERROR([no syslog interface found])]) |
[AC_CHECK_HEADER(syslog.h, |
| ;; |
[AC_DEFINE(HAVE_SYSLOG, 1, [Define to 1 if you have the syslog interface.])])]) |
| esac] |
|
| ) |
AC_CACHE_CHECK([for optreset], pgac_cv_var_int_optreset, |
| |
[AC_TRY_LINK([#include <unistd.h>], |
| |
[extern int optreset; optreset = 1;], |
| |
[pgac_cv_var_int_optreset=yes], |
| |
[pgac_cv_var_int_optreset=no])]) |
| |
if test x"$pgac_cv_var_int_optreset" = x"yes"; then |
| |
AC_DEFINE(HAVE_INT_OPTRESET, 1, [Define to 1 if you have the global variable 'int optreset'.]) |
| |
fi |
| |
|
| |
AC_CHECK_FUNCS([strtoll strtoq], [break]) |
| |
AC_CHECK_FUNCS([strtoull strtouq], [break]) |
| |
|
| |
# Check for one of atexit() or on_exit() |
| |
AC_CHECK_FUNCS(atexit, [], |
| |
[AC_CHECK_FUNCS(on_exit, [], |
| |
[AC_MSG_ERROR([neither atexit() nor on_exit() found])])]) |
| |
|
| |
AC_FUNC_FSEEKO |
| |
|
| |
# |
| |
# Pthreads |
| |
# |
| |
# For each platform, we need to know about any special compile and link |
| |
# libraries, and whether the normal C function names are thread-safe. |
| |
# |
| |
NEED_REENTRANT_FUNC_NAMES=no |
| |
if test "$with_threads" = yes; then |
| |
AC_CHECK_HEADER(pthread.h, [], [AC_MSG_ERROR([pthread.h not found, required for --with-threads])]) |
| |
|
| |
if test "$SUPPORTS_THREADS" != yes; then |
| |
AC_MSG_ERROR([ |
| |
Cannot enable threads on your platform. |
| |
Please report your platform threading info to the PostgreSQL mailing lists |
| |
so it can be added to the next release. Report any compile flags, link flags, |
| |
functions, or libraries required for threading support. |
| |
]) |
| |
fi |
| |
fi |
| |
AC_SUBST(THREAD_CFLAGS) |
| |
AC_SUBST(THREAD_LIBS) |
| |
|
| |
|
| |
# |
| |
# Check for re-entrant versions of certain functions |
| |
# |
| |
# Include special flags if threads are enabled _and_ if required for |
| |
# threading on this platform. Some platforms have *_r functions but |
| |
# their natively named funcs are threadsafe, and should be used instead. |
| |
# |
| |
# One trick here is that if the don't call AC_CHECK_FUNCS, the |
| |
# functions are marked "not found", which is perfect. |
| |
# |
| |
if test "$NEED_REENTRANT_FUNC_NAMES" = yes ; then |
| |
_CFLAGS="$CFLAGS" |
| |
_LIB="$LIBS" |
| |
CFLAGS="$CFLAGS $TREAD_CFLAGS" |
| |
LIBS="$LIBS $THREAD_LIBS" |
| |
AC_CHECK_FUNCS([strerror_r getpwuid_r gethostbyname_r]) |
| |
CFLAGS="$_CFLAGS" |
| |
LIB="$_LIBS" |
| |
fi |
| |
|
| |
|
| |
# 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 Check to see if we have a working 64-bit integer type. |
| dnl This breaks down into two steps: |
dnl This breaks down into two steps: |
|
Line 965 dnl If there is no native snprintf() or
|
Line 1031 dnl If there is no native snprintf() or
|
| dnl we force our own version of snprintf() to be used instead. |
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. |
dnl Note this test must be run after our initial check for snprintf/vsnprintf. |
| |
|
| HAVE_LONG_INT_64=0 |
PGAC_TYPE_64BIT_INT([long int]) |
| AC_MSG_CHECKING(whether 'long int' is 64 bits) |
|
| AC_TRY_RUN([typedef long int int64; |
if test x"$HAVE_LONG_INT_64" = x"no" ; then |
| |
PGAC_TYPE_64BIT_INT([long long int]) |
| /* These are globals to discourage the compiler from folding all the |
fi |
| * arithmetic tests down to compile-time constants. |
|
| */ |
|
| int64 a = 20000001; |
dnl If we need to use "long long int", figure out whether nnnLL notation works. |
| int64 b = 40000005; |
|
| |
if test x"$HAVE_LONG_LONG_INT_64" = xyes ; then |
| int does_int64_work() |
AC_TRY_COMPILE([ |
| { |
#define INT64CONST(x) x##LL |
| int64 c,d; |
long long int foo = INT64CONST(0x1234567890123456); |
| |
], |
| if (sizeof(int64) != 8) |
[], |
| return 0; /* doesn't look like the right size */ |
[AC_DEFINE(HAVE_LL_CONSTANTS, 1, [Define to 1 if constants of type 'long long int' should have the suffix LL.])], |
| |
[]) |
| /* Do perfunctory checks to see if 64-bit arithmetic seems to work */ |
fi |
| c = a * b; |
|
| d = (c + b) / b; |
|
| if (d != a+1) |
# If we found "long int" is 64 bits, assume snprintf handles it. If |
| return 0; |
# we found we need to use "long long int", better check. We cope with |
| return 1; |
# snprintfs that use either %lld, %qd, or %I64d as the format. If |
| } |
# neither works, fall back to our own snprintf emulation (which we |
| main() { |
# know uses %lld). |
| exit(! does_int64_work()); |
|
| }], |
if test "$HAVE_LONG_LONG_INT_64" = yes ; then |
| [HAVE_LONG_INT_64=1 |
if test $pgac_need_repl_snprintf = no; then |
| AC_DEFINE(HAVE_LONG_INT_64) |
PGAC_FUNC_SNPRINTF_LONG_LONG_INT_FORMAT |
| AC_MSG_RESULT(yes)], |
if test "$LONG_LONG_INT_FORMAT" = ""; then |
| AC_MSG_RESULT(no), |
# Force usage of our own snprintf, since system snprintf is broken |
| AC_MSG_RESULT(assuming not on target machine)) |
pgac_need_repl_snprintf=yes |
| |
LONG_LONG_INT_FORMAT='%lld' |
| HAVE_LONG_LONG_INT_64=0 |
fi |
| if [[ $HAVE_LONG_INT_64 -eq 0 ]] ; then |
|
| AC_MSG_CHECKING(whether 'long long int' is 64 bits) |
|
| AC_TRY_RUN([typedef long long int int64; |
|
| |
|
| /* These are globals to discourage the compiler from folding all the |
|
| * arithmetic tests down to compile-time constants. |
|
| */ |
|
| int64 a = 20000001; |
|
| int64 b = 40000005; |
|
| |
|
| int does_int64_work() |
|
| { |
|
| int64 c,d; |
|
| |
|
| if (sizeof(int64) != 8) |
|
| return 0; /* doesn't look like the right size */ |
|
| |
|
| /* Do perfunctory checks to see if 64-bit arithmetic seems to work */ |
|
| c = a * b; |
|
| d = (c + b) / b; |
|
| if (d != a+1) |
|
| return 0; |
|
| return 1; |
|
| } |
|
| main() { |
|
| exit(! does_int64_work()); |
|
| }], |
|
| [HAVE_LONG_LONG_INT_64=1 |
|
| AC_DEFINE(HAVE_LONG_LONG_INT_64) |
|
| AC_MSG_RESULT(yes)], |
|
| AC_MSG_RESULT(no), |
|
| AC_MSG_RESULT(assuming not on target machine)) |
|
| fi |
|
| |
|
| dnl If we found "long int" is 64 bits, assume snprintf handles it. |
|
| dnl If we found we need to use "long long int", better check. |
|
| dnl We cope with snprintfs that use either %lld or %qd as the format. |
|
| dnl If neither works, fall back to our own snprintf emulation (which we |
|
| dnl know uses %lld). |
|
| |
|
| if [[ $HAVE_LONG_LONG_INT_64 -eq 1 ]] ; then |
|
| if [[ x$SNPRINTF = x ]] ; then |
|
| AC_MSG_CHECKING(whether snprintf handles 'long long int' as %lld) |
|
| AC_TRY_RUN([#include <stdio.h> |
|
| typedef long long int int64; |
|
| #define INT64_FORMAT "%lld" |
|
| |
|
| int64 a = 20000001; |
|
| int64 b = 40000005; |
|
| |
|
| int does_int64_snprintf_work() |
|
| { |
|
| int64 c; |
|
| char buf[100]; |
|
| |
|
| if (sizeof(int64) != 8) |
|
| return 0; /* doesn't look like the right size */ |
|
| |
|
| c = a * b; |
|
| snprintf(buf, 100, INT64_FORMAT, c); |
|
| if (strcmp(buf, "800000140000005") != 0) |
|
| return 0; /* either multiply or snprintf is busted */ |
|
| return 1; |
|
| } |
|
| main() { |
|
| exit(! does_int64_snprintf_work()); |
|
| }], |
|
| [ AC_MSG_RESULT(yes) |
|
| INT64_FORMAT='"%lld"' |
|
| ], |
|
| [ AC_MSG_RESULT(no) |
|
| AC_MSG_CHECKING(whether snprintf handles 'long long int' as %qd) |
|
| AC_TRY_RUN([#include <stdio.h> |
|
| typedef long long int int64; |
|
| #define INT64_FORMAT "%qd" |
|
| |
|
| int64 a = 20000001; |
|
| int64 b = 40000005; |
|
| |
|
| int does_int64_snprintf_work() |
|
| { |
|
| int64 c; |
|
| char buf[100]; |
|
| |
|
| if (sizeof(int64) != 8) |
|
| return 0; /* doesn't look like the right size */ |
|
| |
|
| c = a * b; |
|
| snprintf(buf, 100, INT64_FORMAT, c); |
|
| if (strcmp(buf, "800000140000005") != 0) |
|
| return 0; /* either multiply or snprintf is busted */ |
|
| return 1; |
|
| } |
|
| main() { |
|
| exit(! does_int64_snprintf_work()); |
|
| }], |
|
| [ AC_MSG_RESULT(yes) |
|
| INT64_FORMAT='"%qd"' |
|
| ], |
|
| [ AC_MSG_RESULT(no) |
|
| # Force usage of our own snprintf, since system snprintf is broken |
|
| SNPRINTF='snprintf.o' |
|
| INT64_FORMAT='"%lld"' |
|
| ], |
|
| [ AC_MSG_RESULT(assuming not on target machine) |
|
| # Force usage of our own snprintf, since we cannot test foreign snprintf |
|
| SNPRINTF='snprintf.o' |
|
| INT64_FORMAT='"%lld"' |
|
| ]) ], |
|
| [ AC_MSG_RESULT(assuming not on target machine) |
|
| # Force usage of our own snprintf, since we cannot test foreign snprintf |
|
| SNPRINTF='snprintf.o' |
|
| INT64_FORMAT='"%lld"' |
|
| ]) |
|
| else |
else |
| # here if we previously decided we needed to use our own snprintf |
# Here if we previously decided we needed to use our own snprintf |
| INT64_FORMAT='"%lld"' |
LONG_LONG_INT_FORMAT='%lld' |
| fi |
fi |
| |
INT64_FORMAT="\"$LONG_LONG_INT_FORMAT\"" |
| else |
else |
| # Here if we are not using 'long long int' at all |
# Here if we are not using 'long long int' at all |
| INT64_FORMAT='"%ld"' |
INT64_FORMAT='"%ld"' |
| fi |
fi |
| |
|
| AC_DEFINE_UNQUOTED(INT64_FORMAT, $INT64_FORMAT) |
AC_DEFINE_UNQUOTED(INT64_FORMAT, $INT64_FORMAT, |
| |
[Define to the appropriate snprintf format for 64-bit ints, if any.]) |
| |
|
| |
if test $pgac_need_repl_snprintf = yes; then |
| |
AC_LIBOBJ(snprintf) |
| |
fi |
| |
|
| dnl Determine memory alignment requirements for the basic C datatypes. |
# Need a #define for the size of Datum (unsigned long) |
| |
AC_CHECK_SIZEOF([unsigned long]) |
| |
|
| dnl CHECK_ALIGNOF(TYPE) |
# Determine memory alignment requirements for the basic C data types. |
| dnl This is modeled on the standard autoconf macro AC_CHECK_SIZEOF, |
|
| dnl except it finds the alignment requirement of the type instead of the size. |
|
| dnl The defined symbol is named ALIGNOF_TYPE, where the type name is |
|
| dnl converted in the same way as for AC_CHECK_SIZEOF. |
|
| dnl If cross-compiling, sizeof(type) is used as a default assumption. |
|
| |
|
| AC_DEFUN(CHECK_ALIGNOF, |
|
| [changequote(<<, >>)dnl |
|
| dnl The name to #define. |
|
| define(<<AC_TYPE_NAME>>, translit(alignof_$1, [a-z *], [A-Z_P]))dnl |
|
| dnl The cache variable name. |
|
| define(<<AC_CV_NAME>>, translit(ac_cv_alignof_$1, [ *], [_p]))dnl |
|
| changequote([, ])dnl |
|
| AC_MSG_CHECKING(alignment of $1) |
|
| AC_CACHE_VAL(AC_CV_NAME, |
|
| [AC_TRY_RUN([#include <stdio.h> |
|
| struct { char filler; $1 field; } mystruct; |
|
| main() |
|
| { |
|
| FILE *f=fopen("conftestval", "w"); |
|
| if (!f) exit(1); |
|
| fprintf(f, "%d\n", ((char*) & mystruct.field) - ((char*) & mystruct)); |
|
| exit(0); |
|
| }], AC_CV_NAME=`cat conftestval`, |
|
| AC_CV_NAME='sizeof($1)', |
|
| AC_CV_NAME='sizeof($1)')])dnl |
|
| AC_MSG_RESULT($AC_CV_NAME) |
|
| AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME) |
|
| undefine([AC_TYPE_NAME])dnl |
|
| undefine([AC_CV_NAME])dnl |
|
| ]) |
|
| |
|
| CHECK_ALIGNOF(short) |
PGAC_CHECK_ALIGNOF(short) |
| CHECK_ALIGNOF(int) |
PGAC_CHECK_ALIGNOF(int) |
| CHECK_ALIGNOF(long) |
PGAC_CHECK_ALIGNOF(long) |
| if [[ $HAVE_LONG_LONG_INT_64 -eq 1 ]] ; then |
if test x"$HAVE_LONG_LONG_INT_64" = x"yes" ; then |
| CHECK_ALIGNOF(long long int) |
PGAC_CHECK_ALIGNOF(long long int) |
| fi |
fi |
| CHECK_ALIGNOF(double) |
PGAC_CHECK_ALIGNOF(double) |
| |
|
| dnl Compute maximum alignment of any basic type. |
# Compute maximum alignment of any basic type. |
| dnl We assume long's alignment is at least as strong as char, short, or int; |
# We assume long's alignment is at least as strong as char, short, or int; |
| dnl but we must check long long (if it exists) and double. |
# but we must check long long (if it exists) and double. |
| |
|
| if [[ $ac_cv_alignof_double != 'sizeof(double)' ]] ; then |
MAX_ALIGNOF=$pgac_cv_alignof_long |
| MAX_ALIGNOF="$ac_cv_alignof_long" |
if test $MAX_ALIGNOF -lt $pgac_cv_alignof_double ; then |
| if [[ $MAX_ALIGNOF -lt $ac_cv_alignof_double ]] ; then |
MAX_ALIGNOF=$pgac_cv_alignof_double |
| MAX_ALIGNOF="$ac_cv_alignof_double" |
fi |
| fi |
if test x"$HAVE_LONG_LONG_INT_64" = xyes && test $MAX_ALIGNOF -lt $pgac_cv_alignof_long_long_int ; then |
| if [[ $HAVE_LONG_LONG_INT_64 -eq 1 ]] ; then |
MAX_ALIGNOF="$pgac_cv_alignof_long_long_int" |
| if [[ $MAX_ALIGNOF -lt $ac_cv_alignof_long_long_int ]] ; then |
fi |
| MAX_ALIGNOF="$ac_cv_alignof_long_long_int" |
AC_DEFINE_UNQUOTED(MAXIMUM_ALIGNOF, $MAX_ALIGNOF, [Define as the maximum alignment requirement of any C data type.]) |
| fi |
|
| fi |
|
| |
# 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 |
else |
| dnl cross-compiling: assume that double's alignment is worst case |
if test x"$USE_UNNAMED_POSIX_SEMAPHORES" = x"1" ; then |
| MAX_ALIGNOF="$ac_cv_alignof_double" |
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 |
fi |
| AC_DEFINE_UNQUOTED(MAXIMUM_ALIGNOF, $MAX_ALIGNOF) |
|
| |
|
| |
|
| dnl Check to see if platform has POSIX signal interface. |
# Select shared-memory implementation type. |
| dnl NOTE: if this test fails then POSIX signals definitely don't work. |
AC_DEFINE(USE_SYSV_SHARED_MEMORY, 1, [Define to select SysV-style shared memory.]) |
| dnl It could be that the test compiles but the POSIX routines don't |
SHMEM_IMPLEMENTATION="src/backend/port/sysv_shmem.c" |
| dnl really work ... in that case the platform-specific port files |
|
| dnl can unset USE_POSIX_SIGNALS and HAVE_POSIX_SIGNALS. (The former |
|
| dnl goes into config.h, the latter into Makefile.global.) |
|
| |
|
| AC_MSG_CHECKING(for POSIX signal interface) |
|
| AC_TRY_LINK([#include <signal.h>], |
|
| [struct sigaction act, oact; |
|
| sigemptyset(&act.sa_mask); |
|
| act.sa_flags = SA_RESTART; |
|
| sigaction(0, &act, &oact);], |
|
| [AC_DEFINE(USE_POSIX_SIGNALS) |
|
| HAVE_POSIX_SIGNALS="1" |
|
| AC_MSG_RESULT(yes)], |
|
| [HAVE_POSIX_SIGNALS="" |
|
| AC_MSG_RESULT(no)]) |
|
| AC_SUBST(HAVE_POSIX_SIGNALS) |
|
| |
|
| dnl Check for Tcl configuration script tclConfig.sh |
|
| |
|
| dnl If --with-tclconfig was given, don't check for tclsh, tcl |
if test "$enable_nls" = yes ; then |
| if test -z "$TCL_DIRS" |
PGAC_CHECK_GETTEXT |
| then |
|
| AC_PATH_PROG(TCLSH, tclsh) |
|
| if test -z "$TCLSH" |
|
| then |
|
| AC_PATH_PROG(TCLSH, tcl) |
|
| if test -z "$TCLSH" |
|
| then |
|
| AC_MSG_WARN(TCL/TK support disabled; tcl shell is not in your path) |
|
| USE_TCL= |
|
| fi |
|
| fi |
|
| fi |
fi |
| |
|
| if test "$USE_TCL" = true |
# Check for Tcl configuration script tclConfig.sh |
| then |
if test "$with_tcl" = yes; then |
| AC_MSG_CHECKING(for tclConfig.sh) |
PGAC_PATH_TCLCONFIGSH([$with_tclconfig]) |
| TCL_CONFIG_SH= |
PGAC_EVAL_TCLCONFIGSH([$TCL_CONFIG_SH], |
| library_dirs= |
[TCL_INCLUDE_SPEC,TCL_LIB_FILE,TCL_LIBS,TCL_LIB_SPEC,TCL_SHARED_BUILD]) |
| if test -z "$TCL_DIRS" |
AC_SUBST(TCL_SHLIB_LD_LIBS)dnl don't want to double-evaluate that one |
| then |
|
| library_dirs=`echo 'puts $auto_path' | $TCLSH` |
|
| fi |
|
| library_dirs="$TCL_DIRS $TK_DIRS $library_dirs" |
|
| for dir in $library_dirs; do |
|
| if test -d "$dir" -a -r "$dir/tclConfig.sh"; then |
|
| TCL_CONFIG_SH=$dir/tclConfig.sh |
|
| break |
|
| fi |
|
| done |
|
| if test -z "$TCL_CONFIG_SH"; then |
|
| AC_MSG_RESULT(no) |
|
| AC_MSG_WARN(TCL/TK support disabled; Tcl configuration script missing) |
|
| USE_TCL= |
|
| else |
|
| AC_MSG_RESULT($TCL_CONFIG_SH) |
|
| AC_SUBST(TCL_CONFIG_SH) |
|
| fi |
|
| fi |
fi |
| |
|
| USE_TK=$USE_TCL # If TCL is disabled, disable TK |
# Check for Tk configuration script tkConfig.sh |
| |
if test "$with_tk" = yes; then |
| |
PGAC_PATH_TKCONFIGSH([$with_tkconfig $with_tclconfig]) |
| |
PGAC_EVAL_TCLCONFIGSH([$TK_CONFIG_SH], [TK_LIBS,TK_LIB_SPEC,TK_XINCLUDES]) |
| |
fi |
| |
|
| dnl Check for Tk configuration script tkConfig.sh |
|
| if test "$USE_TK" = true |
# |
| then |
# Check for DocBook and tools |
| AC_MSG_CHECKING(for tkConfig.sh) |
# |
| TK_CONFIG_SH= |
PGAC_PROG_NSGMLS |
| # library_dirs are set in the check for TCL |
PGAC_PROG_JADE |
| for dir in $library_dirs |
PGAC_CHECK_DOCBOOK(3.1) |
| do |
PGAC_PATH_DOCBOOK_STYLESHEETS |
| if test -d "$dir" -a -r "$dir/tkConfig.sh" |
PGAC_PATH_COLLATEINDEX |
| then |
AC_CHECK_PROGS(SGMLSPL, sgmlspl) |
| TK_CONFIG_SH=$dir/tkConfig.sh |
|
| break |
|
| fi |
# prepare build tree if outside source tree |
| done |
# Note 1: test -ef might not exist, but it's more reliable than `pwd`. |
| if test -z "$TK_CONFIG_SH" |
# Note 2: /bin/pwd might be better than shell's built-in at getting |
| then |
# a symlink-free name. |
| AC_MSG_RESULT(no) |
if test "$no_create" != yes; then |
| AC_MSG_WARN(TK support disabled; Tk configuration script missing) |
if ( test "$srcdir" -ef . ) >/dev/null 2>&1 || test "`cd $srcdir && /bin/pwd`" = "`/bin/pwd`"; then |
| USE_TK= |
: |
| else |
else |
| AC_MSG_RESULT($TK_CONFIG_SH) |
AC_SUBST(vpath_build, yes) |
| AC_SUBST(TK_CONFIG_SH) |
_AS_ECHO_N([preparing build tree... ]) |
| AC_PATH_PROG(WISH, wish) |
pgac_abs_top_srcdir=`cd "$srcdir" && pwd` |
| fi |
$SHELL "$ac_aux_dir/prep_buildtree" "$pgac_abs_top_srcdir" "." \ |
| fi |
|| AC_MSG_ERROR(failed) |
| |
AC_MSG_RESULT(done) |
| USE_X=$USE_TK |
fi |
| |
fi |
| dnl Check for X libraries |
|
| |
|
| if test "$USE_X" = true; then |
AC_CONFIG_FILES([GNUmakefile src/Makefile.global]) |
| |
|
| ice_save_LIBS="$LIBS" |
AC_CONFIG_LINKS([ |
| ice_save_CFLAGS="$CFLAGS" |
src/backend/port/dynloader.c:src/backend/port/dynloader/${template}.c |
| ice_save_CPPFLAGS="$CPPFLAGS" |
src/backend/port/pg_sema.c:${SEMA_IMPLEMENTATION} |
| ice_save_LDFLAGS="$LDFLAGS" |
src/backend/port/pg_shmem.c:${SHMEM_IMPLEMENTATION} |
| |
src/include/dynloader.h:src/backend/port/dynloader/${template}.h |
| AC_PATH_XTRA |
src/include/pg_config_os.h:src/include/port/${template}.h |
| |
src/Makefile.port:src/makefiles/Makefile.${template} |
| LIBS="$LIBS $X_EXTRA_LIBS" |
]) |
| CFLAGS="$CFLAGS $X_CFLAGS" |
|
| CPPFLAGS="$CPPFLAGS $X_CFLAGS" |
AC_CONFIG_HEADERS([src/include/pg_config.h], |
| LDFLAGS="$LDFLAGS $X_LIBS" |
[ |
| |
# Update timestamp for pg_config.h (see Makefile.global) |
| dnl Check for X library |
echo >src/include/stamp-h |
| |
]) |
| X11_LIBS="" |
|
| AC_CHECK_LIB(X11, XOpenDisplay, X11_LIBS="-lX11",,${X_PRE_LIBS}) |
AC_OUTPUT |
| if test "$X11_LIBS" = ""; then |
|
| dnl Not having X is bad news for pgtksh. Let the user fix this. |
|
| AC_MSG_WARN([The X11 library '-lX11' could not be found, |
|
| so TK support will be disabled. To enable TK support, |
|
| please use the configure options '--x-includes=DIR' |
|
| and '--x-libraries=DIR' to specify the X location. |
|
| See the file 'config.log' for further diagnostics.]) |
|
| USE_TK= |
|
| fi |
|
| AC_SUBST(X_LIBS) |
|
| AC_SUBST(X11_LIBS) |
|
| AC_SUBST(X_PRE_LIBS) |
|
| |
|
| LIBS="$ice_save_LIBS" |
|
| CFLAGS="$ice_save_CFLAGS" |
|
| CPPFLAGS="$ice_save_CPPFLAGS" |
|
| LDFLAGS="$ice_save_LDFLAGS" |
|
| fi |
|
| |
|
| dnl cause configure to recurse into subdirectories with their own configure |
|
| dnl Darn, setting AC_CONFIG_SUBDIRS sets a list $subdirs$ in the configure output |
|
| dnl file, but then configure doesn't bother using that list. Probably a bug in |
|
| dnl this version of autoconf. |
|
| dnl So at the moment interfaces/odbc gets configured unconditionally. |
|
| dnl - thomas 1998-10-05 |
|
| #if test "X$USE_ODBC" = "Xtrue" |
|
| #then |
|
| # AC_CONFIG_SUBDIRS(interfaces/odbc) |
|
| #fi |
|
| if test "$USE_ODBC" = "true" |
|
| then |
|
| PWD_INCDIR=no |
|
| AC_CHECK_HEADER(pwd.h, PWD_INCDIR=yes) |
|
| if test "$PWD_INCDIR" = "no"; then |
|
| AC_MSG_WARN(odbc support disabled; pwd.h missing) |
|
| USE_ODBC= |
|
| fi |
|
| AC_SUBST(USE_ODBC) |
|
| fi |
|
| |
|
| dnl Output files that are neither makefiles nor shell scripts probably |
|
| dnl need fully-expanded substitutions, rather than partial expansions |
|
| dnl that include references to other variables. Currently the only |
|
| dnl such item that's needed is an expanded version of libdir, but |
|
| dnl others may be needed someday. NOTE: 'eval' technique only copes |
|
| dnl with one level of indirect reference per expansion; two levels is |
|
| dnl currently enough for libdir, but it's ugly... |
|
| |
|
| dnl First we have to force 'NONE' prefix to be expanded itself. |
|
| dnl For some reason, autoconf 2.13 doesn't do this until AC_OUTPUT, |
|
| dnl which is too late... |
|
| test "x$prefix" = xNONE && prefix=$ac_default_prefix |
|
| test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' |
|
| |
|
| eval expanded_libdir="$libdir" |
|
| eval expanded_libdir="$expanded_libdir" |
|
| AC_SUBST(expanded_libdir) |
|
| |
|
| dnl Finally ready to produce output files ... |
|
| |
|
| AC_OUTPUT( |
|
| GNUmakefile |
|
| src/GNUmakefile |
|
| src/Makefile.global |
|
| src/backend/port/Makefile |
|
| src/backend/catalog/genbki.sh |
|
| src/backend/utils/Gen_fmgrtab.sh |
|
| src/bin/pg_dump/Makefile |
|
| src/bin/pg_version/Makefile |
|
| src/bin/pgtclsh/mkMakefile.tcldefs.sh |
|
| src/bin/pgtclsh/mkMakefile.tkdefs.sh |
|
| src/bin/psql/Makefile |
|
| src/include/version.h |
|
| src/interfaces/libpq/Makefile |
|
| src/interfaces/ecpg/lib/Makefile |
|
| src/interfaces/ecpg/preproc/Makefile |
|
| src/interfaces/libpq++/Makefile |
|
| src/interfaces/libpgeasy/Makefile |
|
| src/interfaces/libpgtcl/Makefile |
|
| src/interfaces/odbc/GNUmakefile |
|
| src/interfaces/odbc/Makefile.global |
|
| src/pl/plpgsql/src/Makefile |
|
| src/pl/plpgsql/src/mklang.sql |
|
| src/pl/tcl/mkMakefile.tcldefs.sh |
|
| src/test/regress/GNUmakefile |
|
| ) |
|
![[BACK]](/https/anoncvs.postgresql.org/cvsweb/icons/back.gif){kind=icon}
Return to configure.in CVS log ![[TXT]](/https/anoncvs.postgresql.org/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/https/anoncvs.postgresql.org/cvsweb/icons/dir.gif){kind=icon}
Up to [PostgreSQL CVS Repository] / pgsql