dnl Process this file with autoconf to produce a configure script.

AC_INIT(src/macsys.lisp)

AM_INIT_AUTOMAKE(maxima,5.9.1)
AC_CANONICAL_HOST
case "$host" in
        *mingw*)
                win32=true
                mingw=true 
                ;;
        *cygwin*)
                win32=true
                mingw=false
                ;;
        *)
                win32=false
                mingw=false
esac
AC_SUBST(win32)
AM_CONDITIONAL(WIN32, test x$win32 = xtrue)

explicit_lisp=false

dnl n.b. clisp_default_name is hardcoded in "with" message
clisp_default_name=clisp
AC_ARG_ENABLE(clisp,[  --enable-clisp                   Use clisp],
     	[case "${enableval}" in
       		yes) clisp=true 
                     explicit_lisp=true ;;
       		no)  clisp=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-clisp) ;;
     	esac
	explicit_lisp=true],
	[clisp=false])
AC_ARG_WITH(clisp,
	[  --with-clisp=<prog>              Use clisp executable <prog> (default clisp)],
	[clisp=true
	explicit_lisp=true
	if test "$withval" = "yes"; then
		CLISP_NAME="${clisp_default_name}"
	else
		CLISP_NAME="$withval"
	fi],
	[CLISP_NAME=${clisp_default_name}])
if test x"${win32}" = x"true" ; then
   	CLISP_RUNTIME="lisp.exe"
else
	CLISP_RUNTIME="lisp.run"
fi
AC_ARG_WITH(clisp-runtime,
	[  --with-clisp-runtime=<path>	   Use clisp runtime <path> (default
	                             *lib-directory*/base/lisp.run on unix,
	   		             *lib-directory*\\lisp.exe on windows) ],
	[clisp=true
	CLISP_RUNTIME_PATH="$withval"
	CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`],
	[])
if test x"${clisp}" = xtrue ; then
	if test `echo "$CLISP_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
		if test -x "$CLISP_NAME" ; then
			clisp_found=true
		else
			clisp_found=false
		fi
	else
		AC_CHECK_PROG(clisp_found,$CLISP_NAME,true,false)
	fi
	if test x"${clisp_found}" = xfalse ; then
		AC_MSG_WARN(clisp executable ${CLISP_NAME} not found in PATH)
	fi	   
fi

dnl n.b. cmucl_default_name is hardcoded in "with" message
cmucl_default_name=lisp
CMUCL_RUNTIME=lisp
AC_ARG_ENABLE(cmucl,[  --enable-cmucl                   Use CMUCL],
     	[case "${enableval}" in
       		yes) cmucl=true 
                     explicit_lisp=true ;;
       		no)  cmucl=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-cmucl) ;;
     	esac
	explicit_lisp=true],
	[cmucl=false])
AC_ARG_WITH(cmucl,
	[  --with-cmucl=<prog>              Use CMUCL executable <prog> (default lisp)],
	[cmucl=true
	explicit_lisp=true
	if test "$withval" = "yes"; then
		CMUCL_NAME="${cmucl_default_name}"
	else
		CMUCL_NAME="$withval"
	fi],
	[CMUCL_NAME=${cmucl_default_name}])
AC_ARG_WITH(cmucl-runtime,
	[  --with-cmucl-runtime=<path>	   Use CMUCL runtime <path> (default
	                             *cmucl-lib*/../bin/lisp)],
	[cmucl=true
	CMUCL_RUNTIME_PATH="$withval"
	CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`],
	[])
if test x"${cmucl}" = xtrue ; then
	if test `echo "$CMUCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
		if test -x "$CMUCL_NAME" ; then
			cmucl_found=true
		else
			cmucl_found=false
		fi
	else
		AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
	fi
	AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
	if test x"${cmucl_found}" = xfalse ; then
		AC_MSG_WARN(cmucl executable ${CMUCL_NAME} not found in PATH)
	fi
fi

dnl n.b. sbcl_default_name is hardcoded in "with" message
sbcl_default_name=sbcl
AC_ARG_ENABLE(sbcl,[  --enable-sbcl                    Use SBCL],
     	[case "${enableval}" in
       		yes) sbcl=true 
                     explicit_lisp=true ;;
       		no)  sbcl=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-sbcl) ;;
     	esac
	explicit_lisp=true],
	[sbcl=false])
AC_ARG_WITH(sbcl,
	[  --with-sbcl=<prog>               Use SBCL executable <prog> (default sbcl)],
	[sbcl=true
	explicit_lisp=true
	if test "$withval" = "yes"; then
		SBCL_NAME="${sbcl_default_name}"
	else
		SBCL_NAME="$withval"
	fi],
	[SBCL_NAME=${sbcl_default_name}])
if test x"${sbcl}" = xtrue ; then
	if test `echo "$SBCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
		if test -x "$SBCL_NAME" ; then
			sbcl_found=true
		else
			sbcl_found=false
		fi
	else
		AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
	fi
	AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
	if test x"${sbcl_found}" = xfalse ; then
		AC_MSG_WARN(sbcl executable ${SBCL_NAME} not found in PATH)
	fi
fi
	
dnl n.b. acl6_default_name is hardcoded in "with" message
acl6_default_name=lisp
AC_ARG_ENABLE(acl6,[  --enable-acl6                    Use ACL 6],
     	[case "${enableval}" in
       		yes) acl6=true 
                     explicit_lisp=true ;;
       		no)  acl6=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-acl6) ;;
     	esac
	explicit_lisp=true],
	[acl6=false])
AC_ARG_WITH(acl6,
	[  --with-acl6=<prog>               Use ACL6 executable <prog> (default lisp)],
	[acl6=true
	explicit_lisp=true
	if test "$withval" = "yes"; then
		ACL6_NAME="${acl6_default_name}"
	else
		ACL6_NAME="$withval"
	fi],
	[ACL6_NAME=${acl6_default_name}])
if test x"${acl6}" = xtrue ; then
	if test `echo "$ACL6_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
		if test -x "$ACL6_NAME" ; then
			acl6_found=true
		else
			acl6_found=false
		fi
	else
		AC_CHECK_PROG(acl6_found,$ACL6_NAME,true,false)
	fi
	AC_CHECK_PROG(acl6_found,$ACL6_NAME,true,false)
	if test x"${acl6_found}" = xfalse ; then
		AC_MSG_WARN(acl6 executable ${ACL6_NAME} not found in PATH)
	fi
fi

dnl n.b. gcl_default_name is hardcoded in "with" message
gcl_default_name=gcl
AC_ARG_ENABLE(gcl,[  --enable-gcl                     Use GCL],
     	[case "${enableval}" in
       		yes) gcl=true 
		     explicit_lisp=true;;
       		no)  gcl=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl) ;;
     	esac],
	[gcl=false])
AC_ARG_WITH(gcl,
	[  --with-gcl=<prog>                Use GCL executable <prog> (default gcl)],
	[gcl=true
	explicit_lisp=true
	if test "$withval" = "yes"; then
		GCL_NAME="${gcl_default_name}"
	else
		GCL_NAME="$withval"
	fi],
	[GCL_NAME=${gcl_default_name}])
if test x"${gcl}" = xtrue ; then
	if test `echo "$GCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
		if test -x "$GCL_NAME" ; then
			gcl_found=true
		else
			gcl_found=false
		fi
	else
		AC_CHECK_PROG(gcl_found,$GCL_NAME,true,false)
	fi
	if test x"${gcl_found}" = xfalse ; then
		AC_MSG_WARN(gcl executable ${GCL_NAME} not found in PATH)
	fi
fi

dnl n.b. openmcl_default_name is hardcoded in "with" message
openmcl_default_name=openmcl
AC_ARG_ENABLE(openmcl,[  --enable-openmcl                 Use OpenMCL],
     	[case "${enableval}" in
       		yes) openmcl=true 
		     explicit_lisp=true;;
       		no)  openmcl=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-openmcl) ;;
     	esac],
	[openmcl=false])
AC_ARG_WITH(openmcl,
	[  --with-openmcl=<prog>            Use OpenMCL executable <prog> (default openmcl)],
	[openmcl=true
	explicit_lisp=true
	if test "$withval" = "yes"; then
		OPENMCL_NAME="${openmcl_default_name}"
	else
		OPENMCL_NAME="$withval"
	fi],
	[OPENMCL_NAME=${openmcl_default_name}])
if test x"${openmcl}" = xtrue ; then
	if test `echo "$OPENMCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
		if test -x "$OPENMCL_NAME" ; then
			openmcl_found=true
		else
			openmcl_found=false
		fi
	else
		AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
	fi
	if test x"${openmcl_found}" = xfalse ; then
		AC_MSG_WARN(openmcl executable ${OPENMCL_NAME} not found in PATH)
	fi
fi

if test x"${explicit_lisp}" = xfalse ; then
dnl  	AC_CHECK_PROG(clisp_found,${clisp_default_name},true,false)
dnl  	if test x"${clisp_found}" = xtrue ; then
dnl  		clisp=true
dnl  	else
dnl  		AC_CHECK_PROG(gcl_found,${gcl_default_name},true,false)
dnl  		if test x"${gcl_found}" = xtrue ; then
dnl  			gcl=true
dnl  		else
dnl  			AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
dnl  			if test x"${cmucl_found}" = xtrue ; then
dnl  				cmucl=true
dnl  			else
dnl  				AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
dnl  				if test x"${sbcl_found}" = xtrue ; then
dnl  				   	sbcl=true
dnl  				else
dnl  					AC_CHECK_PROG(acl6_found,$ACL6_NAME,true,false)
dnl  					if test x"${acl6_found}" = xtrue ; then
dnl  						acl6=true
dnl  					else
dnl  						AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
dnl  						if test x"${openmcl_found}" = xtrue ; then
dnl  							openmcl=true
dnl  						else
dnl  							AC_MSG_ERROR(No lisp implementation specified and none of the default executables [${clisp_default_name}(clisp),${gcl_default_name}(GCL),${cmucl_default_name}(CMUCL),${sbcl_default_name}(SBCL),${acl6_default_name}(ACL6),${openmcl_default_name}(OpenMCL)] were found in PATH)
dnl  						fi
dnl  					fi
dnl  				fi
dnl  			fi
dnl  		fi
dnl  	fi
	dnl See if any of the lisps can be found
  	AC_CHECK_PROG(clisp_found,${clisp_default_name},true,false)
	AC_CHECK_PROG(gcl_found,${gcl_default_name},true,false)
	AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
	AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
	AC_CHECK_PROG(acl6_found,$ACL6_NAME,true,false)
	AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)

  	if test x"${clisp_found}" = xtrue ; then
  		clisp=true
  	elif test x"${gcl_found}" = xtrue ; then
		gcl=true
	elif test x"${cmucl_found}" = xtrue ; then
		cmucl=true
	elif test x"${sbcl_found}" = xtrue ; then
	   	sbcl=true
	elif test x"${acl6_found}" = xtrue ; then
		acl6=true
	elif test x"${openmcl_found}" = xtrue ; then
		openmcl=true
	else
		AC_MSG_ERROR(No lisp implementation specified and none of the default executables [${clisp_default_name}(clisp),${gcl_default_name}(GCL),${cmucl_default_name}(CMUCL),${sbcl_default_name}(SBCL),${acl6_default_name}(ACL6),${openmcl_default_name}(OpenMCL)] were found in PATH)
	fi
fi

AM_CONDITIONAL(CLISP, test x$clisp = xtrue)
AM_CONDITIONAL(GCL, test x$gcl = xtrue)
AM_CONDITIONAL(CMUCL, test x$cmucl = xtrue)
AM_CONDITIONAL(SBCL, test x$sbcl = xtrue)
AM_CONDITIONAL(ACL6, test x$acl6 = xtrue)
AM_CONDITIONAL(OPENMCL, test x$openmcl = xtrue)

if test x"${clisp}" = xtrue; then
    if test x"${CLISP_RUNTIME_PATH}" = x"" ; then
        if test x"${mingw}" = xtrue ; then
            CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~a${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
        else
            CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~abase/${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
        fi
    fi
    if test -x ${CLISP_RUNTIME_PATH} ; then
        echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
    else
        AC_MSG_ERROR(clisp runtime \"${CLISP_RUNTIME_PATH}\" is not an executable)
    fi
    CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`
fi

if test x"${cmucl}" = xtrue; then
    if test x"${CMUCL_RUNTIME_PATH}" = x"" ; then
        CMUCL_RUNTIME_PATH=`${CMUCL_NAME} -noinit -nositeinit -quiet -batch -eval '#+cmu19 (progn (setf (search-list "cmuclbin:") (lisp::parse-unix-search-path lisp::*cmucl-lib*)) (enumerate-search-list (s "cmuclbin:lisp") (when (probe-file s) (format t "~A~%" s) (quit)))) #+cmu18 (format t "~a/../bin/lisp~%" common-lisp::*cmucl-lib*)(quit)'`
    fi
    if test -x ${CMUCL_RUNTIME_PATH} ; then
        echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
    else
dnl last chance: find CMUCL_NAME in path. Use it if it doesn't appear to
dnl be a shell script.
	cmucl_path=`type -p "${CMUCL_NAME}"`
	if test x"`grep -c '#!.*bin.*sh.*' ${cmucl_path}`" = x"0" ; then
	   	CMUCL_RUNTIME_PATH="${cmucl_path}"
	else
		AC_MSG_ERROR(Unable to determine CMUCL runtime path.
The best guess for CMUCL runtime \"${CMUCL_RUNTIME_PATH}\" is not
an executable. Use the argument
   --with-cmucl-runtime=<path>
to set the actual CMUCL executable. If the CMUCL lisp command is a shell
script the CMUCL executable is the program exec'd by that shell script.)
	fi
    fi
    CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`
fi

AC_ARG_ENABLE(gcl-alt-link,
	[  --enable-gcl-alt-link            Use GCL's alternate linking mechanism],
     	[case "${enableval}" in
       		yes) gcl_alt_link=true ;;
       		no)  gcl_alt_link=false ;;
		*) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl-alt-link) ;;
     	esac],
	[gcl_alt_link=false])

AM_CONDITIONAL(GCL_ALT_LINK, test x$gcl_alt_link = xtrue)
	
AC_ARG_WITH(default-lisp,
	[  --with-default-lisp=<lisp>       Set default lisp implementation to <lisp>],
     	[case "${withval}" in
       		clisp)
			if test x"${clisp}" = xtrue ; then
				DEFAULTLISP=clisp
			else
				AC_MSG_ERROR(clisp not enabled)
			fi
			;;
		cmucl)
			if test x"${cmucl}" = xtrue ; then
				DEFAULTLISP=cmucl
			else
				AC_MSG_ERROR(cmucl not enabled)
			fi
			;;
		sbcl)
			if test x"${sbcl}" = xtrue ; then
				DEFAULTLISP=sbcl
			else
				AC_MSG_ERROR(sbcl not enabled)
			fi
			;;
		gcl)
			if test x"${gcl}" = xtrue ; then
				DEFAULTLISP=gcl
			else
				AC_MSG_ERROR(gcl not enabled)
			fi
			;;	
		acl6)
			if test x"${acl6}" = xtrue ; then
				DEFAULTLISP=acl6
			else
				AC_MSG_ERROR(acl6 not enabled)
			fi
			;;	
		openmcl)
			if test x"${openmcl}" = xtrue ; then
				DEFAULTLISP=openmcl
			else
				AC_MSG_ERROR(openmcl not enabled)
			fi
			;;		
		*) 
			AC_MSG_ERROR(Unknown argument ${DEFAULTLISP} to --with-default-lisp) 
			;;
     	esac],
	[if test x"${clisp}" = xtrue ; then
		DEFAULTLISP=clisp
	elif test x"${cmucl}" = xtrue ; then
		DEFAULTLISP=cmucl
	elif test x"${sbcl}" = xtrue ; then
	   	DEFAULTLISP=sbcl
	elif test x"${gcl}" = xtrue ; then
	   	DEFAULTLISP=gcl
	elif test x"${acl6}" = xtrue ; then
		DEFAULTLISP=acl6
	elif test x"${openmcl}" = xtrue ; then
		DEFAULTLISP=openmcl
	else
		AC_MSG_ERROR(Internal error. No lisp enabled. Please contact maintainer.)
	fi])

AC_SUBST(CLISP_NAME)
AC_SUBST(CLISP_RUNTIME)
AC_SUBST(CLISP_RUNTIME_PATH)
AC_SUBST(CMUCL_NAME)
AC_SUBST(CMUCL_RUNTIME)
AC_SUBST(CMUCL_RUNTIME_PATH)
AC_SUBST(SBCL_NAME)
AC_SUBST(GCL_NAME)
AC_SUBST(ACL6_NAME)
AC_SUBST(OPENMCL_NAME)
AC_SUBST(DEFAULTLISP)

AC_ARG_WITH(posix-shell,
	[  --with-posix-shell=</path/to/shell>    Use <shell> for maxima script (default /bin/sh)],
	[posix_shell_list="${withval}"],
	[posix_shell_list="/bin/sh /bin/bash /usr/bin/bash /usr/local/bin/bash"])

AC_ARG_WITH(wish,
	[  --with-wish=<prog>               Use <prog> for Tk wish shell (default wish)],
	[WISH="${withval}"],
	[WISH="wish"])
AC_SUBST(WISH)


AC_MSG_CHECKING(POSIX shell to see that it contains getopts)
cat <<EOF > conftest-posix-shell.sh
getopts "ab:" opt
result="\$?"
echo "result is \$result"
exit "\$result"
EOF
POSIX_SHELL=""
for shell in $posix_shell_list
do
	if test -z "$POSIX_SHELL" ; then
		echo "trying $shell"
		$shell conftest-posix-shell.sh -a > /dev/null 2>&1
		if test "$?" = "0" ; then
			POSIX_SHELL="$shell"
		fi
	fi
done
rm -f conftest-posix-shell.sh
if test -n "$POSIX_SHELL" ; then
	AC_MSG_RESULT(POSIX shell is $POSIX_SHELL)
else
	AC_MSG_WARN(Could not find a shell that supports getopts. 
The maxima wrapper script will be unusable. The shell may be specified
with --with-posix-shell=</path/to/shell>)
fi
AC_SUBST(POSIX_SHELL)

if test x"${prefix}" = xNONE ; then
	tmp_prefix="/usr/local"
else
	tmp_prefix="${prefix}"
fi
if test x"${exec_prefix}" = xNONE ; then
	tmp_exec_prefix="${tmp_prefix}"
else
	tmp_exec_prefix="${exec_prefix}"
fi
expanded_top_srcdir="`(cd \"$top_srcdir\" 1>/dev/null 2>/dev/null; pwd)`"
expanded_exec_prefix="${tmp_exec_prefix}"
expanded_libdir="`eval \"exec_prefix=${tmp_exec_prefix};echo ${libdir}\"`"
expanded_libexecdir="`eval \"exec_prefix=${tmp_exec_prefix};echo ${libexecdir}\"`"
expanded_datadir="`eval \"prefix=${tmp_prefix};echo ${datadir}\"`"
expanded_infodir="`eval \"prefix=${tmp_prefix};echo ${infodir}\"`"

AC_SUBST(expanded_top_srcdir)
AC_SUBST(expanded_exec_prefix)
AC_SUBST(expanded_libdir)
AC_SUBST(expanded_libexecdir)
AC_SUBST(expanded_datadir)
AC_SUBST(expanded_infodir)
default_layout_autotools="true"
AC_SUBST(default_layout_autotools)

AC_OUTPUT(Makefile maxima-local xmaxima-local maxima.spec maxima.iss src/Makefile src/maxima src/maxima.bat src/rmaxima src/autoconf-variables.lisp lisp-utils/Makefile tests/Makefile doc/Makefile doc/emaxima/Makefile doc/info/Makefile doc/intromax/Makefile doc/man/Makefile doc/man/maxima.1 doc/share/Makefile interfaces/Makefile interfaces/emacs/Makefile interfaces/emacs/emaxima/Makefile interfaces/emacs/misc/Makefile interfaces/xmaxima/Makefile interfaces/xmaxima/autoconf-variables.tcl interfaces/xmaxima/Tkmaxima/Header.tcl interfaces/xmaxima/win32/Makefile plotting/header.tcl plotting/mgnuplot share/Makefile demo/Makefile plotting/Makefile)

chmod +x maxima-local
chmod +x xmaxima-local

echo
echo "Summary:"
if test x"${clisp}" = xtrue ; then
	echo "clisp enabled. Executable name: \"${CLISP_NAME}\""
	echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
fi
if test x"${cmucl}" = xtrue ; then
	echo "CMUCL enabled. Executable name: \"${CMUCL_NAME}\""
	echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
fi
if test x"${sbcl}" = xtrue ; then
	echo "SBCL enabled. Executable name: \"${SBCL_NAME}\""
fi
if test x"${gcl}" = xtrue ; then
	echo "GCL enabled. Executable name: \"${GCL_NAME}\""
	if test x"${gcl_alt_link}" = xtrue ; then
		echo "    GCL alternative linking method enabled."
	fi
fi
if test x"${acl6}" = xtrue ; then
	echo "ACL6 enabled. Executable name: \"${ACL6_NAME}\""
fi
if test x"${openmcl}" = xtrue ; then
	echo "OpenMCL enabled. Executable name: \"${OPENMCL_NAME}\""
fi
echo "default lisp: $DEFAULTLISP"
echo "wish executable name: \"${WISH}\""