dnl Process this file with autoconf to produce a configure script.
dnl The macros which aren't shipped with the autotools are stored in the 
dnl Tools/config directory in .m4 files.

AC_INIT([swig],[1.3.26],[http://www.swig.org])
AC_PREREQ(2.58)
AC_CONFIG_SRCDIR([Source/Swig/swig.h])
AC_CONFIG_AUX_DIR([Tools/config])
AC_CONFIG_HEADERS([Source/Include/swigconfig.h])
AC_CANONICAL_HOST
AM_INIT_AUTOMAKE

dnl Some extra defines for the config file
AH_BOTTOM([
/* Default language */
#define SWIG_LANG               "-tcl"
])

dnl Checks for programs.
AC_PROG_CC
AC_PROG_CXX
AC_PROG_YACC
AC_EXEEXT
AC_OBJEXT
AC_PROG_RANLIB
AM_PROG_CC_C_O  # Needed for subdir-objects in AUTOMAKE_OPTIONS
AC_CHECK_PROGS(AR, ar aal, ar)
AC_SUBST(AR)

AC_COMPILE_WARNINGS # Increase warning levels

AC_DEFINE_UNQUOTED(SWIG_CXX, ["$CXX"], [Compiler that built SWIG])
AC_DEFINE_UNQUOTED(SWIG_PLATFORM, ["$build"], [Platform that SWIG is built for])


dnl Checks for header files.
AC_HEADER_STDC

dnl How to specify include directories that may be system directories.
# -I should not be used on system directories (GCC)
if test "$GCC" = yes; then
    ISYSTEM="-isystem "
else
    ISYSTEM="-I"
fi


dnl Checks for types.
AC_LANG_PUSH([C++])
AC_CHECK_TYPES([bool])
AC_LANG_POP([C++])


# Set info about shared libraries.
AC_SUBST(SO)
AC_SUBST(LDSHARED)
AC_SUBST(CCSHARED)
AC_SUBST(CXXSHARED)
AC_SUBST(TRYLINKINGWITHCXX)
AC_SUBST(LINKFORSHARED)

# SO is the extension of shared libraries `(including the dot!)
AC_MSG_CHECKING(SO)
if test -z "$SO"
then
	case $host in
	*-*-hp*) SO=.sl;;
	*-*-darwin*) SO=.bundle;;
	*-*-cygwin* | *-*-mingw*) SO=.dll;;
	*) SO=.so;;
	esac
fi
AC_MSG_RESULT($SO)

# LDSHARED is the ld *command* used to create shared library
# -- "ld" on SunOS 4.x.x, "ld -G" on SunOS 5.x, "ld -shared" on IRIX 5
# (Shared libraries in this instance are shared modules to be loaded into
# Python, as opposed to building Python itself as a shared library.)
AC_MSG_CHECKING(LDSHARED)
if test -z "$LDSHARED"
then
	case $host in
	*-*-aix*) LDSHARED="\$(srcdir)/ld_so_aix \$(CC)";;
	*-*-cygwin* | *-*-mingw*)
            if test "$GCC" = yes; then
                LDSHARED="$CC -shared"
            else
                if test "cl" = $CC ;  then
                    # Microsoft Visual C++ (MSVC)
                    LDSHARED="$CC -nologo -LD"
                else
                    # Unknown compiler try gcc approach
                    LDSHARED="$CC -shared"
                fi
            fi ;;
	*-*-irix5*) LDSHARED="ld -shared";;
	*-*-irix6*) LDSHARED="ld ${SGI_ABI} -shared -all";;
	*-*-sunos4*) LDSHARED="ld";;
	*-*-solaris*) LDSHARED="ld -G";;
	*-*-hp*) LDSHARED="ld -b";;
	*-*-osf*) LDSHARED="ld -shared -expect_unresolved \"*\"";;
	*-sequent-sysv4) LDSHARED="ld -G";;
	*-*-next*)
		if test "$ns_dyld"
		then LDSHARED='$(CC) $(LDFLAGS) -bundle -prebind'
		else LDSHARED='$(CC) $(CFLAGS) -nostdlib -r';
		fi
                if test "$with_next_framework" ; then
		    LDSHARED="$LDSHARED \$(LDLIBRARY)"
		fi ;;
	*-*-linux*) LDSHARED="gcc -shared";;
	*-*-dgux*) LDSHARED="ld -G";;
	*-*-freebsd3*) LDSHARED="gcc -shared";;
	*-*-freebsd* | *-*-openbsd*) LDSHARED="ld -Bshareable";;
	*-*-netbsd*)
		if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]]
		then
			LDSHARED="cc -shared"
		else
			LDSHARED="ld -Bshareable"
		fi;;
	*-sco-sysv*) LDSHARED="cc -G -KPIC -Ki486 -belf -Wl,-Bexport";;
	*-*-darwin*) LDSHARED="cc -bundle -undefined suppress -flat_namespace";;
	*)	LDSHARED="ld";;
	esac
fi
AC_MSG_RESULT($LDSHARED)
# CXXSHARED is the ld *command* used to create C++ shared library
# -- "ld" on SunOS 4.x.x, "ld -G" on SunOS 5.x, "ld -shared" on IRIX 5
# (Shared libraries in this instance are shared modules to be loaded into
# Python, as opposed to building Python itself as a shared library.)
AC_MSG_CHECKING(CXXSHARED)
if test -z "$CXXSHARED"
then
	CXXSHARED="$LDSHARED"
fi
AC_MSG_RESULT($CXXSHARED)

#
AC_MSG_CHECKING(TRYLINKINGWITHCXX)
if test -z "$TRYLINKINGWITHCXX"
then
	case $host in
	*-*-solaris*) if test "$GCC" = yes;
             then TRYLINKINGWITHCXX="CXXSHARED= $CXX -Wl,-G";
             else TRYLINKINGWITHCXX="CXXSHARED= $CXX -G -L/opt/SUNWspro/lib -lCrun -lCstd";
             fi;;
        *-*-hp*) TRYLINKINGWITHCXX="CXXSHARED= $CXX +z ";;
        *-*-darwin*) TRYLINKINGWITHCXX="CXXSHARED= $CXX -bundle -undefined suppress -flat_namespace";;
        *-*-cygwin* | *-*-mingw*)
            if test "$GCC" = yes; then
                TRYLINKINGWITHCXX="CXXSHARED= $CXX -shared "
            else
                if test "cl" = $CXX ;  then
                    # Microsoft Visual C++ (MSVC)
                    TRYLINKINGWITHCXX="CXXSHARED= $CXX -nologo -LD"
                else
                    TRYLINKINGWITHCXX="#unknown Windows compiler"
                fi
            fi ;;
        *)       TRYLINKINGWITHCXX="CXXSHARED= $CXX -shared ";;
        esac
fi
AC_MSG_RESULT($TRYLINKINGWITHCXX)
# CCSHARED are the C *flags* used to create objects to go into a shared
# library (module) -- this is only needed for a few systems
AC_MSG_CHECKING(CCSHARED)
if test -z "$CCSHARED"
then
	case $host in
	*-*-hp*) if test "$GCC" = yes;
		 then CCSHARED="-fpic";
		 else CCSHARED="+z";
		 fi;;
	*-*-linux*) CCSHARED="-fpic";;
	*-*-freebsd* | *-*-openbsd*) CCSHARED="-fpic";;
	*-*-netbsd*) CCSHARED="-fPIC";;
	*-sco-sysv*) CCSHARED="-KPIC -dy -Bdynamic";;
	*-*-irix6*)  case $CC in
		   *gcc*) CCSHARED="-shared";;
		   *) CCSHARED="";;
		   esac;;
	esac
fi
AC_MSG_RESULT($CCSHARED)

# RPATH is the path used to look for shared library files.
AC_MSG_CHECKING(RPATH)
if test -z "$RPATH"
then
	case $host in
	*-*-solaris*) RPATH='-R. -R$(exec_prefix)/lib';;
        *-*-irix*) RPATH='-rpath .:$(exec_prefix)/lib';;
	*-*-linux*) RPATH='-Xlinker -rpath $(exec_prefix)/lib -Xlinker -rpath .';;
	*)	RPATH='';;
	esac
fi
AC_MSG_RESULT($RPATH)
AC_SUBST(RPATH)

# LINKFORSHARED are the flags passed to the $(CC) command that links
# the a few executables -- this is only needed for a few systems

AC_MSG_CHECKING(LINKFORSHARED)
if test -z "$LINKFORSHARED"
then
	case $host in
	*-*-aix*)	LINKFORSHARED='-Wl,-bE:$(srcdir)/python.exp -lld';;
	*-*-hp*)
	    LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
	*-*-linux*) LINKFORSHARED="-Xlinker -export-dynamic";;
	*-*-next*) LINKFORSHARED="-u libsys_s";;
	*-sco-sysv*) LINKFORSHARED="-Bdynamic -dy -Wl,-Bexport";;
	*-*-irix6*) LINKFORSHARED="-all";;
	esac
fi
AC_MSG_RESULT($LINKFORSHARED)

# This variation is needed on OS-X because there is no (apparent) consistency in shared libary naming.
# Sometimes .bundle works, but sometimes .so is needed.  It depends on the target language

AC_SUBST(PYTHON_SO)
case $host in
   *-*-darwin*) PYTHON_SO=.so;;
   *) PYTHON_SO=$SO;;
esac

AC_SUBST(TCL_SO)
case $host in
   *-*-darwin*) TCL_SO=.dylib;;
   *) TCL_SO=$SO;;
esac

AC_SUBST(GUILE_SO)
case $host in
   *-*-darwin*) GUILE_SO=.so;;
   *) GUILE_SO=$SO;;
esac

AC_SUBST(PHP4_SO)
case $host in
   *-*-darwin*) PHP4_SO=.so;;
   *) PHP4_SO=$SO;;
esac

AC_SUBST(MZSCHEME_SO)
case $host in
   *) MZSCHEME_SO=.so;;
esac

AC_SUBST(TCL_LDSHARED)
case $host in
   *-*-darwin*) TCL_LDSHARED="gcc -dynamiclib -flat_namespace -undefined suppress";;
   *) TCL_LDSHARED=$LDSHARED;;
esac

AC_SUBST(TCL_CXXSHARED)
case $host in
   *-*-darwin*) TCL_CXXSHARED="g++ -dynamiclib -flat_namespace -undefined suppress";;
   *) TCL_CXXSHARED=$TRYLINKINGWITHCXX;;
esac

AC_SUBST(LUA_SO)
case $host in
   *-*-darwin*) LUA_SO=.so;;
   *) LUA_SO=$SO;;
esac

# Optional CFLAGS used to silence compiler warnings on some platforms.

AC_SUBST(PLATFLAGS)
case $host in
   *-*-darwin*) PLATFLAGS="-Wno-long-double";;
   *) PLATFLAGS="";;
esac


echo ""
echo "Checking for installed packages."
echo "Note : None of the following packages are required to compile SWIG"
echo ""

# Check for specific libraries.   Used for SWIG examples
AC_CHECK_LIB(dl, dlopen)	# Dynamic linking for SunOS/Solaris and SYSV
AC_CHECK_LIB(dld, shl_load)	# Dynamic linking for HP-UX

# The following three (nsl,inet,socket) are needed on Sequent;
# the order of checking must be this.  Most SVR4 platforms will
# need -lsocket and -lnsl.  However on SGI IRIX 5, these exist but
# broken.  I see no elegant solution (probably CHECK_LIB should be
# fixed to only add the library if the given entry point is not
# satisfied without it).
case $host in
*-*-irix*)
AC_CHECK_LIB(nsl, t_open, [LIBS="-lnsl $LIBS"]) # SVR4
AC_CHECK_LIB(inet, gethostbyname, [LIBS="-linet $LIBS"], [], -lnsl) # Sequent
AC_CHECK_LIB(socket, socket, [LIBS="-lsocket $LIBS"], [], $LIBS) # SVR4 sockets
;;
esac


AC_CHECK_LIB(swill, swill_init, [SWIGLIBS="-lswill $LIBS" SWILL="-DSWIG_SWILL"])
AC_SUBST(SWIGLIBS)
AC_SUBST(SWILL)

# check for --with-libm=...
AC_SUBST(LIBM)
LIBM=-lm
AC_ARG_WITH(libm, [  --with-libm=STRING      math library], [
if test "$withval" != yes
then LIBM=$withval
else AC_MSG_ERROR([proper usage is --with-libm=STRING])
fi])
AC_CHECK_LIB(ieee, main, [LIBM="-lieee $LIBM"])
AC_CHECK_LIB(crypt,crypt, [LIBCRYPT="-lcrypt"])
AC_SUBST(LIBCRYPT)

# check for --with-libc=...
AC_SUBST(LIBC)
AC_ARG_WITH(libc, [  --with-libc=STRING      C library], [
if test "$withval" != yes
then LIBC=$withval
else AC_MSG_ERROR([proper usage is --with-libc=STRING])
fi])

#--------------------------------------------------------------------
#	Locate the X11 header files and the X11 library archive.  Try
#	the ac_path_x macro first, but if it doesn't find the X stuff
#	(e.g. because there's no xmkmf program) then check through
#	a list of possible directories.  Under some conditions the
#	autoconf macro will return an include directory that contains
#	no include files, so double-check its result just to be safe.
#--------------------------------------------------------------------

AC_PATH_X
not_really_there=""
if test "$no_x" = ""; then
    if test "$x_includes" = ""; then
	AC_TRY_CPP([#include <X11/XIntrinsic.h>], , not_really_there="yes")
    else
	if test ! -r $x_includes/X11/Intrinsic.h; then
	    not_really_there="yes"
	fi
    fi
fi
if test "$no_x" = "yes" -o "$not_really_there" = "yes"; then
    AC_MSG_CHECKING(for X11 header files)
    XINCLUDES="# no special path needed"
    AC_TRY_CPP([#include <X11/Intrinsic.h>], , XINCLUDES="")
    if test -z "$XINCLUDES"; then
        dirs="/usr/unsupported/include /usr/local/include /usr/X386/include /usr/include/X11R4 /usr/X11R5/include /usr/include/X11R5 /usr/openwin/include /usr/X11/include /usr/sww/include /usr/X11R6/include /usr/include/X11R6"
        for i in $dirs ; do
	    if test -r $i/X11/Intrinsic.h; then
		AC_MSG_RESULT($i)
	        XINCLUDES=" -I$i"
		break
	    fi
        done
    fi
else
    if test "$x_includes" != ""; then
	XINCLUDES=-I$x_includes
    else
	XINCLUDES="# no special path needed"
    fi
fi
if test -z "$XINCLUDES"; then
    AC_MSG_RESULT(couldn't find any!)
    XINCLUDES="# no include files found"
fi

if test "$no_x" = yes; then
    AC_MSG_CHECKING(for X11 libraries)
    XLIBSW=
    dirs="/usr/unsupported/lib /usr/local/lib /usr/X386/lib /usr/lib/X11R4 /usr/X11R5/lib /usr/lib/X11R5 /usr/X11R6/lib /usr/lib/X11R6 /usr/openwin/lib /usr/X11/lib /usr/sww/X11/lib"
    for i in $dirs ; do
	if test -r $i/libX11.a -o -r $i/libX11.so -o -r $i/libX11.sl; then
	    AC_MSG_RESULT($i)
	    XLIBSW="-L$i -lX11"
	    break
	fi
    done
else
    if test "$x_libraries" = ""; then
	XLIBSW=-lX11
    else
	XLIBSW="-L$x_libraries -lX11"
    fi
fi
if test -z "$XLIBSW" ; then
    AC_CHECK_LIB(Xwindow, XCreateWindow, XLIBSW=-lXwindow)
fi
if test -z "$XLIBSW" ; then
    AC_MSG_RESULT(couldn't find any!  Using -lX11.)
    XLIBSW=-lX11
fi

AC_SUBST(XINCLUDES)
AC_SUBST(XLIBSW)

AC_ARG_WITH(alllang, AS_HELP_STRING([--without-alllang], [Disable all languages]), with_alllang="$withval")

#--------------------------------------------------------------------
#	Try to locate the Tcl package
#--------------------------------------------------------------------

TCLINCLUDE=
TCLLIB=
TCLPACKAGE=

AC_ARG_WITH(tclconfig, AS_HELP_STRING([--without-tcl], [Disable Tcl])
AS_HELP_STRING([--with-tclconfig=path], [Set location of tclConfig.sh]),
        with_tclconfig="$withval")
AC_ARG_WITH(tcl,
 [  --with-tcl=path         Set location of Tcl package],[
	TCLPACKAGE="$withval"], [TCLPACKAGE=])
AC_ARG_WITH(tclincl,[  --with-tclincl=path     Set location of Tcl include directory],[
	TCLINCLUDE="$ISYSTEM$withval"], [TCLINCLUDE=])
AC_ARG_WITH(tcllib,[  --with-tcllib=path      Set location of Tcl library directory],[
	TCLLIB="-L$withval"], [TCLLIB=])

# First, check for "--without-tcl" or "--with-tcl=no".
if test x"${TCLPACKAGE}" = xno -o x"${with_alllang}" = xno; then 
AC_MSG_NOTICE([Disabling Tcl])
else
AC_MSG_CHECKING([for Tcl configuration])
# First check to see if --with-tclconfig was specified.
if test x"${with_tclconfig}" != x ; then
   if test -f "${with_tclconfig}/tclConfig.sh" ; then
      TCLCONFIG=`(cd ${with_tclconfig}; pwd)`
   else
      AC_MSG_ERROR([${with_tcl} directory doesn't contain tclConfig.sh])
   fi
fi
# check in a few common install locations
if test x"${TCLCONFIG}" = x ; then
    for i in `ls -d /usr/lib 2>/dev/null` \
	    `ls -d /usr/local/lib 2>/dev/null` ; do
	if test -f "$i/tclConfig.sh" ; then
	    TCLCONFIG=`(cd $i; pwd)`
	    break
	fi
    done
fi
if test x"${TCLCONFIG}" = x ; then
    AC_MSG_RESULT(no)
else
    AC_MSG_RESULT(found $TCLCONFIG/tclConfig.sh)
    . $TCLCONFIG/tclConfig.sh
    if test -z "$TCLINCLUDE"; then
        TCLINCLUDE=$ISYSTEM$TCL_PREFIX/include
    fi
    if test -z "$TCLLIB"; then
        TCLLIB=$TCL_LIB_SPEC
    fi
fi

if test -z "$TCLINCLUDE"; then
   if test -n "$TCLPACKAGE"; then
	TCLINCLUDE="$ISYSTEM$TCLPACKAGE/include"
   fi
fi

if test -z "$TCLLIB"; then
   if test -n "$TCLPACKAGE"; then
	TCLLIB="-L$TCLPACKAGE/lib -ltcl"
   fi
fi

AC_MSG_CHECKING(for Tcl header files)
if test -z "$TCLINCLUDE"; then
AC_TRY_CPP([#include <tcl.h>], , TCLINCLUDE="")
if test -z "$TCLINCLUDE"; then
	dirs="/usr/local/include /usr/include /opt/local/include"
	for i in $dirs ; do
		if test -r $i/tcl.h; then
			AC_MSG_RESULT($i)
			TCLINCLUDE="$ISYSTEM$i"
			break
		fi
	done
fi
if test -z "$TCLINCLUDE"; then
    	AC_MSG_RESULT(not found)
fi
else
        AC_MSG_RESULT($TCLINCLUDE)
fi

AC_MSG_CHECKING(for Tcl library)
if test -z "$TCLLIB"; then
dirs="/usr/local/lib /usr/lib /opt/local/lib"
for i in $dirs ; do
	if test -r $i/libtcl.a; then
	    AC_MSG_RESULT($i)
	    TCLLIB="-L$i -ltcl"
	    break
	fi
done
if test -z "$TCLLIB"; then
	AC_MSG_RESULT(not found)
fi
else
AC_MSG_RESULT($TCLLIB)
fi

# Cygwin (Windows) needs the library for dynamic linking
case $host in
*-*-cygwin* | *-*-mingw*) TCLDYNAMICLINKING="$TCLLIB";;
*)TCLDYNAMICLINKING="";;
esac
fi

AC_SUBST(TCLINCLUDE)
AC_SUBST(TCLLIB)
AC_SUBST(TCLDYNAMICLINKING)

#----------------------------------------------------------------
# Look for Python
#----------------------------------------------------------------

PYINCLUDE=
PYLIB=
PYPACKAGE=

AC_ARG_WITH(python, AS_HELP_STRING([--without-python], [Disable Python])
AS_HELP_STRING([--with-python=path], [Set location of Python executable]),[ PYBIN="$withval"], [PYBIN=])

# First, check for "--without-python" or "--with-python=no".
if test x"${PYBIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling Python])
else
# First figure out the name of the Python executable

if test -z "$PYBIN"; then
AC_CHECK_PROGS(PYTHON, python python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5 python1.4 python)
else
PYTHON="$PYBIN"
fi

if test -n "$PYTHON"; then
    AC_MSG_CHECKING(for Python prefix)
    PYPREFIX=`($PYTHON -c "import sys; print sys.prefix") 2>/dev/null`
    AC_MSG_RESULT($PYPREFIX)
    AC_MSG_CHECKING(for Python exec-prefix)
    PYEPREFIX=`($PYTHON -c "import sys; print sys.exec_prefix") 2>/dev/null`
    AC_MSG_RESULT($PYEPREFIX)


    # Note: I could not think of a standard way to get the version string from different versions.
    # This trick pulls it out of the file location for a standard library file.

    AC_MSG_CHECKING(for Python version)

    # Need to do this hack since autoconf replaces __file__ with the name of the configure file
    filehack="file__"
    PYVERSION=`($PYTHON -c "import string,operator,os.path; print operator.getitem(os.path.split(operator.getitem(os.path.split(string.__$filehack),0)),1)")`
    AC_MSG_RESULT($PYVERSION)

    # Find the directory for libraries this is necessary to deal with
    # platforms that can have apps built for multiple archs: e.g. x86_64
    AC_MSG_CHECKING(for Python lib dir)
    PYLIBDIR=`($PYTHON -c "import sys; print sys.lib") 2>/dev/null`
    if test -z "$PYLIBDIR"; then
      # older versions don't have sys.lib  so the best we can do is assume lib
      PYLIBDIR="lib" 
    fi
    AC_MSG_RESULT($PYLIBDIR)
    
    # Set the include directory

    AC_MSG_CHECKING(for Python header files)
    if test -r $PYPREFIX/include/$PYVERSION/Python.h; then
        PYINCLUDE="-I$PYPREFIX/include/$PYVERSION -I$PYEPREFIX/$PYLIBDIR/$PYVERSION/config"
    fi
    if test -z "$PYINCLUDE"; then
        if test -r $PYPREFIX/include/Py/Python.h; then
            PYINCLUDE="-I$PYPREFIX/include/Py -I$PYEPREFIX/$PYLIBDIR/python/lib"
        fi
    fi
    AC_MSG_RESULT($PYINCLUDE)

    # Set the library directory blindly.   This probably won't work with older versions
    AC_MSG_CHECKING(for Python library)
    dirs="$PYVERSION/config $PYVERSION/$PYLIBDIR python/$PYLIBDIR"
    for i in $dirs; do
        if test -d $PYEPREFIX/$PYLIBDIR/$i; then
           PYLIB="$PYEPREFIX/$PYLIBDIR/$i"
           break
        fi
    done
    if test -z "$PYLIB"; then
        AC_MSG_RESULT(Not found)
    else
        AC_MSG_RESULT($PYLIB)
    fi

    # Check for really old versions
    if test -r $PYLIB/libPython.a; then
         PYLINK="-lModules -lPython -lObjects -lParser"
    else
         PYLINK="-l$PYVERSION"
    fi
fi

# Cygwin (Windows) needs the library for dynamic linking
case $host in
*-*-cygwin* | *-*-mingw*) PYTHONDYNAMICLINKING="-L$PYLIB $PYLINK"
         PYINCLUDE="-DUSE_DL_IMPORT $PYINCLUDE"
         ;;
*)PYTHONDYNAMICLINKING="";;
esac
fi

AC_SUBST(PYINCLUDE)
AC_SUBST(PYLIB)
AC_SUBST(PYLINK)
AC_SUBST(PYTHONDYNAMICLINKING)

#----------------------------------------------------------------
# Look for Perl5
#----------------------------------------------------------------

PERLBIN=

AC_ARG_WITH(perl5, AS_HELP_STRING([--without-perl5], [Disable Perl5])
AS_HELP_STRING([--with-perl5=path], [Set location of Perl5 executable]),[ PERLBIN="$withval"], [PERLBIN=])

# First, check for "--without-perl5" or "--with-perl5=no".
if test x"${PERLBIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling Perl5])
else

# First figure out what the name of Perl5 is

if test -z "$PERLBIN"; then
AC_CHECK_PROGS(PERL, perl perl5.6.1 perl5.6.0 perl5.004 perl5.003 perl5.002 perl5.001 perl5 perl)
else
PERL="$PERLBIN"
fi


AC_MSG_CHECKING(for Perl5 header files)
if test -n "$PERL"; then
	PERL5DIR=`($PERL -e 'use Config; print $Config{archlib}, "\n";') 2>/dev/null`
	if test "$PERL5DIR" != ""; then
		dirs="$PERL5DIR $PERL5DIR/CORE"
		PERL5EXT=none
		for i in $dirs; do
			if test -r $i/perl.h; then
				AC_MSG_RESULT($i)
				PERL5EXT="$i"
				break;
			fi
		done
		if test "$PERL5EXT" = none; then
			PERL5EXT="$PERL5DIR/CORE"
			AC_MSG_RESULT(could not locate perl.h...using $PERL5EXT)
		fi

		AC_MSG_CHECKING(for Perl5 library)
		PERL5LIB=`($PERL -e 'use Config; $_=$Config{libperl}; s/^lib//; s/$Config{_a}$//; print $_, "\n"') 2>/dev/null`
		if test "$PERL5LIB" = "" ; then
			AC_MSG_RESULT(not found)
		else
			AC_MSG_RESULT($PERL5LIB)
		fi
    AC_MSG_CHECKING(for Perl5 compiler options)
 		PERL5CCFLAGS=`($PERL -e 'use Config; print $Config{ccflags}, "\n"' | sed "s/-I/$ISYSTEM/") 2>/dev/null`
 		if test "$PERL5CCFLAGS" = "" ; then
 			AC_MSG_RESULT(not found)
 		else
 			AC_MSG_RESULT($PERL5CCFLAGS)
 		fi
	else
		AC_MSG_RESULT(unable to determine perl5 configuration)
		PERL5EXT=$PERL5DIR
	fi
else
       	AC_MSG_RESULT(could not figure out how to run perl5)
fi

# Cygwin (Windows) needs the library for dynamic linking
case $host in
*-*-cygwin* | *-*-mingw*) PERL5DYNAMICLINKING="-L$PERL5EXT -l$PERL5LIB";;
*)PERL5DYNAMICLINKING="";;
esac
fi

AC_SUBST(PERL)
AC_SUBST(PERL5EXT)
AC_SUBST(PERL5DYNAMICLINKING)
AC_SUBST(PERL5LIB)
AC_SUBST(PERL5CCFLAGS)

#----------------------------------------------------------------
# Look for java
#----------------------------------------------------------------

AC_ARG_WITH(java, AS_HELP_STRING([--without-java], [Disable Java])
AS_HELP_STRING([--with-java=path], [Set location of Java executable]),[JAVABIN="$withval"], [JAVABIN=])
AC_ARG_WITH(javac, [  --with-javac=path       Set location of Javac executable],[JAVACBIN="$withval"], [JAVACBIN=])

# First, check for "--without-java" or "--with-java=no".
if test x"${JAVABIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling Java])
else

if test -z "$JAVABIN" ; then
  AC_CHECK_PROGS(JAVA, java kaffe guavac)
else
  JAVA="$JAVABIN"
fi

if test -z "$JAVACBIN" ; then
  AC_CHECK_PROGS(JAVAC, javac)
else
  JAVAC="$JAVACBIN"
fi

AC_MSG_CHECKING(for java include file jni.h)
AC_ARG_WITH(javaincl, [  --with-javaincl=path    Set location of Java include directory], [JAVAINCDIR="$withval"], [JAVAINCDIR=])

if test -z "$JAVAINCDIR"; then
  JAVAINCDIR="/usr/j2sdk*/include /usr/local/j2sdk*/include /usr/jdk*/include /usr/local/jdk*/include /opt/j2sdk*/include /opt/jdk*/include /usr/java/include /usr/java/j2sdk*/include /usr/java/jdk*/include /usr/local/java/include /opt/java/include /usr/include/java /usr/local/include/java /usr/lib/java/include /usr/include/kaffe /usr/local/include/kaffe /usr/include"

  # Add in default installation directory on Windows for Cygwin
  case $host in
  *-*-cygwin* | *-*-mingw*) JAVAINCDIR="c:/Program*Files/Java/jdk*/include d:/Program*Files/Java/jdk*/include c:/j2sdk*/include d:/j2sdk*/include c:/jdk*/include d:/jdk*/include $JAVAINCDIR";;
  *-*-darwin*) JAVAINCDIR="/System/Library/Frameworks/JavaVM.framework/Headers $JAVAINCDIR";;
  *);;
  esac
fi

JAVAINC=""
for d in $JAVAINCDIR ; do
  if test -r "$d/jni.h" ; then
    AC_MSG_RESULT($d)
    JAVAINCDIR=$d
    JAVAINC=-I\"$d\"
    break
  fi
done

if test "$JAVAINC" = "" ; then
  AC_MSG_RESULT(not found)
else
  # now look for <arch>/jni_md.h
  AC_MSG_CHECKING(for java include file jni_md.h)
  JAVAMDDIR=`find "$JAVAINCDIR" -follow -name jni_md.h -print`
  if test "$JAVAMDDIR" = "" ; then
    AC_MSG_RESULT(not found)
  else
    JAVAMDDIR=`dirname "$JAVAMDDIR" | tail -n 1`
    JAVAINC="${JAVAINC} -I\"$JAVAMDDIR\""
    AC_MSG_RESULT($JAVAMDDIR)
  fi
fi

# java.exe on Cygwin requires the Windows standard (Pascal) calling convention as it is a normal Windows executable and not a Cygwin built executable
case $host in
*-*-cygwin* | *-*-mingw*)
    if test "$GCC" = yes; then
        JAVADYNAMICLINKING=" -mno-cygwin -mthreads -Wl,--add-stdcall-alias"
        JAVACFLAGS="-mno-cygwin -mthreads"
    else
        JAVADYNAMICLINKING=""
        JAVACFLAGS=""
    fi ;;
*-*-darwin*) 
        JAVADYNAMICLINKING="-dynamiclib -framework JavaVM"
        JAVACFLAGS=""
        ;;
*)
        JAVADYNAMICLINKING=""
        JAVACFLAGS=""
        ;;
esac

# Java on Windows platforms including Cygwin doesn't use libname.dll, rather name.dll when loading dlls
case $host in
*-*-cygwin* | *-*-mingw*) JAVALIBRARYPREFIX="";;
*)JAVALIBRARYPREFIX="lib";;
esac

# Java on Mac OS X tweaks
case $host in
*-*-darwin*) 
    JAVASO=".jnilib"
    JAVALDSHARED='$(CC)'
    JAVACXXSHARED='$(CXX)'
    ;;
*)
    JAVASO=$SO
    JAVALDSHARED='$(LDSHARED)'
    JAVACXXSHARED='$(CXXSHARED)'
    ;;
esac
fi

AC_SUBST(JAVA)
AC_SUBST(JAVAC)
AC_SUBST(JAVAINC)
AC_SUBST(JAVADYNAMICLINKING)
AC_SUBST(JAVALIBRARYPREFIX)
AC_SUBST(JAVASO)
AC_SUBST(JAVALDSHARED)
AC_SUBST(JAVACXXSHARED)
AC_SUBST(JAVACFLAGS)

#----------------------------------------------------------------
# Look for Guile
#----------------------------------------------------------------

GUILEPACKAGE=
GUILEINCLUDE=
GUILE=
GUILELIB=
GUILELINK=
GUILEPKGDATADIR=

AC_ARG_WITH(guile-config,AS_HELP_STRING([--without-guile], [Disable Guile])
AS_HELP_STRING([--with-guile-config=path], [Set location of guile-config]),[ GUILE_CONFIG="$withval"], [GUILE_CONFIG=])
AC_ARG_WITH(guilepackage, AS_HELP_STRING([--with-guile-prefix=path], [Set location of Guile tree]),[
	GUILEPACKAGE="$withval"])
AC_ARG_WITH(guile,[  --with-guile=path       Set location of Guile executable],[
	GUILE="$withval"])
AC_ARG_WITH(guileincl,[  --with-guileincl=path   Set location of Guile include directory],[
	GUILEINCLUDE="$withval"])
AC_ARG_WITH(guilelib,[  --with-guilelib=path    Set location of Guile library directory],[
	GUILELIB="$withval"])

# First, check for "--without-guile" or "--with-guile=no".
if test x"${GUILE}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling Guile])
else

if test -z "$GUILE_CONFIG" ; then
  AC_PATH_PROG(GUILE_CONFIG, guile-config)
fi

if test -n "$GUILE_CONFIG" ; then
  GUILEPACKAGE="`$GUILE_CONFIG info prefix`"
  GUILEINCLUDE="`$GUILE_CONFIG info includedir`"
  GUILELIB="`$GUILE_CONFIG info libdir`"
  GUILE="`$GUILE_CONFIG info bindir`/guile"
  GUILELINK="`$GUILE_CONFIG link`"
  GUILEPKGDATADIR="`$GUILE_CONFIG info pkgdatadir`"
fi

  if test -z "$GUILE"; then
     if test -n "$GUILEPACKAGE"; then
  	GUILE="$GUILEPACKAGE/bin/guile"
     fi
  fi

  if test -z "$GUILEINCLUDE"; then
     if test -n "$GUILEPACKAGE"; then
  	GUILEINCLUDE="$GUILEPACKAGE/include"
     fi
  fi

  if test -z "$GUILELIB"; then
     if test -n "$GUILEPACKAGE"; then
  	GUILELIB="$GUILEPACKAGE/lib"
     fi
  fi


AC_MSG_CHECKING(for Guile header files)

  dirs="$GUILEINCLUDE"
  for i in $dirs ; do
  	if test -r $i/guile/gh.h; then
  		AC_MSG_RESULT($i)
  		GUILEINCLUDE="$ISYSTEM$i"
  		break
  	fi
  done
  if test -z "$GUILEINCLUDE"; then
      	AC_MSG_RESULT(not found)
  fi

  AC_MSG_CHECKING(for Guile library)
  dirs="$GUILELIB"
  for i in $dirs ; do
  	if test -r $i/libguile.so; then
  	    AC_MSG_RESULT($i)
  	    GUILELIB="$i"
  	    break
  	fi
  done
  if test -z "$GUILELIB"; then
  	AC_MSG_RESULT(not found)
  fi

if test -z "$GUILELINK"; then
  GUILELINK="-L$GUILELIB -lguile"
fi

guilesafe_CFLAGS=$CFLAGS
guilesafe_LDFLAGS=$LDFLAGS
CFLAGS="$CFLAGS $GUILEINCLUDE"
LDFLAGS="$LDFLAGS $GUILELINK"

AC_MSG_CHECKING(whether Guile's gh_ API works)
AC_LINK_IFELSE([#include <guile/gh.h>
  int main() { SCM s; return gh_scm2int(s); }], GUILE_GH_INTERFACE=1, )
if test -n "$GUILE_GH_INTERFACE" ; then
        AC_MSG_RESULT(yes)
else
	AC_MSG_RESULT(no)
fi
AC_MSG_CHECKING(whether Guile's SCM_ API works)
AC_LINK_IFELSE([#include <libguile.h>
  int main() { SCM s; scm_slot_exists_p(SCM_BOOL_F, SCM_BOOL_F); return SCM_STRING_LENGTH(s); }], GUILE_SCM_INTERFACE=1, )
if test -n "$GUILE_SCM_INTERFACE" ; then
        AC_MSG_RESULT(yes)
else
	AC_MSG_RESULT(no)
fi
CFLAGS=$guilesafe_CFLAGS
LDFLAGS=$guilesafe_LDFLAGS
fi

AC_SUBST(GUILE)
AC_SUBST(GUILEINCLUDE)
AC_SUBST(GUILELIB)
AC_SUBST(GUILELINK)
AC_SUBST(GUILE_GH_INTERFACE)
AC_SUBST(GUILE_SCM_INTERFACE)

#----------------------------------------------------------------
# Look for MzScheme
#----------------------------------------------------------------

AC_ARG_WITH(mzscheme, AS_HELP_STRING([--without-mzscheme], [Disable MzScheme])
AS_HELP_STRING([--with-mzscheme=path], [Set location of MzScheme executable]),[ MZSCHEMEBIN="$withval"], [MZSCHEMEBIN=])
AC_ARG_WITH(mzc, AS_HELP_STRING([--with-mzc=path], [Set location of MzScheme's mzc]), [ MZCBIN="$withval"], [MZCBIN=])

# First, check for "--without-mzscheme" or "--with-mzscheme=no".
if test x"${MZSCHEMEBIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling MzScheme])
else

if test -z "$MZSCHEMEBIN"; then
   AC_PATH_PROG(MZSCHEME, mzscheme)
else
   MZSCHEME="$MZSCHEMEBIN"
fi

if test -z "$MZCBIN"; then
   AC_PATH_PROG(MZC, mzc)
else
   MZC="$MZC"
fi

if test -n "$MZSCHEME"; then
AC_MSG_CHECKING(for MzScheme dynext object) 
MZDYNOBJ=`$MZSCHEME --mute-banner --version --eval '(begin (require (lib "link.ss" "dynext")) (with-handlers (((lambda args #t) (lambda args #f))) (for-each (lambda (x) (display x) (display " ")) ((current-make-standard-link-libraries)))) (with-handlers (((lambda args #t) (lambda args #f))) (for-each (lambda (x) (display x) (display " ")) (expand-for-link-variant (current-standard-link-libraries)))))'`
AC_MSG_RESULT($MZDYNOBJ)
fi
fi
AC_SUBST(MZDYNOBJ)

#----------------------------------------------------------------
# Look for Ruby
#----------------------------------------------------------------

RUBYBIN=

AC_ARG_WITH(ruby, AS_HELP_STRING([--without-ruby], [Disable Ruby])
AS_HELP_STRING([--with-ruby=path], [Set location of Ruby executable]),[ RUBYBIN="$withval"], [RUBYBIN=])

# First, check for "--without-ruby" or "--with-ruby=no".
if test x"${RUBYBIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling Ruby])
else

# First figure out what the name of Ruby is

if test -z "$RUBYBIN"; then
	AC_CHECK_PROGS(RUBY, ruby)
else
	RUBY="$RUBYBIN"
fi

AC_MSG_CHECKING(for Ruby header files)
if test -n "$RUBY"; then
	RUBYDIR=`($RUBY -rmkmf -e 'print Config::CONFIG[["archdir"]] || $archdir') 2>/dev/null`
	if test "$RUBYDIR" != ""; then
		dirs="$RUBYDIR"
		RUBYINCLUDE=none
		for i in $dirs; do
			if test -r $i/ruby.h; then
				AC_MSG_RESULT($i)
				RUBYINCLUDE="-I$i"
				break;
			fi
		done
		if test "$RUBYINCLUDE" = none; then
			RUBYINCLUDE="-I$RUBYDIR"
			AC_MSG_RESULT(could not locate ruby.h...using $RUBYINCLUDE)
		fi

		# Find library and path for linking.
		AC_MSG_CHECKING(for Ruby library)
		RUBYLIB=""
		rb_libdir=`($RUBY -rrbconfig -e 'print Config::CONFIG[["libdir"]]') 2>/dev/null`
		rb_bindir=`($RUBY -rrbconfig -e 'print Config::CONFIG[["bindir"]]') 2>/dev/null`
		dirs="$dirs $rb_libdir $rb_bindir"

        rb_libruby=`($RUBY -rrbconfig -e 'print Config::CONFIG[["LIBRUBY_A"]]') 2>/dev/null`
        RUBYLINK=`($RUBY -rrbconfig -e '
            c = Config::CONFIG
            if c.has_key? "LIBRUBYARG_STATIC" # 1.8.x
                if c[["LIBRUBY"]] == c[["LIBRUBY_A"]]
                    link = c[["LIBRUBYARG_STATIC"]]
                else
                    link = c[["LIBRUBYARG_SHARED"]]
                end
            else # 1.6.x
                link = "-l" + c[["RUBY_INSTALL_NAME"]]
            end
            
            # Get the target Ruby was built for
            target = c[["target"]]
           
            if target == "i386-pc-mswin32"
              # Need to change msvcrt-ruby*.lib to -lmsvcrt-ruby*
              ext = File.extname(link)
              # Get index that counts backwards from end of string
              index = -1 - ext.size
              # Strip off the extension
              link = link.slice(0..index)
              puts "-l#{link}"
            else
              puts link
            end') 2>/dev/null`

		if test "$rb_libruby" != ""; then
			for i in $dirs; do
				if (test -r $i/$rb_libruby;) then
					RUBYLIB="$i"
					break;
				fi
			done
		fi
		if test "$RUBYLIB" = ""; then
			RUBYLIB="$RUBYDIR"
			AC_MSG_RESULT(not found... using $RUBYDIR)
		else
			AC_MSG_RESULT($RUBYLINK in $RUBYLIB)
		fi
	else
		AC_MSG_RESULT(unable to determine ruby configuration)
		RUBYINCLUDE="-I$RUBYDIR"
		RUBYLIB="$RUBYDIR"
	fi

	case $host in
		*-*-mingw*) ;; # do nothing, the default windows libraries are already included
		*) RUBYLINK="$RUBYLINK `($RUBY -rrbconfig -e 'print Config::CONFIG[["LIBS"]]') 2>/dev/null`";;
	esac

	RUBYCCDLFLAGS=`($RUBY -rrbconfig -e 'print Config::CONFIG[["CCDLFLAGS"]]') 2>/dev/null`
else
	AC_MSG_RESULT(could not figure out how to run ruby)
	RUBYINCLUDE="-I/usr/local/lib/ruby/1.4/arch"
	RUBYLIB="/usr/local/lib/ruby/1.4/arch"
	RUBYLINK="-lruby -lm"
fi

case $host in
*-*-cygwin* | *-*-mingw*)	RUBYDYNAMICLINKING="-L$RUBYLIB $RUBYLINK";;
*)		RUBYDYNAMICLINKING="";;
esac
fi

AC_SUBST(RUBYINCLUDE)
AC_SUBST(RUBYLIB)
AC_SUBST(RUBYLINK)
AC_SUBST(RUBYCCDLFLAGS)
AC_SUBST(RUBYDYNAMICLINKING)

#-------------------------------------------------------------------------
# Look for Php4
#-------------------------------------------------------------------------

PHP4BIN=

AC_ARG_WITH(php4, AS_HELP_STRING([--without-php4], [Disable PHP4])
AS_HELP_STRING([--with-php4=path], [Set location of PHP4 executable]),[ PHP4BIN="$withval"], [PHP4BIN=])

# First, check for "--without-php4" or "--with-php4=no".
if test x"${PHP4BIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling PHP4])
else

if test -z "$PHP4BIN"; then
AC_CHECK_PROGS(PHP4, php php4)
else
PHP4="$PHP4BIN"
fi

AC_MSG_CHECKING(for PHP4 header files)
PHP4CONFIG="${PHP4}-config"
PHP4INC="`$PHP4CONFIG --includes 2>/dev/null`"
if test "$PHP4INC"; then
	AC_MSG_RESULT($PHP4INC)
else
	dirs="/usr/include/php /usr/local/include/php /usr/include/php4 /usr/local/include/php4 /usr/local/apache/php"
	for i in $dirs; do
		echo $i
		if test -r $i/php_config.h -o -r $i/php_version.h; then
			AC_MSG_RESULT($i)
			PHP4EXT="$i"
			PHP4INC="-I$PHP4EXT -I$PHP4EXT/Zend -I$PHP4EXT/main -I$PHP4EXT/TSRM"
			break;
		fi
	done
fi
if test -z "$PHP4INC"; then
	AC_MSG_RESULT(not found)
fi

fi
AC_SUBST(PHP4)
AC_SUBST(PHP4INC)

#----------------------------------------------------------------
# Look for ocaml
#----------------------------------------------------------------

AC_ARG_WITH(ocaml, AS_HELP_STRING([--without-ocaml], [Disable OCaml])
AS_HELP_STRING([--with-ocaml=path], [Set location of ocaml executable]),[ OCAMLBIN="$withval"], [OCAMLBIN=])
AC_ARG_WITH(ocamlc,[  --with-ocamlc=path      Set location of ocamlc executable],[ OCAMLC="$withval"], [OCAMLC=])
AC_ARG_WITH(ocamldlgen,[  --with-ocamldlgen=path  Set location of ocamldlgen],[ OCAMLDLGEN="$withval" ], [OCAMLDLGEN=])
AC_ARG_WITH(ocamlfind,[  --with-ocamlfind=path   Set location of ocamlfind],[OCAMLFIND="$withval"],[OCAMLFIND=])
AC_ARG_WITH(ocamlmktop,[  --with-ocamlmktop=path  Set location of ocamlmktop executable],[ OCAMLMKTOP="$withval"], [OCAMLMKTOP=])

# First, check for "--without-ocaml" or "--with-ocaml=no".
if test x"${OCAMLBIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling OCaml])
else

AC_MSG_CHECKING(for Ocaml DL load generator)
if test -z "$OCAMLDLGEN"; then
AC_CHECK_PROGS(OCAMLDLGEN, ocamldlgen, ocamldlgen)
else
OCAMLDLGEN="$OCAMLDLGEN"
fi

AC_MSG_CHECKING(for Ocaml package tool)
if test -z "$OCAMLFIND"; then
AC_CHECK_PROGS(OCAMLFIND, ocamlfind, ocamlfind)
else
OCAMLFIND="$OCAMLFIND"
fi

AC_MSG_CHECKING(for Ocaml compiler)
if test -z "$OCAMLC"; then
AC_CHECK_PROGS(OCAMLC, ocamlc, ocamlc)
else
OCAMLC="$OCAMLC"
fi

AC_MSG_CHECKING(for Ocaml interpreter)
if test -z "$OCAMLBIN"; then
AC_CHECK_PROGS(OCAMLBIN, ocaml, ocaml)
else
OCAMLBIN="$OCAMLBIN"
fi

AC_MSG_CHECKING(for Ocaml toplevel creator)
if test -z "$OCAMLMKTOP"; then
AC_CHECK_PROGS(OCAMLMKTOP, ocamlmktop, ocamlmktop)
else
OCAMLMKTOP="$OCAMLMKTOP"
fi

AC_MSG_CHECKING(for Ocaml header files)
dirs="/usr/lib/ocaml/caml /usr/local/lib/ocaml/caml"
dir="`$OCAMLC -where 2>/dev/null`"
if test "$dir"; then
	dirs="$dir/caml $dirs"
fi
for i in $dirs; do
	if test -r $i/mlvalues.h; then
		AC_MSG_RESULT($i)
		OCAMLEXT="$i"
		OCAMLINC="-I$OCAMLEXT"
		break;
	fi
done
if test -z "$OCAMLINC"; then
	AC_MSG_RESULT(not found)
fi
fi

export OCAMLINC
export OCAMLBIN
export OCAMLC
export OCAMLDLGEN
export OCAMLFIND
export OCAMLMKTOP

AC_SUBST(OCAMLINC)
AC_SUBST(OCAMLBIN)
AC_SUBST(OCAMLC)
AC_SUBST(OCAMLDLGEN)
AC_SUBST(OCAMLFIND)
AC_SUBST(OCAMLMKTOP)

#----------------------------------------------------------------
# Look for Pike
#----------------------------------------------------------------

# Identify the name of the Pike executable
# Priority: configure option, automatic search
PIKEBIN=
AC_ARG_WITH(pike, AS_HELP_STRING([--without-pike], [Disable Pike])
AS_HELP_STRING([--with-pike=path], [Set location of Pike executable]),[ PIKEBIN="$withval"], [PIKEBIN=])

# First, check for "--without-pike" or "--with-pike=no".
if test x"${PIKEBIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling Pike])
else

if test -z "$PIKEBIN"; then
	AC_CHECK_PROGS(PIKE, pike pike7.6 pike7.4 pike7.2)
else
	PIKE="$PIKEBIN"
fi


# Check for pike-config
# Priority: configure option, guessed from $PIKE, search from list
AC_ARG_WITH(pike-config, AS_HELP_STRING([--with-pike-config=path], 
  	[Set location of pike-config script]),
  [PIKECONFIG="$withval"], [PIKECONFIG=""])

if test -z "$PIKECONFIG" -a -n "$PIKE"; then
	AC_CHECK_PROGS(PIKECONFIG, $PIKE-config pike-config \
		pike7.6-config pike7.4-config pike7.2-config)
fi

# Check for a --with-pikeincl option to configure
# Priority: configure option, info from $PIKECONFIG, guessed by pike script
AC_ARG_WITH(pikeincl, AS_HELP_STRING([--with-pikeincl=path], 
	[Set location of Pike include directory]),
  [PIKEINCLUDE="-I$withval"], [PIKEINCLUDE=])

AC_MSG_CHECKING([for Pike header files])
if test -z "$PIKEINCLUDE" -a -n "$PIKECONFIG"; then
	PIKEINCLUDE=`$PIKECONFIG --cflags`
fi
if test -z "$PIKEINCLUDE" -a -n "$PIKE"; then
	PIKEPATH=`which $PIKE`
	PIKEINCLUDE=`$PIKE Tools/check-include-path.pike $PIKEPATH`
	PIKEINCLUDE="-I$PIKEINCLUDE"
fi

if test -z "$PIKEINCLUDE"; then
    	AC_MSG_RESULT(not found)
else
        AC_MSG_RESULT($PIKEINCLUDE)
fi
fi

AC_SUBST(PIKEINCLUDE)
AC_SUBST(PIKECCDLFLAGS)		dnl XXX: where is this used/defined?
AC_SUBST(PIKEDYNAMICLINKING)	dnl XXX: where is this used/defined?

#----------------------------------------------------------------
# Look for CHICKEN
#----------------------------------------------------------------

CHICKEN=
CHICKEN_CONFIG=
CHICKENHOME=
CHICKENOPTS=
CHICKENLIB=


AC_ARG_WITH(chicken, AS_HELP_STRING([--without-chicken], [Disable CHICKEN])
AS_HELP_STRING([--with-chicken=path], [Set location of CHICKEN executable]),[ CHICKEN="$withval"], [CHICKEN=])

# First, check for "--without-chicken" or "--with-chicken=no".
if test x"${CHICKEN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling CHICKEN])
else

if test -z "$CHICKEN"; then
AC_CHECK_PROGS(CHICKEN, chicken)
else
CHICKEN="$CHICKEN"
fi

AC_ARG_WITH(chickencsc,[  --with-chickencsc=path  Set location of csc executable],[ CHICKEN_CSC="$withval"], [CHICKEN_CSC=])

if test -z "$CHICKEN_CSC"; then
AC_CHECK_PROGS(CHICKEN_CSC, csc)
else
CHICKEN_CSC="$CHICKEN_CSC"
fi

AC_ARG_WITH(chickencsi,[  --with-chickencsi=path  Set location of csi executable],[ CHICKEN_CSI="$withval"], [CHICKEN_CSI=])

if test -z "$CHICKEN_CSI"; then
AC_CHECK_PROGS(CHICKEN_CSI, csi)
else
CHICKEN_CSI="$CHICKEN_CSI"
fi

AC_ARG_WITH(chickencfg,[  --with-chickencfg=path  Set location of chicken-config],[ CHICKEN_CONFIG="$withval"], [CHICKEN_CONFIG=])

if test -z "$CHICKEN_CONFIG"; then
AC_CHECK_PROGS(CHICKEN_CONFIG, chicken-config)
else
CHICKEN_CONFIG="$CHICKEN_CONFIG"
fi

if test -n "$CHICKEN_CONFIG" ; then

  AC_ARG_WITH(chickenhome,[  --with-chickenhome=path Set location of CHICKEN home directory],[
	CHICKENHOME="$withval"], [CHICKENHOME=])
  AC_ARG_WITH(chickensharedopts,[  --with-chickensharedopts=path   Set compiler options for shared CHICKEN generated code],[
	CHICKENSHAREDOPTS="$withval"], [CHICKENSHAREDOPTS=])
  AC_ARG_WITH(chickenopts,[  --with-chickenopts=path Set compiler options for static CHICKEN generated code],[
	CHICKENOPTS="$withval"], [CHICKENOPTS=])
  AC_ARG_WITH(chickensharedlib,[  --with-chickensharedlib=path    Set linker options for shared CHICKEN generated code],[
	CHICKENSHAREDLIB="$withval"], [CHICKENSHAREDLIB=])
  AC_ARG_WITH(chickenlib,[  --with-chickenlib=path  Set linker options for static CHICKEN generated code],[
	CHICKENLIB="$withval"], [CHICKENLIB=])

  AC_MSG_CHECKING(for CHICKEN home directory)
  dirs="$CHICKENHOME `chicken-config -home | sed s/CHICKEN_HOME=//`"
  for i in $dirs ; do
  	if test -d $i; then
  		AC_MSG_RESULT($i)
  		CHICKENHOME="$i"
  		break
  	fi
  done
  if test -z "$CHICKENHOME"; then
      	AC_MSG_RESULT(not found)
  fi

  AC_MSG_CHECKING(for compiler options for shared CHICKEN generated code)
  if test -z "$CHICKENSHAREDOPTS"; then
        CHICKENSHAREDOPTS="`chicken-config -shared -cflags`"
  else
        CHICKENSHAREDOPTS="`chicken-config -shared -cflags` $CHICKENSHAREDOPTS"
  fi
  if test -z "$CHICKENSHAREDOPTS"; then
        AC_MSG_RESULT(not found)
  else
        AC_MSG_RESULT($CHICKENSHAREDOPTS)
  fi

  AC_MSG_CHECKING(for compiler options for static CHICKEN generated code)
  if test -z "$CHICKENOPTS"; then
        CHICKENOPTS="`chicken-config -cflags`"
  else
        CHICKENOPTS="`chicken-config -cflags` $CHICKENOPTS"
  fi
  if test -z "$CHICKENOPTS"; then
        AC_MSG_RESULT(not found)
  else
        AC_MSG_RESULT($CHICKENOPTS)
  fi

  AC_MSG_CHECKING(for linker options for shared CHICKEN generated code)
  dirs="$CHICKENSHAREDLIB `chicken-config -shared -libs -extra-libs | sed s/-L//g` /usr/lib"
  for i in $dirs ; do
  	if test -r $i/libchicken.a; then
  	    AC_MSG_RESULT(libraries found in $i)
  	    CHICKENSHAREDLIB="$CHICKENSHAREDLIB `chicken-config -shared -extra-libs`"
  	    CHICKENSHAREDLIB="$CHICKENSHAREDLIB `chicken-config -shared -libs`"
  	    break
  	fi
  done
  if test -z "$CHICKENSHAREDLIB"; then
  	AC_MSG_RESULT(not found)
  fi

  AC_MSG_CHECKING(for linker options for static CHICKEN generated code)
  dirs="$CHICKENLIB `chicken-config -libs -extra-libs | sed s/-L//g` /usr/lib "
  for i in $dirs ; do
  	if test -r $i/libchicken.a; then
  	    AC_MSG_RESULT(libraries found in $i)
  	    CHICKENLIB="$CHICKENLIB `chicken-config -extra-libs`"
  	    CHICKENLIB="$CHICKENLIB `chicken-config -libs`"
  	    break
  	fi
  done
  if test -z "$CHICKENLIB"; then
  	AC_MSG_RESULT(not found)
  fi

fi # have CHICKEN_CONFIG
fi # Check for --without-chicken

AC_SUBST(CHICKEN)
AC_SUBST(CHICKEN_CSC)
AC_SUBST(CHICKEN_CSI)
AC_SUBST(CHICKEN_CONFIG)
AC_SUBST(CHICKENHOME)
AC_SUBST(CHICKENOPTS)
AC_SUBST(CHICKENSHAREDOPTS)
AC_SUBST(CHICKENLIB)
AC_SUBST(CHICKENSHAREDLIB)

#----------------------------------------------------------------
# Look for C#
#----------------------------------------------------------------

AC_ARG_WITH(csharp, AS_HELP_STRING([--without-csharp], [Disable CSharp]), [with_csharp="$withval"], [with_csharp=])
AC_ARG_WITH(cil-interpreter, [  --with-cil-interpreter=path     Set location of CIL interpreter for CSharp],[CSHARPBIN="$withval"], [CSHARPBIN=])
AC_ARG_WITH(csharp-compiler, [  --with-csharp-compiler=path     Set location of CSharp compiler],[CSHARPCOMPILERBIN="$withval"], [CSHARPCOMPILERBIN=])

# First, check for "--without-csharp" or "--with-csharp=no".
if test x"${with_csharp}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling CSharp])
else

if test -z "$CSHARPCOMPILERBIN" ; then
  case $host in
  *-*-cygwin* | *-*-mingw*)
    AC_CHECK_PROGS(CSHARPCOMPILER, csc mcs cscc);;
  *)AC_CHECK_PROGS(CSHARPCOMPILER, mcs cscc);;
  esac
else
  CSHARPCOMPILER="$CSHARPCOMPILERBIN"
fi

CSHARPPATHSEPARATOR="/"
CSHARPCYGPATH_W=echo
if test -z "$CSHARPBIN" ; then
  CSHARPCILINTERPRETER=""
  if test "cscc" = "$CSHARPCOMPILER" ; then
    AC_CHECK_PROGS(CSHARPCILINTERPRETER, ilrun)
  else
    if test "mcs" = "$CSHARPCOMPILER"; then
      # Check that mcs is the C# compiler and not the Unix mcs utility by examining the output of 'mcs --version'
      # The Mono compiler should emit: Mono C# compiler version a.b.c.d
      csharp_version_raw=`(mcs --version) 2>/dev/null`
      csharp_version_searched=`(mcs --version | sed -e "/C#/b" -e "/Mono/b" -e d) 2>/dev/null` # return string if contains 'Mono' or 'C#'
      CSHARPCOMPILER="";
      if test -n "$csharp_version_raw" ; then
        if test "$csharp_version_raw" = "$csharp_version_searched" ; then
          CSHARPCOMPILER="mcs"
        fi
      fi
      if test "mcs" = "$CSHARPCOMPILER" ; then
        AC_CHECK_PROGS(CSHARPCILINTERPRETER, mono) # Mono JIT
      else
        echo "mcs is not a working Mono C# compiler"
      fi
    else 
      if test "csc" = "$CSHARPCOMPILER"; then
          CSHARPPATHSEPARATOR="\\\\"
          CSHARPCYGPATH_W='cygpath -w'
      fi
    fi
  fi
else
  CSHARPCILINTERPRETER="$CSHARPBIN"
fi

# Cygwin requires the Windows standard (Pascal) calling convention as it is a Windows executable and not a Cygwin built executable
case $host in
*-*-cygwin* | *-*-mingw*)
    if test "$GCC" = yes; then
        CSHARPDYNAMICLINKING=" -mno-cygwin -mthreads -Wl,--add-stdcall-alias"
        CSHARPCFLAGS="-mno-cygwin -mthreads"
    else
        CSHARPDYNAMICLINKING=""
        CSHARPCFLAGS=""
    fi ;;
*)
        CSHARPDYNAMICLINKING=""
        CSHARPCFLAGS=""
        ;;
esac

# CSharp on Windows platforms including Cygwin doesn't use libname.dll, rather name.dll when loading dlls
case $host in
*-*-cygwin* | *-*-mingw*) CSHARPLIBRARYPREFIX="";;
*)CSHARPLIBRARYPREFIX="lib";;
esac

# C#/Mono on Mac OS X tweaks
case $host in
*-*-darwin*)
    CSHARPSO=".so"
    ;;
*)
    CSHARPSO=$SO
    ;;
esac
fi

AC_SUBST(CSHARPCILINTERPRETER)
AC_SUBST(CSHARPPATHSEPARATOR)
AC_SUBST(CSHARPCYGPATH_W)
AC_SUBST(CSHARPCOMPILER)
AC_SUBST(CSHARPDYNAMICLINKING)
AC_SUBST(CSHARPLIBRARYPREFIX) # Is this going to be used?
AC_SUBST(CSHARPCFLAGS)
AC_SUBST(CSHARPSO)

#----------------------------------------------------------------
# Look for Lua
#----------------------------------------------------------------

LUABIN=
LUAINCLUDE=
LUALIB=
LUADYNAMICLOADLIB=

AC_ARG_WITH(lua, AS_HELP_STRING([--without-lua], [Disable Lua])
AS_HELP_STRING([--with-lua=path], [Set location of Lua executable]),[ LUABIN="$withval"], [LUABIN=])
AC_ARG_WITH(luaincl,[  --with-luaincl=path     Set location of Lua include directory],[
	LUAINCLUDE="$ISYSTEM$withval"], [LUAINCLUDE=])
AC_ARG_WITH(lualib,[  --with-lualib=path      Set location of Lua library directory],[
	LUALIB="-L$withval"], [LUALIB=])

# First, check for "--without-lua" or "--with-lua=no".
if test x"${LUABIN}" = xno -o x"${with_alllang}" = xno ; then 
AC_MSG_NOTICE([Disabling Lua])
else

# can we find lua?
if test -z "$LUABIN"; then
   AC_PATH_PROG(LUABIN, lua)
fi

# check version: we need Lua 5.x
if test "$LUABIN"; then
   AC_MSG_CHECKING(Lua version)
   # if version 5.x
   LUAV5=`$LUABIN -e 'if string.sub(_VERSION,5,5)=="5" then print "1" end'`
   # if not version 5.0
   LUAV51=`$LUABIN -e 'if string.sub(_VERSION,5,7)~="5.0" then print "1" end'`

   if test -z "$LUAV5"; then
     AC_MSG_WARN(Not Lua 5.x, SWIG does not support this version of Lua)
     LUABIN=""
   elif test -z "$LUAV51"; then
     AC_MSG_RESULT(Lua 5.0.x)
     # note: different versions of lua use different libs
     LUALIBRARY="-llua -llualib"
   else
     AC_MSG_RESULT(Lua 5.1 or later)
     # note: different versions of lua use different libs
     LUALIBRARY="-llua"
   fi
fi

if test "$LUABIN"; then
   AC_MSG_CHECKING(whether Lua dynamic loading is enabled)
   # using Lua to check Lua
   # lua 5.0 & 5.1 have different fn names
   if test -z "$LUAV51"; then
     LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=loadlib("no_such_lib","") if c~="absent" then print "1" end'`
   else
     LUADYNAMICLOADLIB=`$LUABIN -e '_,_,c=package.loadlib("no_such_lib","") if c~="absent" then print "1" end'`
   fi
   
   if test -z "$LUADYNAMICLOADLIB"; then 
     AC_MSG_RESULT(no)
   else
     AC_MSG_RESULT(yes)
   fi
fi

# look for the header files
AC_MSG_CHECKING(for Lua header files)
if test -z "$LUAINCLUDE"; then
#AC_TRY_CPP([#include <lua.h>], , LUAINCLUDE="")
AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <lua.h>]])], , LUAINCLUDE="")
if test -z "$LUAINCLUDE"; then
	dirs="/usr/local/include /usr/include /opt/local/include"
	for i in $dirs ; do
		if test -r $i/lua.h; then
			AC_MSG_RESULT($i)
			LUAINCLUDE="$ISYSTEM$i"
			break
		fi
	done
fi
fi
if test -z "$LUAINCLUDE"; then
    	AC_MSG_RESULT(not found)
else
        AC_MSG_RESULT($LUAINCLUDE)
fi

# look for the library files
AC_MSG_CHECKING(for Lua library)
if test -z "$LUALIB"; then
dirs="/usr/local/lib /usr/lib /opt/local/lib"
for i in $dirs ; do
	if test -r $i/liblua.a; then
	    AC_MSG_RESULT($i)
	    LUALIB="-L$i"
	    break
	fi
done
fi
if test -z "$LUALIB"; then
   AC_MSG_RESULT(not found)
else
   AC_MSG_RESULT($LUALIB)
fi

# copied from PYTHON code, but I think this is not needed for lua...
# Cygwin (Windows) needs the library for dynamic linking
#case $host in
#*-*-cygwin* | *-*-mingw*) LUADYNAMICLINKING="-L$LUALIB $PYLINK"
#         PYINCLUDE="-DUSE_DL_IMPORT $PYINCLUDE"
#         ;;
#*)LUADYNAMICLINKING="";;
#esac

fi # if not disabled

AC_SUBST(LUADYNAMICLINKING)
AC_SUBST(LUAINCLUDE)
AC_SUBST(LUALIB)
AC_SUBST(LUALIBRARY)
AC_SUBST(LUABIN)

#----------------------------------------------------------------
# Determine which languages to use for examples/test-suite
#----------------------------------------------------------------

SKIP_TCL=
if test -z "$TCLINCLUDE" || test -z "$TCLLIB" ; then
    SKIP_TCL="1"
fi
AC_SUBST(SKIP_TCL)


SKIP_PERL5=
if test -z "$PERL" || test -z "$PERL5EXT" ; then
    SKIP_PERL5="1"
fi
AC_SUBST(SKIP_PERL5)


SKIP_PYTHON=
if test -z "$PYINCLUDE" || test -z "$PYLIB" ; then
    SKIP_PYTHON="1"
fi
AC_SUBST(SKIP_PYTHON)


SKIP_JAVA=
if test -z "$JAVA" || test -z "$JAVAC" || test -z "$JAVAINC" ; then
    SKIP_JAVA="1"
fi
AC_SUBST(SKIP_JAVA)


SKIP_GUILE=
if test -z "$GUILEINCLUDE" || test -z "$GUILELIB" || test -z "$GUILE_GH_INTERFACE"; then
    SKIP_GUILE="1"
fi
AC_SUBST(SKIP_GUILE)

SKIP_GUILESCM=
if test -z "$GUILEINCLUDE" || test -z "$GUILELIB" || test -z "$GUILE_SCM_INTERFACE"; then
    SKIP_GUILESCM="1"
fi
AC_SUBST(SKIP_GUILESCM)


SKIP_MZSCHEME=
if test -z "$MZC" ; then
    SKIP_MZSCHEME="1"
fi
AC_SUBST(SKIP_MZSCHEME)


SKIP_RUBY=
if test -z "$RUBY" || test -z "$RUBYINCLUDE" || test -z "$RUBYLIB" ; then
    SKIP_RUBY="1"
fi
AC_SUBST(SKIP_RUBY)


SKIP_PHP4=
if test -z "$PHP4" || test -z "$PHP4INC" ; then
    SKIP_PHP4="1"
fi
AC_SUBST(SKIP_PHP4)


SKIP_OCAML=
if test -z "$OCAMLBIN" || test -z "$OCAMLINC" ; then
    SKIP_OCAML="1"
fi
AC_SUBST(SKIP_OCAML)


SKIP_PIKE="1" # Always skipped!
if test -z "$PIKE" || test -z "$PIKEINCLUDE" ; then
    SKIP_PIKE="1"
fi
AC_SUBST(SKIP_PIKE)


SKIP_CHICKEN=
if test -z "$CHICKEN" || test -z "$CHICKENHOME" || test -z "$CHICKENLIB" ; then
    SKIP_CHICKEN="1"
fi
AC_SUBST(SKIP_CHICKEN)


SKIP_CSHARP=
if test -z "$CSHARPCOMPILER" ; then
    SKIP_CSHARP="1"
else
    if test "cscc" = "$CSHARPCOMPILER" && test -z "$CSHARPCILINTERPRETER" ; then
      SKIP_CSHARP="1"
    fi
fi
AC_SUBST(SKIP_CSHARP)

SKIP_MODULA3="1" # Always skipped!
AC_SUBST(SKIP_MODULA3)

SKIP_LUA=
# do we really need the LUABIN?
if test -z "$LUABIN" || test -z "$LUAINCLUDE" || test -z "$LUALIB" || test -z "$LUADYNAMICLOADLIB"; then
    SKIP_LUA="1"
fi
AC_SUBST(SKIP_LUA)

#----------------------------------------------------------------
# Miscellaneous
#----------------------------------------------------------------

# Root directory
# Translate path for native Windows compilers for use with 'make check'
ROOT_DIR=`pwd`
case $host in
*-*-cygwin* | *-*-mingw*)
  if (cygpath --mixed $ROOT_DIR) >/dev/null 2>/dev/null; then
    ROOT_DIR=`cygpath --mixed $ROOT_DIR`
  fi
  # Extra files generated by some Windows compilers
  EXTRA_CLEAN="*.stackdump *.exp *.lib"
  ;;
esac

AC_SUBST(ROOT_DIR)
AC_SUBST(EXTRA_CLEAN)
AC_SUBST(ac_aux_dir)

# Configure SWIG_LIB path

AC_ARG_WITH(swiglibdir,[  --with-swiglibdir=DIR   Put SWIG system-independent libraries into DIR.],
  [swig_lib="$withval"], [swig_lib="${datadir}/swig/${PACKAGE_VERSION}"])
AC_SUBST(swig_lib)
AC_DEFINE_DIR(SWIG_LIB, swig_lib, [Directory for SWIG system-independent libraries])

# Configure RELEASESUFFIX (for setups having both SWIG 1.1 and 1.3 on a system...)

AC_ARG_WITH(release-suffix,
  [  --with-release-suffix=SUFFIX    Attach SUFFIX to the binary. ],
  [release_suffix="$withval"], [release_suffix=""])
AC_SUBST(release_suffix)
AC_DEFINE_UNQUOTED(RELEASE_SUFFIX, "$release_suffix", [Executable release suffix for co-existence with older versions])

AC_CONFIG_FILES([			        \
    Makefile				        \
    swig.spec				        \
    Source/Makefile			        \
    Examples/Makefile			        \
    Examples/guile/Makefile		        \
    Examples/GIFPlot/Makefile		        \
    Examples/GIFPlot/Lib/Makefile	        \
    Examples/test-suite/chicken/Makefile	\
    Examples/test-suite/csharp/Makefile	        \
    Examples/test-suite/guile/Makefile	        \
    Examples/test-suite/guilescm/Makefile	\
    Examples/test-suite/java/Makefile	        \
    Examples/test-suite/mzscheme/Makefile	\
    Examples/test-suite/ocaml/Makefile	        \
    Examples/test-suite/perl5/Makefile	        \
    Examples/test-suite/php4/Makefile	        \
    Examples/test-suite/pike/Makefile	        \
    Examples/test-suite/python/Makefile	        \
    Examples/test-suite/ruby/Makefile	        \
    Examples/test-suite/tcl/Makefile	        \
    Examples/test-suite/lua/Makefile	        \
])
AC_CONFIG_FILES([preinst-swig], [chmod +x preinst-swig])
AC_OUTPUT

dnl configure.in ends here