The R Project SVN – R – /branches/R-Tk/configure.in

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_HEADER(src/include/config.h)
AC_CONFIG_AUX_DIR(tools)

### Platform & Version

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}")

PACKAGE="R"
VERSION=`cat ${srcdir}/VERSION | cut -d' ' -f1`
AC_SUBST(PACKAGE)
AC_SUBST(VERSION)

### 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 force us to use f2c.
AC_ARG_WITH(f2c,
  [  --with-f2c              use f2c even if FORTRAN compiler is available],
  [ if test "${withval}" = no; then
      use_f2c=false;
    else
      use_f2c=true;
    fi],
  use_f2c=false)

## Allow the user to force us to use g77.
AC_ARG_WITH(g77,
  [  --with-g77              use g77 to compile FORTRAN subroutines],
  [ if test "${withval}" = no; then
      use_g77=false;
    else
      use_g77=true;
    fi],
  use_g77=false)

## Allow the user to force us to use f77.
AC_ARG_WITH(f77,
  [  --with-f77              use f77 to compile FORTRAN subroutines],
  [ if test "${withval}" = no; then
      use_f77=false;
    else
      use_f77=true;
    fi],
  use_f77=false)

## Here we should maybe check that only one of the above options for
## dealing with FORTRAN were specified.

AC_ARG_WITH(libmoto,
  [  --with-libmoto          use libmoto math library (if available)],
  [ if test "${withval}"=no; then
      use_libmoto=false;
    else
      use_libmoto=true;
    fi],
  use_libmoto=true)

AC_ARG_WITH(blas,
  [  --with-blas             use BLAS library (if available)],
  [ if test "${withval}" = no; then
      use_blas=false;
    else
      use_blas=true;
    fi],
  use_blas=true)

AC_ARG_WITH(blas_risc,
  [  --with-blas_risc        use RISC Optimized BLAS library (if available)],
  [ if test "${withval}" = no; then
      use_blas_risc=false;
    else
      use_blas_risc=true;
    fi],
  use_blas_risc=true)

AC_ARG_WITH(dxml,
  [  --with-dxml             use DXML library (if available)],
  [ if test "${withval}" = no; then
      use_dxml=false;
    else
      use_dxml=true;
    fi],
  use_dxml=true)

AC_ARG_WITH(atlas,
  [  --with-atlas            use ATLAS library (if available)],
  [ if test "${withval}" = no; then
      use_atlas=false;
    else
      use_atlas=true;
    fi],
  use_atlas=true)

AC_ARG_WITH(readline,
  [  --with-readline         use readline library (if available)],
  [ if test "${withval}" = no; then
      use_readline=false;
    else
      use_readline=true;
    fi],
  use_readline=true)

AC_ARG_WITH(gnome,
  [  --with-gnome            use GNOME, or specify its prefix],
  [ 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],
  [ 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)

### Programs.

AC_PROG_AWK
AC_PROG_INSTALL
warn_install="redefining INSTALL to be `pwd`/tools/install-sh -c"
case "${INSTALL}" in
  [[!/]]*install-sh*)
    ## Fix a bug in older versions of autoconf---the path of the install
    ## shell script is not cached.  Could also use an absolute path in
    ## AC_CONFIG_AUX_DIR().
    INSTALL="\$\(top_srcdir\)/tools/install-sh -c"
    AC_MSG_WARN([${warn_install}])
    ;;
esac
case "${host}" in
  *aix*|*hpux*)
    ## installbsd on AIX does not seem to work?
    INSTALL="\$\(top_srcdir\)/tools/install-sh -c"
    AC_MSG_WARN([${warn_install}])
    ;;
esac
AC_PROG_LN_S
AC_PROG_RANLIB
AC_PROG_YACC
## Ar.
AC_CHECK_PROGS(AR, [${AR} ar], ar)
: ${ARFLAGS="rc"}
AC_SUBST(ARFLAGS)
## Echo.
R_PROG_ECHO_N
## 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], "")

## C compiler.

AC_PROG_CC
AC_PROG_CPP
AC_PROG_GCC_TRADITIONAL

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

## FORTRAN compiler

## If we haven't 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)
  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
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
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)

## C++ compiler.

AC_PROG_CXX
AC_PROG_CXXCPP

### Libraries.

## 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 "${LD_LIBRARY_PATH}"; then
        LD_LIBRARY_PATH="${lib}"
      else
        LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${lib}"
      fi
      ;;
  esac
done
export LD_LIBRARY_PATH

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
BLAS="blas.o"
if test "${r_cv_prog_f77_append_underscore}" = yes; then
  fun=dgemm_
else
  fun=dgemm
fi
if ${use_dxml}; then
  AC_CHECK_LIB(dxml, ${fun}, FLIBS="-ldxml ${FLIBS}" BLAS="")
fi
if test -n "${BLAS}" && ${use_atlas}; then
  AC_CHECK_LIB(atlas, ATL_xerbla,
    [ FLIBS="-latlas ${FLIBS}" BLAS=""
      AC_CHECK_LIB(cblas, cblas_dgemm,
        [ FLIBS="-lcblas ${FLIBS}"
      AC_CHECK_LIB(f77blas, ${fun},
            FLIBS="-lf77blas ${FLIBS}", , ${FLIBS}),
    ], ,${FLIBS})
    ], ,
    ${FLIBS})
fi
if test -n "${BLAS}" && ${use_blas}; then
  AC_CHECK_LIB(blas, ${fun},
    [ FLIBS="-lblas ${FLIBS}" BLAS=""
      if ${use_blas_risc}; then
        AC_CHECK_LIB(blas_risc, main,
      FLIBS="-lblas_risc ${FLIBS}", , ${FLIBS})
      fi
    ], ,
    ${FLIBS})
fi
AC_SUBST(BLAS)

for arg in ${LIBS}; do
  case ${arg} in
    -L*)
      FLIBS="${arg} ${FLIBS}"
      ;;
  esac
done
AC_SUBST(FLIBS)

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(acosh asinh atanh bcopy finite getcwd isnan matherr \
  memcpy memmove popen rint strcoll system times 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 \
  ieee754.h ieeefp.h locale.h readline/history.h readline/readline.h \
  rpc/rpc.h rpc/xdr.h string.h sys/param.h sys/stat.h sys/time.h \
  sys/times.h unistd.h)
AC_CHECK_HEADERS(netdb.h netinet/in.h netinet/tcp.h sys/socket.h)
case "${host}" in
  *sunos4*)
    AC_DEFINE(SunOS4) ;;
esac
R_HEADER_SETJMP
AC_MSG_CHECKING([for BSD networking])
if test "${ac_cv_header_netdb_h}" = yes \
  -a "${ac_cv_header_netinet_in_h}" = yes \
  -a "${ac_cv_header_netinet_tcp_h}" = yes \
  -a "${ac_cv_header_sys_socket_h}" = yes \
  -a \( "${ac_cv_func_connect}" = yes \
        -o "${ac_cv_lib_socket_connect}" = yes \) \
  -a \( "${ac_cv_func_gethostbyname}" = yes \
        -o "${ac_cv_lib_nsl_gethostbyname}" = yes \) ; then
  AC_DEFINE(HAVE_BSD_NETWORKING)
  AC_MSG_RESULT([yes])
else
  AC_MSG_RESULT([no])
fi

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

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(CXXFLAGS)
AC_SUBST(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:
##
## MAINLD, MAINLDFLAGS
##   command and flags for loading the main binary so that it will load
##   shared libraries (DLLs) at runtime
## CPICFLAGS, CXXPICFLAGS, FPICFLAGS
##   flags for compiling C, C++, and Fortran library code
## SHLIBLD, SHLIBLDFLAGS
##   command and flags for creating DLLs
##
## The following procedure is as follows.
## *) We think we know what to do if CC is gcc.  Otherwise, try using
##    imake values in case its CC is ours.
## *) Then, use platform specific overrides.
## *) As a final safeguard, values from the environment (as specified in
##    one of the configuration files) override anything we figure out.

mainld=${CC}
shlibld=${CC}
SHLIBEXT=so

AC_PATH_PROG(XMKMF, xmkmf, ,
  ${PATH}:/usr/bin/X11:/usr/X11R6/bin:/usr/openwin/bin)
AC_MSG_CHECKING([how to deal with shared libraries])
if test -n "${XMKMF}"; then
  echo > Imakefile
  ${XMKMF} > /dev/null
  cc=`${srcdir}/tools/GETMAKEVAL CC`
  if test "`which ${cc}`" = "`which ${CC}`"; then
    shlibldflags=`${srcdir}/tools/GETMAKEVAL SHLIBLDFLAGS`
    cpicflags=`${srcdir}/tools/GETMAKEVAL PICFLAGS`
    fpicflags=${cpicflags}
  fi
  cxx=`${srcdir}/tools/GETMAKEVAL CXX`
  if test "`which ${cxx}`" = "`which ${CXX}`"; then
    cxxpicflags=`${srcdir}/tools/GETMAKEVAL CXXPICFLAGS`
  fi
  rm -f Imakefile Makefile
fi
if test "${GCC}" = yes; then
  cpicflags=-fPIC
  shlibldflags=-shared
fi
if test "${GXX}" = yes; then
  cxxpicflags=-fPIC
fi
if test "${G77}" = yes; then
  fpicflags=-fPIC
fi
AC_MSG_RESULT(done)

## Individual platform overrides.

case "${host}" in
  *aix4.[[2-9]]*)
    EXPORTFILE="\$(top_builddir)/etc/R.exp"
    mainld=ld
    mainldflags="-bdynamic -bE:${EXPORTFILE} -bM:SRE"
    if test "${GCC}" = yes; then
      mainldflags="${mainldflags} `${CC} -print-libgcc-file-name`"
    fi
    shlibld=ld
    shlibldflags="-bM:SRE -H512 -T512 -bnoentry -bexpall \
      -bI:\$(R_HOME)/etc/R.exp"
    ;;
  alpha*osf*)
    mainld="${FC} -g -nofor_main -fpe3 "
    cpicflags=
    cxxpicflags=
    shlibld=${FC}
    shlibldflags=-shared
    ;;
  alpha*linux*)
    mainldflags=-export-dynamic
    ;;
  *freebsd[[3-4]].*)
    mainldflags=-export-dynamic
    shlibldflags="-shared"
    ;;
  *hpux*)
    case "${CC}" in
      cc|c89)
        cpicflags="+z" ;;
    esac
    case "${FC}" in
      f77|fort77|f90)
        fpicflags="+z" ;;
    esac
    mainldflags="-Wl,-E"
    shlibld=ld
    shlibldflags="-b"
    SHLIBEXT=sl
    ;;
  *linux*aout)
    sed '/HAVE_ELF_H/d' confdefs.h > tmp.h ; mv tmp.h confdefs.h
    ;;
  *linux*)
    mainldflags=-export-dynamic
    ;;
  *netbsd*)
    if ${CPP} - -dM < /dev/null | grep -q __ELF__; then
      mainldflags="-export-dynamic"
      shlibldflags="-shared"
    else
      shlibldflags="-Bshareable"
    fi
    ;;
  *sgi*)
    if test "${GCC}" = yes; then
      cpicflags=-fPIC
    else
      cpicflags=-KPIC
    fi
    if test "${G77}" = yes; then
      fpicflags=-fPIC
    else
      fpicflags=-KPIC
    fi
    shlibldflags="-shared"
    ;;
  *solaris*)
    shlibldflags="-G"
    if test "${GCC}" = yes; then
      cpicflags=-fPIC
      ld=`${CC} -print-prog-name=ld`
      ldoutput=`${ld} -v 2>&1 | grep GNU`
      if test -n "${ldoutput}"; then
    mainldflags="-Wl,-export-dynamic"
    shlibldflags="-shared"
      fi
    else
      cpicflags=-KPIC
    fi
    if test "${G77}" = yes; then
      fpicflags=-fPIC
    else
      fpicflags=-PIC
    fi
    ;;
esac

: ${MAINLD=${mainld}}
: ${MAINLDFLAGS=${mainldflags}}
: ${CPICFLAGS=${cpicflags}}
if test -z "${CPICFLAGS}"; then
  case "${host}" in
    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
    alpha*osf*)
      ;;
    *)
      AC_MSG_WARN([Could not determine CXXPICFLAGS.])
      ;;
  esac
fi
: ${SHLIBLD=${shlibld}}
: ${SHLIBLDFLAGS=${shlibldflags}}
if test -z "${SHLIBLDFLAGS}"; then
  AC_MSG_WARN([Could not determine SHLIBLDFLAGS.])
  AC_MSG_ERROR([See the file INSTALL for more information.])
fi

AC_SUBST(MAINLD)
AC_SUBST(MAINLDFLAGS)
AC_SUBST(CPICFLAGS)
AC_SUBST(FPICFLAGS)
AC_SUBST(CXXPICFLAGS)
AC_SUBST(SHLIBLDFLAGS)
AC_SUBST(SHLIBEXT)
AC_SUBST(SHLIBLD)
AC_DEFINE_UNQUOTED(SHLIBEXT, "${SHLIBEXT}")
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

R_TCLTK
if test "${use_tcltk}" = yes; then
  R_GUIS="${R_GUIS} tcltk";
fi


AC_SUBST(R_GUIS)

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

AC_CHECK_HEADERS(png.h)
AC_CHECK_HEADERS(jpeglib.h)
if test -n "${ac_cv_header_jpeglib_h}"; then
  BITMAP_LIBS=-ljpeg
else
  BITMAP_LIBS=
fi
if test -n "${ac_cv_header_png_h}"; then
  BITMAP_LIBS="${BITMAP_LIBS} -lpng -lz"
fi
echo "using libraries \`${BITMAP_LIBS}' for bitmap functions"
AC_SUBST(BITMAP_LIBS)

R_BITMAPS

## Saving.

AC_SUBST(R_BATCHSAVE)

### Output.

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

AC_OUTPUT(Makeconf
  Makefile
  afm/Makefile
  demos/Makefile
  demos/dynload/Makefile
  doc/Makefile
  doc/manual/Makefile
  etc/Makefile
  etc/Makeconf
  etc/Makeconf-tests  
  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/ts/DESCRIPTION
  src/library/ts/Makefile
  src/library/ts/src/Makefile
  src/main/Makefile
  src/nmath/Makefile
  src/scripts/Makefile
  src/scripts/COMPILE
  src/scripts/INSTALL
  src/scripts/REMOVE
  src/scripts/R.sh
  src/scripts/Rd2contents
  src/scripts/Rd2txt
  src/scripts/Rdconv
  src/scripts/Rdindex
  src/scripts/SHLIB
  src/scripts/Sd2Rd
  src/scripts/build-help
  src/scripts/check
  src/unix/Makefile
  src/unix/X11/Makefile
  src/unix/gnome/Makefile
  src/unix/tcltk/Makefile
  tests/Makefile
  tests/Examples/Makefile
  tools/Makefile
  tools/Rdnewer
  tools/help2man
  tools/keyword-test
  tools/keywords2html
  tools/install-info
  tools/pkg2tex
)

AC_OUTPUT_COMMANDS(
  chmod +x \
  tools/Rdnewer \
  tools/help2man \
  tools/install-info \
  tools/keyword-test \
  tools/keywords2html \
  tools/pkg2tex
  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}
  FORTRAN compiler:         ${FORT}
  X11 support:              ${use_X11}
  Gnome support:            ${use_gnome}
  Tcl/Tk support:           ${use_tcltk}
])

dnl Local Variables: ***
dnl mode: sh ***
dnl sh-indentation: 2 ***
dnl End: ***
The R Project SVN R

(root)/branches/R-Tk/configure.in @ 28362 – Rev 9164
