The R Project SVN R

dnl configure.in
dnl
dnl Process this file with autoconf to produce a configure script.
dnl
dnl Copyright (C) 1998, 1999, 2000 R Core Team
###
### This file is part of R.
###
### R is free software; you can redistribute it and/or modify it under
### the terms of the GNU General Public License as published by the Free
### Software Foundation; either version 2 of the License, or (at your
### option) any later version.
###
### R is distributed in the hope that it will be useful, but WITHOUT ANY
### WARRANTY; without even the implied warranty of MERCHANTABILITY or
### FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
### License for more details.
###
### You should have received a copy of the GNU General Public License
### along with R; if not, you can obtain it via the World Wide Web at
### `http://www.gnu.org/copyleft/gpl.html', or by writing to the Free
### Software Foundation, 59 Temple Place -- Suite 330, Boston, MA
### 02111-3307, USA.

AC_PREREQ(2.13)

AC_INIT(src/include/Defn.h)
AC_CONFIG_AUX_DIR(tools)

PACKAGE="R"
VERSION=`cat ${srcdir}/VERSION | cut -d" " -f1`
AM_INIT_AUTOMAKE(${PACKAGE}, ${VERSION})
AM_CONFIG_HEADER(src/include/config.h)

### Platform

AC_CANONICAL_HOST
AC_DEFINE_UNQUOTED(R_PLATFORM, "${host}")
AC_DEFINE_UNQUOTED(R_CPU, "${host_cpu}")
AC_DEFINE_UNQUOTED(R_VENDOR, "${host_vendor}")
AC_DEFINE_UNQUOTED(R_OS, "${host_os}")

R_PLATFORM="${host}"
AC_SUBST(R_PLATFORM)

case "${host_os}" in
  macos*)
    AC_DEFINE(Macintosh) ;;
  cygwin*|mingw*|windows*|winnt)
    AC_DEFINE(Win32) ;;
  *)
    AC_DEFINE(Unix) ;;
esac

### Defaults

f="${srcdir}/config.site"
if test -r ${f}; then echo "loading site script ${f}"; . ${f}; fi
f="${HOME}/.Rconf"
if test -r ${f}; then echo "loading user script ${f}"; . ${f} ; fi
f="./config.site"
if test -r ${f}; then echo "loading build specific script ${f}"; . ${f} ; fi

### Handle arguments to configure

config_opts=${ac_configure_args}
AC_SUBST(config_opts)

## Allow the user to specify support for R-profiling.
AC_ARG_ENABLE(R-profiling,
  [  --enable-R-profiling    attempt to compile support for Rprof() [yes]],
  [ if test "${enableval}" = no; then
      want_R_profiling=no
    elif test "${enableval}" = yes; then
      want_R_profiling=yes
    else
      want_R_profiling=yes
    fi],
  want_R_profiling=yes)

## Allow the user to specify building R shared libraries.
AC_ARG_ENABLE(R-shlib,
  [  --enable-R-shlib        build R as a shared library [no]],
  [ want_R_shlib="${enableval}" ],
  want_R_shlib=no)
## FIXME:
## Should add a check whether the user disabled shlibs in general?

## Enable maintainer-specific portions of Makefiles.
AC_ARG_ENABLE(maintainer-mode,
  [  --enable-maintainer-mode
                          enable make rules and dependencies not useful
              (and maybe confusing) to the casual installer
              [no]],
  use_maintainer_mode=${enableval},
  use_maintainer_mode=no)
AM_CONDITIONAL(MAINTAINER_MODE, test "${use_maintainer_mode}" = yes)

## Enable testing the write barrier.
AC_ARG_ENABLE(strict-barrier,
  [  --enable-strict-barrier
                          provoke compile error on write barrier violation
              [no]],
  [ if test "${enableval}" = yes; then
      AC_DEFINE(TESTING_WRITE_BARRIER, 1)
    fi],
  [])

## Allow the user to force us to use f2c.
AC_ARG_WITH(f2c,
  [  --with-f2c              use f2c even if FORTRAN compiler is available],
  R_ARG_USE(f2c),
  use_f2c=false)
## Allow the user to force us to use g77.
AC_ARG_WITH(g77,
  [  --with-g77              use g77 to compile FORTRAN subroutines],
  R_ARG_USE(g77),
  use_g77=false)
## Allow the user to force us to use f77.
AC_ARG_WITH(f77,
  [  --with-f77              use f77 to compile FORTRAN subroutines],
  R_ARG_USE(f77),
  use_f77=false)

## Make sure only one of the above options for Fortran compilers was
## specified.
R_ARG_WITH_EXCLUSIVE(f77, g77,
 [warn_f77_and_g77="--with-f77 and --with-g77 both given!  Using f77 ..."
  AC_MSG_WARN(${warn_f77_and_g77})
  use_g77=false])
R_ARG_WITH_EXCLUSIVE(f77, f2c,
 [warn_f77_and_f2c="--with-f77 and --with-f2c both given!  Using f77 ..."
  AC_MSG_WARN(${warn_f77_and_f2c})
  use_f2c=false])
R_ARG_WITH_EXCLUSIVE(g77, f2c,
 [warn_g77_and_f2c="--with-g77 and --with-f2c both given!  Using g77 ..."
  AC_MSG_WARN(${warn_g77_and_f2c})
  use_f2c=false])

AC_ARG_WITH(blas,
  [  --with-blas             use specified BLAS library],
  R_ARG_USE(blas),
  use_blas=true)

AC_ARG_WITH(readline,
  [  --with-readline         use readline library (if available) [yes]],
  R_ARG_USE(readline),
  use_readline=true)

AC_ARG_WITH(gnome,
  [  --with-gnome            use GNOME, or specify its prefix [no]],
  [ if test "${withval}" = no; then
      want_gnome=no
    elif test "${withval}" = yes; then
      want_gnome=yes
    else
      want_gnome=yes
      LIBS="${LIBS} -L${withval}/lib"
      CPPFLAGS="${CPPFLAGS} -I${withval}/include"
      gnome_prefix=${withval}/lib
    fi],
  want_gnome=no)

AC_ARG_WITH(tcltk,
  [  --with-tcltk            use Tcl/Tk, or specify its library dir [yes]],
  [ if test "${withval}" = no; then
      want_tcltk=no
    elif test "${withval}" = yes; then
      want_tcltk=yes
    else
      want_tcltk=yes
      LIBS="${LIBS} -L${withval}"
      tcltk_prefix=${withval}
    fi],
  want_tcltk=yes)
AC_ARG_WITH(tcl-config,
  [  --with-tcl-config=TCL_CONFIG
                          specify location of tclConfig.sh []],
  TCL_CONFIG=${withval},
  TCL_CONFIG="")
AC_ARG_WITH(tk-config,
  [  --with-tk-config=TK_CONFIG
                          specify location of tkConfig.sh []],
  TK_CONFIG=${withval},
  TK_CONFIG="")

## FIXME:
## Completely disable using libtool for building shlibs until libtool
## fully supports at least Fortran and C++.
## AC_ARG_WITH(libtool,
##   [  --with-libtool          use libtool for building shared libraries [yes]],
##   use_libtool=${withval},
##   use_libtool=yes)
## </FIXME>
AM_CONDITIONAL(USE_LIBTOOL, test "${use_libtool}" = yes)    

### C compiler.

AC_PROG_CC
AC_PROG_CPP
AC_PROG_GCC_TRADITIONAL

: ${CPPFLAGS="-I/usr/local/include"}
: ${LIBS="-L/usr/local/lib"}

dnl Yes, we already need this at configure time ...
case "${host}" in
  *aix*)
    AC_AIX
    LIBS="${LIBS} -lc"
    ;;
  *hpux*)
    case "${CC}" in
      cc)
        if test `echo ${CFLAGS} | grep -c -e "-A[ae] "` = 0; then
      CFLAGS="${CFLAGS} -Aa"
    fi
    AC_DEFINE(_HPUX_SOURCE)
    ;;
      c89)
    AC_DEFINE(_HPUX_SOURCE)
    ;;
    esac
    ;;
esac

R_PROG_CC_M
R_PROG_CC_C_O_LO

### Programs.

AC_PROG_AWK
AC_PROG_LN_S
AC_PROG_RANLIB
AC_PROG_YACC
R_PROG_AR
R_PROG_ECHO_N
R_PROG_INSTALL
## Libtool
AM_DISABLE_STATIC
AM_PROG_LIBTOOL
AC_SUBST(LIBTOOL_DEPS)
## Make
: ${MAKE=make}
AC_SUBST(MAKE)
## Perl
R_PROG_PERL
## Tar
: ${TAR=tar}
AC_SUBST(TAR)
## TeXMF stuff
R_PROG_TEXMF
## Unzip && zip
AC_PATH_PROGS(R_UNZIPCMD, [${UNZIP} unzip], "")
AC_PATH_PROGS(R_ZIPCMD, [${ZIP} zip], "")

### FORTRAN compiler

## If we have not been forced to use a particular FORTRAN compiler, try
## to find one using one of the several common names.
##
## The configure options `--with-g77', `--with-f77', or `--with-f2c'
## force g77, f77, or f2c to be used.  It is also possible to use these
## options to specify the full path name of the compiler.

if test -n "${FC}"; then
  F77=${FC}
  AC_MSG_RESULT([defining F77 to be ${F77}])
elif ${use_f77}; then
  if test "${with_f77}" = yes; then
    F77=f77
  else
    F77="${with_f77}"
  fi
  AC_MSG_RESULT([defining F77 to be ${F77}])
elif ${use_g77}; then
  if test "${with_g77}" = yes; then
    F77=g77
  else
    F77="${with_g77}"
  fi
  AC_MSG_RESULT([defining F77 to be ${F77}])
elif ${use_f2c}; then
  F77=
  if test "${with_f2c}" = yes; then
    F2C=f2c
  else
    F2C="${with_f2c}"
  fi
  AC_MSG_RESULT([defining F2C to be ${F2C}])
else
  F77=
  for name in g77 fort77 f77 f90 xlf cf77 fc; do
    AC_PATH_PROG(F77, ${name})
    if test -n "${F77}"; then
      if test -n "`file ${F77} | grep script`"; then
    dnl If F77 found above is a shell or perl script, do not use it.
    F77=
      else
    F77=`basename ${F77}`
    break
      fi
    fi
  done
  if test -z "${F77}"; then
    AC_CHECK_PROG(F2C, f2c, f2c, [])
  fi
fi

if test -n "${F77}"; then
  FC=${F77}
  AC_PROG_F77
  AC_F77_LIBRARY_LDFLAGS
  R_PROG_F77_APPEND_UNDERSCORE
  R_PROG_F77_CC_COMPAT
  f77_rules_frag=Makefrag.f77
  cat << \EOF > ${f77_rules_frag}
.f.c:
.f.o:
    $(FC) $(ALL_FFLAGS) -c $< -o $[@]
EOF
  R_PROG_F77_C_O_LO
  if test "${r_cv_prog_f77_c_o_lo}" = yes; then
    cat << \EOF >> ${f77_rules_frag}
.f.lo:
    $(FC) $(ALL_FFLAGS_LO) -c $< -o $[@]
EOF
  else
    cat << \EOF >> ${f77_rules_frag}
.f.lo:
    @test -d .libs || mkdir .libs
    $(FC) $(ALL_FFLAGS_LO) -c $< -o .libs/$[*].o
    mv .libs/$[*].o $[*].lo
EOF
  fi
elif test -n "${F2C}"; then
  R_PROG_F2C_FLIBS
  f77_rules_frag=Makefrag.f77
  cat << \EOF > ${f77_rules_frag}
.f.o:
    $(F2C) $(F2CFLAGS) < $< > $[*].c
    $(CC) $(ALL_CPPFLAGS) $(ALL_CFLAGS) -c $[*].c -o $[@]
    @rm -f $[*].c
.f.lo:
    $(F2C) $(F2CFLAGS) < $< > $[*].c
EOF
  if test "${r_cv_prog_cc_c_o_lo}" = yes; then
    cat << \EOF >> ${f77_rules_frag}
    $(CC) $(ALL_CPPFLAGS) $(ALL_CFLAGS_LO) -c $[*].c -o $[@]
EOF
  else
    cat << \EOF >> ${f77_rules_frag}
    @test -d .libs || mkdir .libs
    $(CC) $(ALL_CPPFLAGS) $(ALL_CFLAGS_LO) -c $[*].c -o .libs/$[*].o
    mv .libs/$[*].o $[*].lo
EOF
  fi
  cat << \EOF >> ${f77_rules_frag}
    @rm -f $[*].c
EOF
else
  AC_MSG_ERROR([Neither an F77 compiler nor f2c found])
fi

AC_SUBST(FC)
AC_SUBST(F2C)
AC_SUBST_FILE(f77_rules_frag)

### Libraries.

## FIXME: Should be needed for tests using AC_TRY_RUN()?
## Make sure that non-standard directories specified via `-L' are really
## searched in the tests.
for arg in ${LIBS}; do
  case ${arg} in
    -L*)
      lib=`echo ${arg} | sed "s/^-L//"`
      if test -z "${R_LD_LIBRARY_PATH}"; then
        R_LD_LIBRARY_PATH="${lib}"
      else
        R_LD_LIBRARY_PATH="${R_LD_LIBRARY_PATH}:${lib}"
      fi
      ;;
  esac
done
if test -z "${LD_LIBRARY_PATH}"; then
  LD_LIBRARY_PATH="${R_LD_LIBRARY_PATH}"
else
  LD_LIBRARY_PATH="${R_LD_LIBRARY_PATH}:${LD_LIBRARY_PATH}"
fi
export LD_LIBRARY_PATH

## C++ compiler.
## Needs to follow Libraries as -lstdc++ might well be in /usr/local/lib
## and so not found at run time.

AC_PROG_CXX
AC_PROG_CXXCPP

AC_CHECK_LIB(m, sin)
if ${use_libmoto}; then
  AC_CHECK_LIB(moto, sin)
fi
AC_CHECK_LIB(ncurses, main,,
  AC_CHECK_LIB(termcap, main,,
    AC_CHECK_LIB(termlib, main)
))
AC_CHECK_LIB(dl, dlopen)
AC_CHECK_LIB(z, main)

## Special checks for odd OS specific things
AC_CHECK_FUNC(gethostbyname)
if test "${ac_cv_func_gethostbyname}" = no; then
  AC_CHECK_LIB(nsl, gethostbyname)
fi
AC_CHECK_FUNC(connect)
if test "${ac_cv_func_connect}" = no; then
  AC_CHECK_LIB(socket, connect)
fi

## BLAS
if ${use_blas}; then
  R_BLAS_LIBS
fi
if test -n "${BLAS_LIBS}"; then
  BLAS=
else
  BLAS="blas.o"
fi
AC_SUBST(BLAS)

if ${use_readline}; then
  AC_CHECK_LIB(readline, rl_callback_read_char)
fi

### Library functions.

AC_FUNC_ALLOCA
AC_FUNC_VFORK
AC_FUNC_VPRINTF
AC_CHECK_FUNCS(access acosh asinh atanh bcopy finite getcwd getgrgid \
  getpwuid getuid hypot isnan matherr memcpy memmove popen putenv rint \
  setenv strcoll stat strptime system times unsetenv vsnprintf)
AC_REPLACE_FUNCS(strdup)
R_FUNC___SETFPUCW
R_FUNC_CALLOC
R_FUNC_FINITE
R_FUNC_LOG

### Header files.

AC_HEADER_STDC
AC_HEADER_TIME
AC_HEADER_DIRENT
AC_HEADER_SYS_WAIT
AC_CHECK_HEADERS(dl.h dlfcn.h elf.h floatingpoint.h fpu_control.h \
  grp.h ieee754.h ieeefp.h locale.h netdb.h netinet/in.h netinet/tcp.h \
  pwd.h readline/history.h readline/readline.h rpc/rpc.h rpc/xdr.h \
  string.h sys/param.h sys/socket.h sys/stat.h sys/time.h sys/times.h \
  sys/utsname.h unistd.h)
case "${host}" in
  *sunos4*)
    AC_DEFINE(SunOS4) ;;
esac
R_HEADER_SETJMP
R_HEADER_GLIBC2

### Typedefs.

AC_TYPE_SIGNAL
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_CHECK_TYPE(blkcnt_t, long)

### C Compiler characteristics.

AC_C_BIGENDIAN
AC_C_CONST
if test "${cross_compiling}" = yes; then
  AC_MSG_WARN([assuming C longs are 4 byte on ${host}])
fi
AC_CHECK_SIZEOF(long, 4)
R_C_IEEE_754

case "${host}" in
  i[[3456789]]86-*-*)
    R_PROG_CC_FLAG(-mieee-fp,
      R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -mieee-fp")
    R_PROG_CXX_FLAG(-mieee-fp,
      R_XTRA_CXXFLAGS="${R_XTRA_CXXFLAGS} -mieee-fp")
    ## In current glibc, inline version [x86] of exp is broken
    AC_EGREP_CPP(yes,
      [ #include <math.h>
        #if defined(__GLIBC__)
          yes
    #endif ],
      R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -D__NO_MATH_INLINES")
    ;;
  *aix4.[[2-9]]*)
    AC_DEFINE(HAVE_NO_SYMBOL_UNDERSCORE)
    if test "${GCC}" = yes; then
      R_PROG_CC_FLAG(-mno-fp-in-toc,
        R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -mno-fp-in-toc")
    fi
    R_XTRA_LIBS="${R_XTRA_LIBS} /lib/crt0.o"
    ;;
  alpha*osf*)
    AC_DEFINE(HAVE_NO_SYMBOL_UNDERSCORE)
    ## <Albrecht.Gebhardt@uni-klu.ac.at>
    if test "${GCC}" = yes; then
      R_PROG_CC_FLAG(-mieee,
        R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -mieee")
    else
      R_PROG_CC_FLAG(-ieee_with_inexact,
        R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -ieee_with_inexact")
      R_PROG_CC_FLAG(-std1,
        R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -std1")
    fi
    if test "${G77}" = yes; then
      R_XTRA_FFLAGS="${R_XTRA_FFLAGS} -mieee"
    else
      R_XTRA_FFLAGS="${R_XTRA_FFLAGS} -fpe3"
    fi
    ## </Albrecht.Gebhardt@uni-klu.ac.at>
    ;;
  alpha*linux*)
    R_PROG_CC_FLAG(-mieee,
      R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -mieee"
      R_XTRA_FFLAGS="${R_XTRA_FFLAGS} -mieee")
    ;;
  *hpux*)
    AC_DEFINE(HAVE_NO_SYMBOL_UNDERSCORE)
    AC_DEFINE(USE_BUILTIN_RINT)
    case "${CC}" in
      cc|c89)
    R_XTRA_CFLAGS="${R_XTRA_CFLAGS} -D_HPUX_SOURCE"
    ;;
    esac
    AC_CHECK_LIB(dld, shl_load, R_XTRA_LIBS="${R_XTRA_LIBS} -ldld")
    ;;
  *irix*)
    R_C_OPTIEEE
    ;;
esac

AC_SUBST(CFLAGS)
AC_SUBST(MAIN_CFLAGS)
AC_SUBST(SHLIB_CFLAGS)
AC_SUBST(CXXFLAGS)
AC_SUBST(SHLIB_CXXFLAGS)
AC_SUBST(FFLAGS)
AC_SUBST(MAIN_FFLAGS)
AC_SUBST(SHLIB_FFLAGS)
AC_SUBST(F2CFLAGS)
AC_SUBST(R_XTRA_CFLAGS)
AC_SUBST(R_XTRA_CXXFLAGS)
AC_SUBST(R_XTRA_FFLAGS)
AC_SUBST(R_XTRA_LIBS)

## DLL stuff

## We need to determine the following:
##
## MAIN_LD, MAINLD_FLAGS
##   command and flags for loading the main binary so that it will load
##   shared libraries (DLLs) at runtime, also for profiling.
## CPICFLAGS, CXXPICFLAGS, FPICFLAGS
##   flags for compiling C, C++, and Fortran library code
## SHLIB_LD, SHLIB_LDFLAGS
##   command and flags for creating DLLs (which contain object files
##   from a C or Fortran compiler).
## SHLIB_CXXLD, SHLIB_CXXLDFLAGS
##   command and flags for creating DLLs which contain object files from
##   a C++ compiler.  According to autoconf, the C++ compiler/linker
##   must be used for linking in this case (since special C++-ish things
##   need to happen at link time like calling global constructors,
##   instantiating templates, enabling exception support, etc.).
##
## The procedure is as follows.
##   
## * We use applicable values from imake in case its CC is ours.
## * Irrespective of that, we think we know what to do with GNU tools
##   (GNU C, Fortran, and C++ compilers).
## * Then, use platform specific overrides.
## * As a final safeguard, values from the environment (as specified in
##   one of the configuration files or at the configure command line)
##   override anything we figure out in the case of compiler flags; for
##   linker flags (*LDFLAGS), environment settings override our results
##   if the corresponding *LD variable was set, and add otherwise.
##
## NOTE: We do not provide defaults for the *LDFLAGS, taking a defensive
## approach.  In case we cannot figure out {MAIN,SHLIB}_LDFLAGS and the
## user did not provide defaults, an error results.  A warning is given
## if nothing was obtained for SHLIB_CXXLDFLAGS.

main_ld=${CC}
shlib_ld=${CC}
shlib_cxxld=${CXX}
SHLIB_EXT="so"

## Step 1.  Ask imake.
AC_PATH_PROG(XMKMF, xmkmf, [],
  ${PATH}:/usr/bin/X11:/usr/X11R6/bin:/usr/openwin/bin)
if test -n "${XMKMF}"; then
  echo > Imakefile
  ${XMKMF} > /dev/null
  cc=`${srcdir}/tools/GETMAKEVAL CC`
  cc=`echo ${cc} | sed "s/ .*//"`
  if test "`which ${cc}`" = "`which ${CC}`"; then
    shlib_ldflags=`${srcdir}/tools/GETMAKEVAL SHLIBLDFLAGS`
    cpicflags=`${srcdir}/tools/GETMAKEVAL PICFLAGS`
    fpicflags=${cpicflags}
  fi
  cxx=`${srcdir}/tools/GETMAKEVAL CXX`
  cxx=`echo ${cxx} | sed "s/ .*//"`
  if test "`which ${cxx}`" = "`which ${CXX}`"; then
    cxxpicflags=`${srcdir}/tools/GETMAKEVAL CXXPICFLAGS`
  fi
  rm -f Imakefile Makefile
fi

## Step 2.  GNU compilers.
if test "${GCC}" = yes; then
  cpicflags="-fPIC"
  shlib_ldflags="-shared"
fi
if test "${GXX}" = yes; then
  cxxpicflags="-fPIC"
  shlib_cxxldflags="-shared"
fi
if test "${G77}" = yes; then
  fpicflags="-fPIC"
fi

## Step 3.  Individual platform overrides.
case "${host}" in
  *aix4.[[2-9]]*)
    EXPORTFILE="\$(top_builddir)/etc/R.exp"
    cpicflags=
    cxxpicflags=
    fpicflags=
    if test "${GCC}" = yes; then
      wl="-Xlinker "
    else
      wl=
    fi
    main_ldflags="${wl}-bdynamic ${wl}-bE:${EXPORTFILE} ${wl}-bM:SRE"
    # FIXME: is this really necessary?
    #     if test "${GCC}" = yes; then
    #       main_ldflags="${main_ldflags} `${CC} -print-libgcc-file-name`"
    #     fi
    shlib_ldflags="${wl}-bM:SRE ${wl}-H512 ${wl}-T512 ${wl}-bnoentry \
      ${wl}-bexpall ${wl}-bI:\$(R_HOME)/etc/R.exp"
    ;;
  alpha*osf*)
    cpicflags=
    cxxpicflags=
    fpicflags=
    shlib_ldflags="-shared"
    ;;
  *freebsd[[3-4]].*)
    main_ldflags="-export-dynamic"
    shlib_ldflags="-shared"
    ;;
  *-*-gnu*)         # GNU Hurd
    main_ldflags="-export-dynamic"
    ;;
  *hpux*)
    SHLIB_EXT=sl
    case "${CC}" in
      cc|c89)
        cpicflags="+Z" ;;
    esac
    case "${FC}" in
      f77|fort77|f90)
        fpicflags="+Z" ;;
    esac
    main_ldflags="-Wl,-E"
    if test "${GCC}" = yes; then
      shlib_ldflags="-shared -fPIC"
    else
      shlib_ldflags="-b"
    fi
    if test "${GXX}" = yes; then
      shlib_cxxldflags="-shared -fPIC"
    fi
    ;;
  *linux*aout)          # GNU Linux/aout
    sed '/HAVE_ELF_H/d' confdefs.h > tmp.h ; mv tmp.h confdefs.h
    ;;
  *linux*)          # GNU Linux/ELF
    main_ldflags="-export-dynamic"
    ;;
  *netbsd*)
    if ${CPP} - -dM < /dev/null | grep -q __ELF__; then
      main_ldflags="-export-dynamic"
      shlib_ldflags="-shared"
    else
      shlib_ldflags="-Bshareable"
    fi
    ;;
  *sgi*)
    if test "${GCC}" != yes; then
      cpicflags="-KPIC"
    fi
    if test "${G77}" != yes; then
      fpicflags="-KPIC"
    fi
    shlib_ldflags="-shared"
    ;;
  *solaris*)
    shlib_ldflags="-G"
    shlib_cxxldflags="-G"
    if test "${GCC}" = yes; then
      ld=`${CC} -print-prog-name=ld`
      ldoutput=`${ld} -v 2>&1 | grep GNU`
      if test -n "${ldoutput}"; then
    main_ldflags="-Wl,-export-dynamic"
    shlib_ldflags="-shared"
      fi
    else
      cpicflags="-KPIC"
    fi
    if test "${GXX}" = yes; then
      ld=`${CXX} -print-prog-name=ld`
      ldoutput=`${ld} -v 2>&1 | grep GNU`
      if test -n "${ldoutput}"; then
        shlib_cxxldflags="-shared"
      fi
    fi
    if test "${G77}" != yes; then
      fpicflags="-PIC"
    fi
    ;;
esac

## FIXME:
## Completely disable using libtool for building shlibs until libtool
## fully supports at least Fortran and C++.
## ## Step 4.  In case we use libtool ...
## if test "${use_libtool}" = yes; then
##   case "${host}" in
##     *aix4.[[2-9]]*)
##       ## FIXME: AIX needs special care.
##       ;;
##     *)
##       ## FIXME: Maybe we should set this here and not in R_bin_LDFLAGS?
##       main_ldflags=
##       ;;
##   esac
## fi
## </FIXME>

## Step 5.  Overrides from the environment and error checking.
if test -z "${MAIN_LD-${MAINLD}}"; then
  ## FIXME: get rid of MAINLD/MAINLDFLAGS eventually.
  MAIN_LD=${main_ld}
  if test -z "${MAIN_LDFLAGS-${MAINLDFLAGS}}"; then
    MAIN_LDFLAGS=${main_ldflags}
  else
    MAIN_LDFLAGS="${MAIN_LDFLAGS-${MAINLDFLAGS}} ${main_ldflags}"
  fi
fi

: ${CPICFLAGS=${cpicflags}}
if test -z "${CPICFLAGS}"; then
  case "${host}" in
    *aix4.[[2-9]]*)
      ;;
    alpha*osf*)
      ;;
    *)
      AC_MSG_WARN([Could not determine CPICFLAGS.])
      AC_MSG_ERROR([See the file INSTALL for more information.])
      ;;
  esac
fi
: ${FPICFLAGS=${fpicflags}}
: ${CXXPICFLAGS=${cxxpicflags}}
if test -z "${CXXPICFLAGS}"; then
  case "${host}" in
    *aix4.[[2-9]]*)
      ;;
    alpha*osf*)
      ;;
    *)
      warn_cxxpicflags="I could not determine CXXPICFLAGS"
      AC_MSG_WARN(${cxxpicflags})
      ;;
  esac
fi

if test -z "${SHLIB_LD-${SHLIBLD}}"; then
  ## FIXME: get rid of SHLIBLD/SHLIBLDFLAGS eventually.
  SHLIB_LD=${shlib_ld}
  if test -z "${SHLIB_LDFLAGS-${SHLIBLDFLAGS}}"; then
    SHLIB_LDFLAGS=${shlib_ldflags}
  else
    SHLIB_LDFLAGS="${SHLIB_LDFLAGS-${SHLIBLDFLAGS}} ${shlib_ldflags}"
  fi
fi
if test -z "${SHLIB_LDFLAGS}"; then
  AC_MSG_WARN([Could not determine SHLIB_LDFLAGS.])
  AC_MSG_ERROR([See the file INSTALL for more information.])
fi

if test -z "${SHLIB_CXXLD}"; then
  SHLIB_CXXLD=${shlib_cxxld}
  if test -z "${SHLIB_CXXLDFLAGS}"; then
    SHLIB_CXXLDFLAGS=${shlib_cxxldflags}
  else
    SHLIB_CXXLDFLAGS="${SHLIB_CXXLDFLAGS} ${shlib_cxxldflags}"
  fi
fi
if test -z "${SHLIB_CXXLDFLAGS}"; then
  warn_shlib_cxxldflags="I could not determine SHLIB_CXXLDFLAGS"
  AC_MSG_WARN(${warn_shlib_cxxldflags})
fi

AC_SUBST(MAIN_LD)
AC_SUBST(MAIN_LDFLAGS)
AC_SUBST(CPICFLAGS)
AC_SUBST(FPICFLAGS)
AC_SUBST(CXXPICFLAGS)
AC_SUBST(SHLIB_LD)
AC_SUBST(SHLIB_LDFLAGS)
AC_SUBST(SHLIB_CXXLD)
AC_SUBST(SHLIB_CXXLDFLAGS)
AC_SUBST(SHLIB_EXT)
AC_DEFINE_UNQUOTED(SHLIB_EXT, "${SHLIB_EXT}")
AC_SUBST(EXPORTFILE)

### System services.

## X11 locations
##
## Here we use the standard X11 search macro.
## We force the use of -lX11 (perhaps this is not necessary).

AC_PATH_XTRA
if test -z "${no_x}"; then
  X_LIBS="${X_LIBS} -lX11"
  use_X11="yes"
  R_GUIS=X11
  AC_DEFINE(HAVE_X11, 1)
else
  use_X11="no"
  R_GUIS=
fi

## GNOME
R_GNOME
if test "${use_gnome}" = yes; then
  R_GUIS="${R_GUIS} gnome";
fi

AC_SUBST(R_GUIS)

## Tcl/Tk
R_TCLTK

AC_MSG_CHECKING([for BSD networking])
if test "${ac_cv_header_netdb_h}" = yes \
  && test "${ac_cv_header_netinet_in_h}" = yes \
  && test "${ac_cv_header_netinet_tcp_h}" = yes \
  && test "${ac_cv_header_sys_socket_h}" = yes \
  && (test "${ac_cv_func_connect}" = yes \
      || test "${ac_cv_lib_socket_connect}" = yes) \
  && (test "${ac_cv_func_gethostbyname}" = yes \
      || test "${ac_cv_lib_nsl_gethostbyname}" = yes); then
  AC_DEFINE(HAVE_BSD_NETWORKING)
  AC_MSG_RESULT([yes])
else
  AC_MSG_RESULT([no])
fi

R_BITMAPS

## POSIX times
R_USES_LEAPSECONDS

## R-profiling
if test "${want_R_profiling}" = yes; then
  AC_CHECK_FUNCS(setitimer,
    [AC_DEFINE(R_PROFILING)],
    [want_R_profiling="no"])
fi
AC_SUBST(R_PROFILING)

### Miscellaneous.

## Printing
##
## We look to see whether we have "lpr" or "lp".  Some platforms
## provide both (SunOS and HPUX), and in those cases we choose lpr.

if test -z "${R_PRINTCMD}"; then
  AC_CHECK_PROGS(R_PRINTCMD, lpr lp)
fi
AC_DEFINE_UNQUOTED(R_PRINTCMD, "${R_PRINTCMD}")

AC_PATH_PROG(PAPERCONF, paperconf, false)
papersize=`${PAPERCONF}`
: ${R_PAPERSIZE=${papersize:-a4}}
AC_SUBST(R_PAPERSIZE)

## Saving.

AC_SUBST(R_BATCHSAVE)

## Make sure -L terms come first in LIBS, separate out as LIBPATHS.
LIBS1=""
LIBS2=""
for arg in ${LIBS}; do
  case ${arg} in
    -L*)
    LIBS1="${LIBS1} ${arg}"
      ;;
    *)
    LIBS2="${LIBS2} ${arg}"
      ;;
  esac
done
LIBS="${LIBS1} ${LIBS2}"
if test -n "${LIBS1}"; then
  LIBPATHS="${LIBS1}"
fi
AC_SUBST(LIBPATHS)

## FIXME:
## This should not be necessary when using libtool for linking.
## In any case, is this really good enough?

for arg in ${X_LIBS} ${TCLTK_LIBS} ${GNOME_LIBS} ${BLAS_LIBS}; do
  case ${arg} in
    -L*)
      lib=`echo ${arg} | sed "s/^-L//"`
      if test -z "${R_LD_LIBRARY_PATH}"; then
        R_LD_LIBRARY_PATH="${lib}"
      else
        R_LD_LIBRARY_PATH="${R_LD_LIBRARY_PATH}:${lib}"
      fi
      ;;
  esac
done
AC_SUBST(R_LD_LIBRARY_PATH)

## Record name of environment variable which tells the dynamic linker
## where to find shlibs (typically, `LD_LIBRARY_PATH').
ltout=`./libtool --config | grep '^shlibpath_var='`
eval "${ltout}"
AC_SUBST(shlibpath_var)

## Final cleanups/rewrites.

AM_CONDITIONAL(WANT_R_SHLIB, test "${want_R_shlib}" = yes)

## FIXME:
## This will no longer be necessary in Autoconf 2.49b or better.
LTLIBOBJS=`echo $LIBOBJS | sed 's/\.o/\.lo/g'`
AC_SUBST(LTLIBOBJS)
LTALLOCA=`echo "$ALLOCA" | sed 's/\.o/.lo/g'`
AC_SUBST(LTALLOCA)

if test "${PERL}" = false; then
  PERL="/bin/sh false"
fi

### Output.

AC_OUTPUT(Makeconf
  Makefile
  afm/Makefile
  demos/Makefile
  demos/dynload/Makefile
  doc/Makefile
  doc/html/Makefile
  doc/html/search/Makefile
  doc/manual/Makefile
  etc/Makefile
  etc/Makeconf
  etc/Makeconf-tests
  etc/Renviron
  share/Makefile
  src/Makefile
  src/appl/Makefile
  src/include/Makefile
  src/library/Makefile
  src/library/base/DESCRIPTION
  src/library/base/Makefile
  src/library/profile/Makefile
  src/library/ctest/DESCRIPTION
  src/library/ctest/Makefile
  src/library/ctest/src/Makefile
  src/library/eda/DESCRIPTION
  src/library/eda/Makefile
  src/library/eda/src/Makefile
  src/library/lqs/DESCRIPTION
  src/library/lqs/Makefile
  src/library/lqs/src/Makefile
  src/library/modreg/DESCRIPTION
  src/library/modreg/Makefile
  src/library/modreg/src/Makefile
  src/library/mva/DESCRIPTION
  src/library/mva/Makefile
  src/library/mva/src/Makefile
  src/library/nls/DESCRIPTION
  src/library/nls/Makefile
  src/library/nls/src/Makefile
  src/library/stepfun/DESCRIPTION
  src/library/stepfun/Makefile
  src/library/splines/DESCRIPTION
  src/library/splines/Makefile
  src/library/splines/src/Makefile
  src/library/tcltk/DESCRIPTION
  src/library/tcltk/Makefile
  src/library/tcltk/src/Makefile
  src/library/ts/DESCRIPTION
  src/library/ts/Makefile
  src/library/ts/src/Makefile
  src/main/Makefile
  src/nmath/Makefile
  src/nmath/standalone/Makefile
  src/scripts/Makefile
  src/scripts/COMPILE
  src/scripts/INSTALL
  src/scripts/REMOVE
  src/scripts/R.sh
  src/scripts/Rd2contents
  src/scripts/Rdconv
  src/scripts/Rdindex
  src/scripts/Rprof
  src/scripts/SHLIB
  src/scripts/Sd2Rd
  src/scripts/build
  src/scripts/build-help
  src/scripts/check
  src/scripts/extract-usage
  src/unix/Makefile
  src/unix/X11/Makefile
  src/unix/gnome/Makefile
  tests/Makefile
  tests/Examples/Makefile
  tools/Makefile
  tools/Rdnewer
  tools/help2man
  tools/keyword-test
  tools/install-info
  tools/pkg2tex
)

AC_OUTPUT_COMMANDS(
  chmod +x \
  tools/Rdnewer \
  tools/help2man \
  tools/install-info \
  tools/keyword-test \
  tools/pkg2tex
  test -f src/include/stamp-h || echo timestamp > src/include/stamp-h
)

if test -z "${F77}"; then
  FORT="${F2C} ${F2CFLAGS}"
else
  FORT="${F77} ${R_XTRA_FFLAGS} ${FFLAGS}"
fi

AC_MSG_RESULT([

R is now configured for ${host}

  Source directory:          ${srcdir}
  Installation directory:    ${prefix}
  C compiler:                ${CC} ${R_XTRA_CFLAGS} ${CFLAGS}
  C++ compiler:              ${CXX} ${R_XTRA_CXXFLAGS} ${CXXFLAGS}
  FORTRAN compiler:          ${FORT}

  X11 support:               ${use_X11}
  Gnome support:             ${use_gnome}
  Tcl/Tk support:            ${use_tcltk}

  R profiling support:       ${want_R_profiling}
  R as a shared library:     ${want_R_shlib}
])

if test -n "${warn_f77_and_g77}"; then
  AC_MSG_WARN(${warn_f77_and_g77})
fi
if test -n "${warn_f77_and_f2c}"; then
  AC_MSG_WARN(${warn_f77_and_f2c})
fi
if test -n "${warn_g77_and_f2c}"; then
  AC_MSG_WARN(${warn_g77_and_f2c})
fi
if test -n "${warn_f2c_flibs}"; then
  AC_MSG_WARN(${warn_f2c_flibs})
fi
if test -n "${warn_cxxpicflags}"; then
  AC_MSG_WARN(${warn_cxxpicflags})
fi
if test -n "${warn_shlib_cxxldflags}"; then
  AC_MSG_WARN(${warn_shlib_cxxldflags})
fi
if test -n "${warn_libglade}"; then
  AC_MSG_WARN(${warn_libglade})
fi
if test -n "${warn_tcltk_version}"; then
  AC_MSG_WARN(${warn_tcltk_version})
fi
if test -n "${warn_perl5}"; then
  AC_MSG_WARN(${warn_perl5})
fi
if test -n "${warn_dvi}"; then
  AC_MSG_WARN(${warn_dvi})
fi
if test -n "${warn_info}"; then
  AC_MSG_WARN(${warn_info})
fi
if test -n "${warn_pdf}"; then
  AC_MSG_WARN(${warn_pdf})
fi

dnl Local Variables: ***
dnl mode: sh ***
dnl sh-indentation: 2 ***
dnl End: ***