configure.ac

   1 dnl Process this file with autoconf to produce a configure script.
   2
   3 dnl If git is available, the version number here is not used.
   4 dnl Instead, git is used to derive the version based on the closest
   5 dnl annotated branch tag.
   6 dnl
   7 dnl Note: during Lisp-based builds (see INSTALL.lisp) the version
   8 dnl number is read from the following AC_INIT line.  It's sensitive to
   9 dnl whitespace so when updating the version number only make changes
  10 dnl within the second pair of square brackets.
  11 AC_INIT([maxima],[5.45post])
  12 AC_CONFIG_SRCDIR([src/macsys.lisp])
  13 AM_INIT_AUTOMAKE([-Wno-portability tar-ustar])
  14
  15 # On debian-based systems this makes us use the right gcl version out-of-the box.
  16 # On other systems it doesn't hurt.
  17 export GCL_ANSI=t
  18
  19 # This enables running the testbench for "make check" on gcl versions with the old
  20 # memory management (Which in January 2018 includes all Versions shipped with debian
  21 # and Ubuntu)
  22 export GCL_MEM_MULTIPLE=0.1
  23
  24 AM_PATH_LISPDIR
  25
  26 AC_CANONICAL_HOST
  27
  28 dnl If we were using a C compiler, EXEEXT would get defined
  29 dnl automatically. But we aren't, so we have to define it ourselves.
  30 dnl Still to do: Add Win64 support here, if this is needed.
  31 case "$host" in
  32         *mingw*)
  33                 win32=true
  34                 win64=false
  35                 mingw=true
  36                 EXEEXT=.exe
  37                 CLISPEXT=${EXEEXT}
  38                 ;;
  39         *cygwin*)
  40                 win32=false
  41                 win64=false
  42                 mingw=false
  43                 EXEEXT=.exe
  44                 CLISPEXT=${EXEEXT}
  45                 ;;
  46         *)
  47                 win32=false
  48                 win64=false
  49                 mingw=false
  50                 EXEEXT=
  51                 CLISPEXT=.run
  52 esac
  53 AC_SUBST(EXEEXT)
  54 AC_SUBST(win32)
  55 AC_SUBST(win64)
  56 AM_CONDITIONAL(WIN32, test x$win32 = xtrue)
  57 AM_CONDITIONAL(WIN64, test x$win64 = xtrue)
  58
  59 dnl To make life more confusing, the automake test machinery (which we
  60 dnl use in ./tests) needs the am__EXEEXT conditional. This would have
  61 dnl normally been expanded (via something we've copied from Automake's
  62 dnl init.m4 into our aclocal.m4) as Automake computed EXEEXT, but it
  63 dnl didn't so we have to drop this in ourselves.
  64 AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])
  65
  66 explicit_lisp=false
  67 lisps_enabled=""
  68
  69 dnl Compiling with abcl requires a jre and the path to abcl.jar
  70 AC_ARG_ENABLE(abcl,
  71         [  --enable-abcl                Use abcl, requires --with-abcl-jar],
  72         [case "${enableval}" in
  73                 yes) abcl=true
  74                      lisps_enabled="${lisps_enabled} abcl"
  75                      explicit_lisp=true ;;
  76                 no)  abcl=false ;;
  77                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-abcl) ;;
  78         esac
  79         explicit_lisp=true],
  80         [abcl=false])
  81 ABCL_JAR=`pwd`/"abcl.jar"
  82 AC_ARG_WITH(abcl-jar,
  83         [  --with-abcl-jar=<jarfile>    Use <jarfile> as abcl install (default ./abcl.jar)],
  84         [abcl=true
  85         lisps_enabled="${lisps_enabled} abcl"
  86         explicit_lisp=true
  87         ABCL_JAR="${withval}"])
  88
  89 AC_ARG_WITH(jre,
  90         [  --with-jre=<jre>             When compiling with abcl: use <jre> as Java interpreter],
  91         [JRE="${withval}"],
  92         [JRE="java"])
  93
  94 if test x"${abcl}" = xtrue ; then
  95      if test -e "${ABCL_JAR}" ; then
  96           echo Using abcl found in ${ABCL_JAR}
  97      else
  98         AC_MSG_ERROR(${ABCL_JAR} not found.)
  99      fi
 100 fi
 101
 102 dnl n.b. clisp_default_name is hardcoded in "with" message
 103 clisp_default_name=clisp
 104 AC_ARG_ENABLE(clisp,
 105         [  --enable-clisp               Use clisp],
 106         [case "${enableval}" in
 107                 yes) clisp=true
 108                      lisps_enabled="${lisps_enabled} clisp"
 109                      explicit_lisp=true ;;
 110                 no)  clisp=false ;;
 111                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-clisp) ;;
 112         esac
 113         explicit_lisp=true],
 114         [clisp=false])
 115 AC_ARG_WITH(clisp,
 116         [  --with-clisp=<prog>          Use clisp executable <prog> (default clisp)],
 117         [clisp=true
 118         lisps_enabled="${lisps_enabled} clisp"
 119         explicit_lisp=true
 120         if test "$withval" = "yes"; then
 121                 CLISP_NAME="${clisp_default_name}"
 122         else
 123                 CLISP_NAME="$withval"
 124         fi],
 125         [CLISP_NAME=${clisp_default_name}])
 126         CLISP_RUNTIME="lisp${CLISPEXT}"
 127 AC_ARG_WITH(clisp-runtime,
 128         [  --with-clisp-runtime=<path>  Use clisp runtime <path> (default
 129                                   *lib-directory*/base/lisp.run on unix,
 130                                   *lib-directory*\\lisp.exe on windows) ],
 131         [clisp=true
 132         lisps_enabled="${lisps_enabled} clisp"
 133         CLISP_RUNTIME_PATH="$withval"
 134         CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`],
 135         [])
 136 AC_ARG_ENABLE(clisp-exec,
 137         [  --enable-clisp-exec          Create a maxima executable image using CLISP.
 138                                 No check is made if the version of
 139                                 CLISP supports executable images],
 140         [case "${enableval}" in
 141             yes) clisp_exec=true
 142                  clisp=true
 143                  lisps_enabled="${lisps_enabled} clisp"
 144                  explicit_lisp=true ;;
 145             no) clisp_exec=false ;;
 146             *) AC_MSG_ERROR(bad value ${enableval} for --enable-clisp-exec) ;;
 147          esac
 148          CLISP_EXEC=${clisp_exec}],
 149         [clisp_exec=false
 150          CLISP_EXEC=false])
 151 if test x"${clisp}" = xtrue ; then
 152         if test `echo "$CLISP_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 153                 if test -x "$CLISP_NAME" ; then
 154                         clisp_found=true
 155                 else
 156                         clisp_found=false
 157                 fi
 158         else
 159                 AC_CHECK_PROG(clisp_found,$CLISP_NAME,true,false)
 160         fi
 161         if test x"${clisp_found}" = xfalse ; then
 162                 AC_MSG_WARN(clisp executable ${CLISP_NAME} not found in PATH)
 163         fi
 164 fi
 165
 166
 167 dnl See if git exists.  If it does, update VERSION to include a git tag
 168 AC_CHECK_PROG(git_found, git, true, false)
 169 if test x"${git_found}" = xtrue; then
 170     # Test to see if git describe works (discarding any output).  If
 171     # it works, use it.  Otherwise, keep existing value of VERSION.
 172     # (git describe fails if git is executed in a non-Git directory, e.g.,
 173     # an unpacked tarball. Since the exit codes of git describe are undocumented,
 174     # we cannot distinguish that from a missing annotated tag.
 175     # Play it safe by refusing to change VERSION.)
 176     if git describe > /dev/null 2>&1; then
 177         VERSION="`git describe --dirty`"
 178         # When building RPMs, hyphens in the version are not allowed, so
 179         # replace them with underscores.
 180         VERSION=`echo $VERSION | sed 's;-;_;g'`
 181     fi
 182 fi
 183
 184 dnl Parses the version number for the manual
 185 manual_version=`echo $VERSION | sed 's+branch_++; s+_base++; s+_dirty++; s+_+.+g'`
 186 AC_SUBST(manual_version)
 187
 188 dnl n.b. cmucl_default_name is hardcoded in "with" message
 189 cmucl_default_name=lisp
 190 CMUCL_RUNTIME=lisp
 191 AC_ARG_ENABLE(cmucl,
 192         [  --enable-cmucl               Use CMUCL],
 193         [case "${enableval}" in
 194                 yes) cmucl=true
 195                      lisps_enabled="${lisps_enabled} cmucl"
 196                      explicit_lisp=true ;;
 197                 no)  cmucl=false ;;
 198                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-cmucl) ;;
 199         esac
 200         explicit_lisp=true],
 201         [cmucl=false])
 202 AC_ARG_WITH(cmucl,
 203         [  --with-cmucl=<prog>          Use CMUCL executable <prog> (default lisp)],
 204         [cmucl=true
 205         lisps_enabled="${lisps_enabled} cmucl"
 206         explicit_lisp=true
 207         if test "$withval" = "yes"; then
 208                 CMUCL_NAME="${cmucl_default_name}"
 209         else
 210                 CMUCL_NAME="$withval"
 211         fi],
 212         [CMUCL_NAME=${cmucl_default_name}])
 213 AC_ARG_WITH(cmucl-runtime,
 214         [  --with-cmucl-runtime=<path>  Use CMUCL runtime <path> (default
 215                                   *cmucl-lib*/../bin/lisp)],
 216         [cmucl=true
 217         lisps_enabled="${lisps_enabled} cmucl"
 218         CMUCL_RUNTIME_PATH="$withval"
 219         CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`],
 220         [])
 221 AC_ARG_ENABLE(cmucl-exec,
 222         [  --enable-cmucl-exec          Create a maxima executable image using CMUCL.
 223                                 No check is made if the version of
 224                                 CMUCL supports executable images],
 225         [case "${enableval}" in
 226             yes) cmucl_exec=true
 227                  cmucl=true
 228                  lisps_enabled="${lisps_enabled} cmucl"
 229                  explicit_lisp=true ;;
 230             no) cmucl_exec=false ;;
 231             *) AC_MSG_ERROR(bad value ${enableval} for --enable-cmucl-exec) ;;
 232          esac
 233          CMUCL_EXEC=${cmucl_exec}],
 234         [cmucl_exec=false
 235          CMUCL_EXEC=false])
 236 if test x"${cmucl}" = xtrue ; then
 237         if test `echo "$CMUCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 238                 if test -x "$CMUCL_NAME" ; then
 239                         cmucl_found=true
 240                 else
 241                         cmucl_found=false
 242                 fi
 243         else
 244                 AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
 245         fi
 246         AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
 247         if test x"${cmucl_found}" = xfalse ; then
 248                 AC_MSG_WARN(cmucl executable ${CMUCL_NAME} not found in PATH)
 249         fi
 250 fi
 251
 252 dnl n.b. scl_default_name is hardcoded in "with" message
 253 scl_default_name=scl
 254 SCL_RUNTIME=lisp
 255 AC_ARG_ENABLE(scl,
 256         [  --enable-scl                 Use SCL],
 257         [case "${enableval}" in
 258                 yes) scl=true
 259                      lisps_enabled="${lisps_enabled} scl"
 260                      explicit_lisp=true ;;
 261                 no)  scl=false ;;
 262                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-scl) ;;
 263         esac
 264         explicit_lisp=true],
 265         [scl=false])
 266 AC_ARG_WITH(scl,
 267         [  --with-scl=<prog>            Use SCL executable <prog> (default scl)],
 268         [scl=true
 269         lisps_enabled="${lisps_enabled} scl"
 270         explicit_lisp=true
 271         if test "$withval" = "yes"; then
 272                 SCL_NAME="${scl_default_name}"
 273         else
 274                 SCL_NAME="$withval"
 275         fi],
 276         [SCL_NAME=${scl_default_name}])
 277 AC_ARG_WITH(scl-runtime,
 278         [  --with-scl-runtime=<path>    Use SCL runtime <path> (default
 279                                   file://library/../bin/lisp)],
 280         [scl=true
 281         lisps_enabled="${lisps_enabled} scl"
 282         SCL_RUNTIME_PATH="$withval"
 283         SCL_RUNTIME=`basename ${SCL_RUNTIME_PATH}`],
 284         [])
 285 if test x"${scl}" = xtrue ; then
 286         if test `echo "$SCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 287                 if test -x "$SCL_NAME" ; then
 288                         scl_found=true
 289                 else
 290                         scl_found=false
 291                 fi
 292         else
 293                 AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
 294         fi
 295         AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
 296         if test x"${scl_found}" = xfalse ; then
 297                 AC_MSG_WARN(scl executable ${SCL_NAME} not found in PATH)
 298         fi
 299 fi
 300
 301 dnl n.b. sbcl_default_name is hardcoded in "with" message
 302 sbcl_default_name=sbcl
 303 AC_ARG_ENABLE(sbcl,
 304         [  --enable-sbcl                Use SBCL],
 305         [case "${enableval}" in
 306                 yes) sbcl=true
 307                      lisps_enabled="${lisps_enabled} sbcl"
 308                      explicit_lisp=true ;;
 309                 no)  sbcl=false ;;
 310                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-sbcl) ;;
 311         esac
 312         explicit_lisp=true],
 313         [sbcl=false])
 314 AC_ARG_WITH(sbcl,
 315         [  --with-sbcl=<prog>           Use SBCL executable <prog> (default sbcl)],
 316         [sbcl=true
 317         lisps_enabled="${lisps_enabled} sbcl"
 318         explicit_lisp=true
 319         if test "$withval" = "yes"; then
 320                 SBCL_NAME="${sbcl_default_name}"
 321         else
 322                 SBCL_NAME="$withval"
 323         fi],
 324         [SBCL_NAME="${sbcl_default_name}"])
 325 AC_ARG_ENABLE(sbcl-exec,
 326         [  --enable-sbcl-exec           Create a maxima executable image using SBCL.
 327                                 No check is made if the version of
 328                                 SBCL supports executable images],
 329         [case "${enableval}" in
 330             yes) sbcl_exec=true
 331                  sbcl=true
 332                  lisps_enabled="${lisps_enabled} sbcl"
 333                  explicit_lisp=true ;;
 334             no) sbcl_exec=false ;;
 335             *) AC_MSG_ERROR(bad value ${enableval} for --enable-sbcl-exec) ;;
 336          esac
 337          SBCL_EXEC=${sbcl_exec}],
 338         [sbcl_exec=false
 339          SBCL_EXEC=false])
 340 if test x"${sbcl}" = xtrue ; then
 341         if test `echo "$SBCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 342                 if test -x "$SBCL_NAME" ; then
 343                         sbcl_found=true
 344                 else
 345                         sbcl_found=false
 346                 fi
 347         else
 348                 AC_CHECK_PROG(sbcl_found,"$SBCL_NAME",true,false)
 349         fi
 350         AC_CHECK_PROG(sbcl_found,"$SBCL_NAME",true,false)
 351         if test x"${sbcl_found}" = xfalse ; then
 352                 AC_MSG_WARN(sbcl executable "${SBCL_NAME}" not found in PATH)
 353         fi
 354 fi
 355
 356 dnl n.b. acl_default_name is hardcoded in "with" message
 357 acl_default_name=lisp
 358 AC_ARG_ENABLE(acl,
 359         [  --enable-acl                 Use ACL],
 360         [case "${enableval}" in
 361                 yes) acl=true
 362                      lisps_enabled="${lisps_enabled} acl"
 363                      explicit_lisp=true ;;
 364                 no)  acl=false ;;
 365                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-acl) ;;
 366         esac
 367         explicit_lisp=true],
 368         [acl=false])
 369 AC_ARG_WITH(acl,
 370         [  --with-acl=<prog>            Use ACL executable <prog> (default lisp)],
 371         [acl=true
 372         lisps_enabled="${lisps_enabled} acl"
 373         explicit_lisp=true
 374         if test "$withval" = "yes"; then
 375                 ACL_NAME="${acl_default_name}"
 376         else
 377                 ACL_NAME="$withval"
 378         fi],
 379         [ACL_NAME=${acl_default_name}])
 380 if test x"${acl}" = xtrue ; then
 381         if test `echo "$ACL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 382                 if test -x "$ACL_NAME" ; then
 383                         acl_found=true
 384                 else
 385                         acl_found=false
 386                 fi
 387         else
 388                 AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
 389         fi
 390         AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
 391         if test x"${acl_found}" = xfalse ; then
 392                 AC_MSG_WARN(acl executable ${ACL_NAME} not found in PATH)
 393         fi
 394 fi
 395
 396 dnl n.b. gcl_default_name is hardcoded in "with" message
 397 gcl_default_name=gcl
 398 AC_ARG_ENABLE(gcl,
 399         [  --enable-gcl                 Use GCL],
 400         [case "${enableval}" in
 401                 yes) gcl=true
 402                      lisps_enabled="${lisps_enabled} gcl"
 403                      explicit_lisp=true;;
 404                 no)  gcl=false ;;
 405                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl) ;;
 406         esac],
 407         [gcl=false])
 408 AC_ARG_WITH(gcl,
 409         [  --with-gcl=<prog>            Use GCL executable <prog> (default gcl)],
 410         [gcl=true
 411         lisps_enabled="${lisps_enabled} gcl"
 412         explicit_lisp=true
 413         if test "$withval" = "yes"; then
 414                 GCL_NAME="${gcl_default_name}"
 415         else
 416                 GCL_NAME="$withval"
 417         fi],
 418         [GCL_NAME=${gcl_default_name}])
 419 if test x"${gcl}" = xtrue ; then
 420         if test `echo "$GCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 421                 if test -x "$GCL_NAME" ; then
 422                         gcl_found=true
 423                 else
 424                         gcl_found=false
 425                 fi
 426         else
 427                 AC_CHECK_PROG(gcl_found,$GCL_NAME,true,false)
 428         fi
 429         if test x"${gcl_found}" = xfalse ; then
 430                 AC_MSG_WARN(gcl executable ${GCL_NAME} not found in PATH)
 431         fi
 432 fi
 433
 434 dnl n.b. openmcl_default_name is hardcoded in "with" message
 435 openmcl_default_name=openmcl
 436 AC_ARG_ENABLE(openmcl,
 437         [  --enable-openmcl             Use OpenMCL],
 438         [case "${enableval}" in
 439                 yes) openmcl=true
 440                      lisps_enabled="${lisps_enabled} openmcl"
 441                      explicit_lisp=true;;
 442                 no)  openmcl=false ;;
 443                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-openmcl) ;;
 444         esac],
 445         [openmcl=false])
 446 AC_ARG_WITH(openmcl,
 447         [  --with-openmcl=<prog>        Use OpenMCL executable <prog> (default openmcl)],
 448         [openmcl=true
 449         lisps_enabled="${lisps_enabled} openmcl"
 450         explicit_lisp=true
 451         if test "$withval" = "yes"; then
 452                 OPENMCL_NAME="${openmcl_default_name}"
 453         else
 454                 OPENMCL_NAME="$withval"
 455         fi],
 456         [OPENMCL_NAME=${openmcl_default_name}])
 457 AC_ARG_ENABLE(openmcl-exec,
 458         [  --enable-openmcl-exec        Create a maxima executable image using OPENMCL.
 459                                 No check is made if the version of
 460                                 OPENMCL supports executable images],
 461         [case "${enableval}" in
 462             yes) openmcl_exec=true
 463                  openmcl=true
 464                  lisps_enabled="${lisps_enabled} openmcl"
 465                  explicit_lisp=true;;
 466             no) openmcl_exec=false ;;
 467             *) AC_MSG_ERROR(bad value ${enableval} for --enable-openmcl-exec) ;;
 468          esac
 469          OPENMCL_EXEC=${openmcl_exec}],
 470         [openmcl_exec=false
 471          OPENMCL_EXEC=false])
 472
 473 dnl Define ccl as an alias (essentially) for openmcl
 474 AC_ARG_ENABLE(ccl,
 475         [  --enable-ccl                 Use CCL (Clozure Common Lisp)],
 476         [case "${enableval}" in
 477                 yes) openmcl=true
 478                      lisps_enabled="${lisps_enabled} openmcl"
 479                      explicit_lisp=true;;
 480                 no)  openmcl=false ;;
 481                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-ccl) ;;
 482         esac],
 483         [openmcl=false])
 484 AC_ARG_WITH(ccl,
 485         [  --with-ccl=<prog>            Use OpenMCL executable <prog> (default ccl)],
 486         [openmcl=true
 487         lisps_enabled="${lisps_enabled} openmcl"
 488         explicit_lisp=true
 489         if test "$withval" = "yes"; then
 490                 OPENMCL_NAME="${openmcl_default_name}"
 491         else
 492                 OPENMCL_NAME="$withval"
 493         fi],
 494         [OPENMCL_NAME=${openmcl_default_name}])
 495 AC_ARG_ENABLE(ccl-exec,
 496         [  --enable-ccl-exec            Create a maxima executable image using CCL.
 497                                 No check is made if the version of
 498                                 CCL supports executable images],
 499         [case "${enableval}" in
 500             yes) openmcl_exec=true
 501                  openmcl=true
 502                  lisps_enabled="${lisps_enabled} openmcl"
 503                  explicit_lisp=true;;
 504             no) openmcl_exec=false ;;
 505             *) AC_MSG_ERROR(bad value ${enableval} for --enable-ccl-exec) ;;
 506          esac
 507          OPENMCL_EXEC=${openmcl_exec}],
 508         [openmcl_exec=false
 509          OPENMCL_EXEC=false])
 510
 511 if test x"${openmcl}" = xtrue ; then
 512         if test `echo "$OPENMCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 513                 if test -x "$OPENMCL_NAME" ; then
 514                         openmcl_found=true
 515                 else
 516                         openmcl_found=false
 517                 fi
 518         else
 519                 AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
 520         fi
 521         if test x"${openmcl_found}" = xfalse ; then
 522                 AC_MSG_WARN(openmcl executable ${OPENMCL_NAME} not found in PATH)
 523         fi
 524 fi
 525
 526 dnl n.b. ccl64_default_name is hardcoded in "with" message
 527 dnl We assume we're running on an x86 processor.  The user has to
 528 dnl select a different executable name to match his system, if neceessary.
 529
 530 ccl64_default_name=dx86cl64
 531 AC_ARG_ENABLE(ccl64,
 532         [  --enable-ccl64               Use CCL (Clozure Common Lisp), 64-bit],
 533         [case "${enableval}" in
 534                 yes) ccl64=true
 535                      lisps_enabled="${lisps_enabled} ccl64"
 536                      explicit_lisp=true;;
 537                 no)  ccl64=false ;;
 538                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-ccl64) ;;
 539         esac],
 540         [ccl64=false])
 541 AC_ARG_WITH(ccl64,
 542         [  --with-ccl64=<prog>          Use ccl64 executable <prog> (default dx86cl64)],
 543         [ccl64=true
 544         lisps_enabled="${lisps_enabled} ccl64"
 545         explicit_lisp=true
 546         if test "$withval" = "yes"; then
 547                 CCL64_NAME="${ccl64_default_name}"
 548         else
 549                 CCL64_NAME="$withval"
 550         fi],
 551         [CCL64_NAME=${ccl64_default_name}])
 552 AC_ARG_ENABLE(ccl64-exec,
 553         [  --enable-ccl64-exec          Create a maxima executable image using CCL.
 554                                 No check is made if the version of
 555                                 CCL supports executable images],
 556         [case "${enableval}" in
 557             yes) ccl64_exec=true
 558                  ccl64=true
 559                  lisps_enabled="${lisps_enabled} ccl64"
 560                  explicit_lisp=true;;
 561             no) ccl64_exec=false ;;
 562             *) AC_MSG_ERROR(bad value ${enableval} for --enable-ccl64-exec) ;;
 563          esac
 564          CCL64_EXEC=${ccl64_exec}],
 565         [ccl64_exec=false
 566          CCL64_EXEC=false])
 567
 568 dnl n.b. ecl_default_name is hardcoded in "with" message
 569 ecl_default_name=ecl
 570 AC_ARG_ENABLE(ecl,
 571         [  --enable-ecl                 Use ECL],
 572         [case "${enableval}" in
 573                 yes) ecl=true
 574                      lisps_enabled="${lisps_enabled} ecl"
 575                      explicit_lisp=true;;
 576                 no)  ecl=false ;;
 577                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-ecl) ;;
 578         esac],
 579         [ecl=false])
 580 AC_ARG_WITH(ecl,
 581         [  --with-ecl=<prog>            Use ECL executable <prog> (default ecl)],
 582         [ecl=true
 583         lisps_enabled="${lisps_enabled} ecl"
 584         explicit_lisp=true
 585         if test "$withval" = "yes"; then
 586                 ECL_NAME="${ecl_default_name}"
 587         else
 588                 ECL_NAME="$withval"
 589         fi],
 590         [ECL_NAME=${ecl_default_name}])
 591 if test x"${ecl}" = xtrue ; then
 592         if test `echo "$ECL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
 593                 if test -x "$ECL_NAME" ; then
 594                         ecl_found=true
 595                 else
 596                         ecl_found=false
 597                 fi
 598         else
 599                 AC_CHECK_PROG(ecl_found,$ECL_NAME,true,false)
 600         fi
 601         if test x"${ecl_found}" = xfalse ; then
 602                 AC_MSG_WARN(ecl executable ${ECL_NAME} not found in PATH)
 603         fi
 604 fi
 605
 606 dnl xgettext
 607 AC_ARG_ENABLE(gettext,
 608         [  --enable-gettext             Locale support],
 609         [case "${enableval}" in
 610                yes) enable_gettext=true  ;;
 611                no)  enable_gettext=false ;;
 612                *) AC_MSG_ERROR(bad value ${enableval} for --enable-gettext) ;;
 613          esac],
 614          [enable_gettext=false])
 615
 616
 617 AM_CONDITIONAL(ENABLE_GETTEXT, test x$enable_gettext = xtrue)
 618
 619 AC_ARG_ENABLE(build-docs,
 620         [  --enable-build-docs        Execute make in doc directories],
 621         [case "${enableval}" in
 622                yes) enable_build_docs=true  ;;
 623                no)  enable_build_docs=false ;;
 624                *) AC_MSG_ERROR(bad value ${enableval} for --enable-build-docs) ;;
 625          esac],
 626          [enable_build_docs=true])
 627
 628
 629 AM_CONDITIONAL(ENABLE_BUILD_DOCS, test x$enable_build_docs = xtrue)
 630
 631 AC_CHECK_PROG(makeinfo_found,makeinfo,true,false)
 632
 633 if test x"${enable_build_docs}" = xtrue ; then
 634     if test x"${makeinfo_found}" = xfalse ; then
 635         AC_MSG_ERROR(No makeinfo found; consider --disable-build-docs)
 636     fi
 637 fi
 638
 639 dnl languages
 640 AC_ARG_ENABLE(lang-de,
 641         [  --enable-lang-de             German language support],
 642         [case "${enableval}" in
 643                 yes) lang_de=true  ;;
 644                 no)  lang_de=false ;;
 645                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-de) ;;
 646         esac],
 647         [lang_de=false])
 648
 649 AM_CONDITIONAL(LANG_DE, test x$lang_de = xtrue)
 650
 651 AC_ARG_ENABLE(lang-ja,
 652         [  --enable-lang-ja             Japanese language support],
 653         [case "${enableval}" in
 654                 yes) lang_ja=true  ;;
 655                 no)  lang_ja=false ;;
 656                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-ja) ;;
 657         esac],
 658         [lang_ja=false])
 659
 660 AM_CONDITIONAL(LANG_JA, test x$lang_ja = xtrue)
 661
 662 AC_ARG_ENABLE(lang-es,
 663         [  --enable-lang-es             Spanish language support],
 664         [case "${enableval}" in
 665                 yes) lang_es=true  ;;
 666                 no)  lang_es=false ;;
 667                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-es) ;;
 668         esac],
 669         [lang_es=false])
 670
 671 AC_SUBST(lang_es)
 672 AM_CONDITIONAL(LANG_ES, test x$lang_es = xtrue)
 673
 674 AC_ARG_ENABLE(lang-pt,
 675         [  --enable-lang-pt             Portuguese language support],
 676         [case "${enableval}" in
 677                 yes) lang_pt=true  ;;
 678                 no)  lang_pt=false ;;
 679                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt) ;;
 680         esac],
 681         [lang_pt=false])
 682
 683 AC_SUBST(lang_pt)
 684 AM_CONDITIONAL(LANG_PT, test x$lang_pt = xtrue)
 685
 686 AC_ARG_ENABLE(lang-pt_BR,
 687         [  --enable-lang-pt_BR          Brazilian Portuguese language support],
 688         [case "${enableval}" in
 689                 yes) lang_pt_br=true  ;;
 690                 no)  lang_pt_br=false ;;
 691                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt_BR) ;;
 692         esac],
 693         [lang_pt_br=false])
 694
 695 AC_SUBST(lang_pt_br)
 696 AM_CONDITIONAL(LANG_PT_BR, test x$lang_pt_br = xtrue)
 697
 698 AC_ARG_ENABLE(lang-ru,
 699         [  --enable-lang-ru             Russian language support],
 700         [case "${enableval}" in
 701                 yes) lang_ru=true  ;;
 702                 no)  lang_ru=false ;;
 703                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-ru) ;;
 704         esac],
 705         [lang_ru=false])
 706
 707 AM_CONDITIONAL(LANG_RU, test x$lang_ru = xtrue)
 708
 709 dnl Optionally build the windows CHM help files
 710 dnl default to false as requires win32 and Microsoft HTML Help Workshop
 711 AC_ARG_ENABLE(chm,
 712   [  --enable-chm                 Build Windows CHM help files],
 713   [case "${enableval}" in
 714                 yes) chm=true ;;
 715                 no)  chm=false ;;
 716                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-chm) ;;
 717    esac],
 718    [chm=false])
 719 AM_CONDITIONAL(CHM, test x$chm = xtrue)
 720 dnl hhc is the HTML Help Compiler for CHM documentation
 721 hhc_default_name=hhc$EXEEXT
 722 AC_ARG_WITH(hhc,
 723         [  --with-hhc=<prog>            Use HTML Help Compiler executable <prog> (default hhc)],
 724         [hhc=true
 725         if test "$withval" = "yes"; then
 726                 HHC="${hhc_default_name}"
 727         else
 728                 HHC="$withval"
 729         fi],
 730         [HHC="${hhc_default_name}"])
 731
 732 # Check that hhc exists, using AC_CHECK_PROG
 733 if test x$chm = xtrue; then
 734   if test -x "${HHC}"; then
 735     # HHC was a path to the executable, and it existed, which is
 736     # great! We still say something to the caller, since this is
 737     # probably less confusing.
 738     AC_MSG_CHECKING([for hhc])
 739     AC_MSG_RESULT([yes])
 740   else
 741     AC_CHECK_PROG(hhc_found, ${HHC}, yes)
 742     if test x"${hhc_found}" != x"yes"; then
 743       AC_MSG_ERROR([HTML Help Compiler executable ${HHC} not found])
 744     fi
 745   fi
 746 fi
 747
 748 dnl Make the build quiet
 749 AC_ARG_ENABLE(quiet_build,
 750   [  --enable-quiet-build         Make the build quieter],
 751   [case "${enableval}" in
 752      yes) quiet_build=true ;;
 753      no)  quiet_build=false ;;
 754      *) AC_MSG_ERROR(bad value ${enableval} for --enable-quiet-build) ;;
 755    esac],
 756   [quiet_build=false])
 757 AM_CONDITIONAL(QUIET_BUILD, test x${quiet_build} = xtrue)
 758
 759 dnl Optionally build xmaxima.exe under windows
 760 dnl default to false as additional software
 761 AC_ARG_ENABLE(xmaxima_exe,
 762   [  --enable-xmaxima-exe         Build Windows xmaxima.exe for installer],
 763   [case "${enableval}" in
 764                 yes) xmaxima_exe=true ;;
 765                 no)  xmaxima_exe=false ;;
 766                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-xmaxima-exe) ;;
 767    esac],
 768    [xmaxima_exe=false])
 769 AM_CONDITIONAL(XMAXIMA_EXE, test x$xmaxima_exe = xtrue)
 770
 771 dnl Optionally build xmaxima.exe under windows
 772 dnl default to false as additional software
 773 AC_ARG_ENABLE(winkill_exe,
 774   [  --enable-winkill             Build Windows winkill.exe and winkill_lib.dll for installer],
 775   [case "${enableval}" in
 776                 yes) winkill_exe=true ;;
 777                 no)  winkill_exe=false ;;
 778                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-winkill-exe) ;;
 779    esac],
 780    [winkill_exe=false])
 781 AM_CONDITIONAL(WINKILL_EXE, test x$winkill_exe = xtrue)
 782
 783 dnl Should we build a win64 installer?
 784 AC_ARG_ENABLE(win64-installer,
 785   [  --enable-win64-installer     Build a 64bit installer on Windows],
 786   [case "${enableval}" in
 787                 yes) win64_installer=true ;;
 788                 no) win64_installer=false ;;
 789                 *) AC_MSG_ERROR(bad valu ${enableval} for --enable-win64-installer) ;;
 790   esac],
 791   [win64_installer=false])
 792 AM_CONDITIONAL(WIN64_INSTALLER, test x$win64_installer = xtrue)
 793 AC_SUBST(win64_installer)
 794
 795 dnl Enable use of MathJax in the html documentation.  This just loads
 796 dnl MathJax in each html file.  The texi files need to put the
 797 dnl appropriate @html/@end html text to generate the equations for MathJax.
 798 AC_ARG_ENABLE(mathjax,
 799   [  --enable-mathjax             Enable MathJax support for html manual],
 800   [case "${enableval}" in
 801       yes) mathjax=true
 802            mathjax_enable='@set mathjax true'
 803            mathjax_script='<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.9/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>'
 804 ;;
 805       no)  mathjax=false
 806            mathjax_enable='@clear mathjax'
 807            mathjax_script="";;
 808       *) AC_MSG_ERROR(bad value ${enableval} for --enable-mathjax) ;;
 809    esac],
 810   [mathjax=false])
 811 AM_CONDITIONAL(MATHJAX, test x$mathjax = xtrue)
 812 AC_SUBST(mathjax_script)
 813 AC_SUBST(mathjax_enable)
 814
 815 dnl Tools for building xmaxima.exe on windows
 816 dnl Hard code the filenames for now.  Can over-ride on make command line
 817 GCCVER=undefined
 818 if test x${xmaxima_exe} = xtrue ; then
 819   GCCVER=`gcc -dumpversion`
 820   dnl http://tclkits.rkeene.org/fossil/wiki?name=Downloads
 821   dnl and http://www.tcl.tk/starkits/
 822   TCLKITSH=/c/programs/star/tclkitsh-8.6.3-win32-ix86.exe
 823   TCLKIT_RUNTIME=/c/programs/star/tclkit-8.6.3-win32-ix86.exe
 824   SDXKIT=/c/programs/star/sdx.kit
 825   IMGKIT=/c/programs/star/img.kit
 826 fi
 827
 828 AC_SUBST(GCCVER)
 829 AC_SUBST(TCLKITSH)
 830 AC_SUBST(TCLKIT_RUNTIME)
 831 AC_SUBST(SDXKIT)
 832 AC_SUBST(IMGKIT)
 833 AM_CONDITIONAL(GCC331, test x${GCCVER} = x3.3.1)
 834
 835 if test x"${explicit_lisp}" = xfalse ; then
 836         dnl See if any of the lisps can be found
 837         AC_CHECK_PROG(clisp_found,${clisp_default_name},true,false)
 838         AC_CHECK_PROG(gcl_found,${gcl_default_name},true,false)
 839         AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
 840         AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
 841         AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
 842         AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
 843         AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
 844         AC_CHECK_PROG(ccl64_found,$CCL64_NAME,true,false)
 845         AC_CHECK_PROG(ecl_found,$ECL_NAME,true,false)
 846
 847         if test x"${clisp_found}" = xtrue ; then
 848                 clisp=true
 849                 lisps_enabled="${lisps_enabled} clisp"
 850         elif test x"${gcl_found}" = xtrue ; then
 851                 gcl=true
 852                 lisps_enabled="${lisps_enabled} gcl"
 853         elif test x"${cmucl_found}" = xtrue ; then
 854                 cmucl=true
 855                 lisps_enabled="${lisps_enabled} cmucl"
 856         elif test x"${scl_found}" = xtrue ; then
 857                 scl=true
 858                 lisps_enabled="${lisps_enabled} scl"
 859         elif test x"${sbcl_found}" = xtrue ; then
 860                 sbcl=true
 861                 lisps_enabled="${lisps_enabled} sbcl"
 862         elif test x"${acl_found}" = xtrue ; then
 863                 acl=true
 864                 lisps_enabled="${lisps_enabled} acl"
 865         elif test x"${ecl_found}" = xtrue ; then
 866                 ecl=true
 867                 lisps_enabled="${lisps_enabled} ecl"
 868         else
 869                 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),${scl_default_name}(SCL),${sbcl_default_name}(SBCL),${acl_default_name}(ACL),${openmcl_default_name}(OpenMCL),${ecl_default_name}(ECL)] were found in PATH)
 870         fi
 871 fi
 872
 873 AM_CONDITIONAL(ABCL, test x$abcl = xtrue)
 874 AM_CONDITIONAL(CLISP, test x$clisp = xtrue)
 875 AM_CONDITIONAL(CLISP_EXEC, test x$clisp_exec = xtrue)
 876 AM_CONDITIONAL(GCL, test x$gcl = xtrue)
 877 AM_CONDITIONAL(CMUCL, test x$cmucl = xtrue)
 878 AM_CONDITIONAL(CMUCL_EXEC, test x${cmucl_exec} = xtrue)
 879 AM_CONDITIONAL(SCL, test x$scl = xtrue)
 880 AM_CONDITIONAL(SBCL, test x$sbcl = xtrue)
 881 AM_CONDITIONAL(SBCL_EXEC, test x$sbcl_exec = xtrue)
 882 AM_CONDITIONAL(ACL, test x$acl = xtrue)
 883 AM_CONDITIONAL(OPENMCL, test x$openmcl = xtrue)
 884 AM_CONDITIONAL(OPENMCL_EXEC, test x${openmcl_exec} = xtrue)
 885 AM_CONDITIONAL(ECL, test x$ecl = xtrue)
 886 AM_CONDITIONAL(CCL64, test x$ccl64 = xtrue)
 887 AM_CONDITIONAL(CCL64_EXEC, test x${ccl64_exec} = xtrue)
 888
 889 if test x"${clisp}" = xtrue; then
 890     if test x"${CLISP_RUNTIME_PATH}" = x"" ; then
 891         if test x"${mingw}" = xtrue ; then
 892             CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~a${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
 893         else
 894             CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~abase/${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
 895         fi
 896     fi
 897     if test -x ${CLISP_RUNTIME_PATH} ; then
 898         echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
 899     else
 900         AC_MSG_ERROR(clisp runtime "${CLISP_RUNTIME_PATH}" is not an executable)
 901     fi
 902     CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`
 903 fi
 904
 905 if test x"${cmucl}" = xtrue; then
 906     if test x"${CMUCL_RUNTIME_PATH}" = x"" ; then
 907         CMUCL_RUNTIME_PATH=`${CMUCL_NAME} -noinit -nositeinit -quiet -batch -eval '#-cmu18 (progn (setf (search-list "cmuclbin:") (append (lisp::parse-unix-search-path lisp::*cmucl-lib*) (mapcar (function (lambda (p) (concatenate (quote string) p "../bin/"))) (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)'`
 908     fi
 909     if test -x "${CMUCL_RUNTIME_PATH}" ; then
 910         echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
 911     else
 912 dnl last chance: find CMUCL_NAME in path. Use it if it doesn't appear to
 913 dnl be a shell script.
 914         cmucl_path=`type -p "${CMUCL_NAME}"`
 915         if test x"`grep -c '#!.*bin.*sh.*' ${cmucl_path}`" = x"0" ; then
 916                 CMUCL_RUNTIME_PATH="${cmucl_path}"
 917         else
 918                 AC_MSG_ERROR([Unable to determine CMUCL runtime path.
 919 The best guess for CMUCL runtime, "${CMUCL_RUNTIME_PATH}", is not
 920 an executable. Use the argument
 921    --with-cmucl-runtime=<path>
 922 to set the actual CMUCL executable. If the CMUCL lisp command is a shell
 923 script the CMUCL executable is the program exec'd by that shell script.])
 924         fi
 925     fi
 926     CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`
 927
 928 dnl cmucl final check
 929    result=`"${CMUCL_RUNTIME_PATH}" -quiet -eval '(format t "MAXIMA_CMUCL_TEST_SUCCESS%")(quit)'`
 930    retval=$?
 931    if test ! x"${retval}" = x"0" ; then
 932       AC_MSG_ERROR(unable to run cmucl runtime = "${CMUCL_RUNTIME_PATH}".
 933 Please specify the full path of the cmucl runtime using the
 934     --with-cmucl-runtime=<path>
 935 flag.)
 936    fi
 937    count=`echo "${result}" | grep -c "MAXIMA_CMUCL_TEST_SUCCESS"`
 938    if test ! "${count}" = "1" ; then
 939       AC_MSG_ERROR(an error occurred while checking cmucl runtime)
 940    fi
 941 fi
 942
 943 if test x"${scl}" = xtrue; then
 944     if test x"${SCL_RUNTIME_PATH}" = x"" ; then
 945         SCL_RUNTIME_PATH=`${SCL_NAME} -noinit -nositeinit -quiet -batch -eval '(progn (enumerate-pathname-translations (pathname "file://library/../bin/lisp") (when (probe-file pathname) (format t "~A~%" (unix-namestring pathname)))) (quit))'`
 946     fi
 947     if test -x "${SCL_RUNTIME_PATH}" ; then
 948         echo "scl runtime is \"${SCL_RUNTIME_PATH}\""
 949     else
 950 dnl last chance: find SCL_NAME in path. Use it if it doesn't appear to
 951 dnl be a shell script.
 952         scl_path=`type -p "${SCL_NAME}"`
 953         if test x"`grep -c '#!.*bin.*sh.*' ${scl_path}`" = x"0" ; then
 954                 SCL_RUNTIME_PATH="${scl_path}"
 955         else
 956                 AC_MSG_ERROR([Unable to determine SCL runtime path.
 957 The best guess for SCL runtime, "${SCL_RUNTIME_PATH}", is not
 958 an executable. Use the argument
 959    --with-scl-runtime=<path>
 960 to set the actual SCL executable. If the SCL lisp command is a shell
 961 script the SCL executable is the program exec'd by that shell script.])
 962         fi
 963     fi
 964     SCL_RUNTIME=`basename ${SCL_RUNTIME_PATH}`
 965 fi
 966
 967 if test x"${gcl}" = xtrue; then
 968    result=`"${GCL_NAME}" -batch -eval '#+ansi-cl (format t "MAXIMA_GCL_ANSI_TEST_SUCCESS~%") #-ansi-cl (format t "MAXIMA_GCL_ANSI_TEST_FAILURE~%")' -eval '(si::bye)'`
 969    retval=$?
 970    if test ! x"${retval}" = x"0" ; then
 971       AC_MSG_ERROR(unable to run gcl executable "${GCL_NAME}".)
 972    fi
 973    count=`echo "${result}" | grep -c "MAXIMA_GCL_ANSI_TEST_SUCCESS"`
 974    if test ! "${count}" = "1" ; then
 975       AC_MSG_ERROR([The gcl executable "${GCL_NAME}" was not compiled with
 976 the --enable-ansi flag, which is required for Maxima.
 977 The gcl ANSI-CL check returned
 978 "${result}".])
 979    fi
 980 fi
 981
 982 AC_ARG_ENABLE(gcl-alt-link,
 983         [  --enable-gcl-alt-link        Use GCL's alternate linking mechanism],
 984         [case "${enableval}" in
 985                 yes) gcl_alt_link=true ;;
 986                 no)  gcl_alt_link=false ;;
 987                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl-alt-link) ;;
 988         esac],
 989         [gcl_alt_link=false])
 990
 991 AM_CONDITIONAL(GCL_ALT_LINK, test x$gcl_alt_link = xtrue)
 992
 993 AC_ARG_WITH(default-lisp,
 994         [  --with-default-lisp=<lisp>   Set default lisp implementation to <lisp>],
 995         [case "${withval}" in
 996                 clisp)
 997                         if test x"${clisp}" = xtrue ; then
 998                                 DEFAULTLISP=clisp
 999                         else
1000                                 AC_MSG_ERROR(clisp not enabled)
1001                         fi
1002                         ;;
1003                 cmucl)
1004                         if test x"${cmucl}" = xtrue ; then
1005                                 DEFAULTLISP=cmucl
1006                         else
1007                                 AC_MSG_ERROR(cmucl not enabled)
1008                         fi
1009                         ;;
1010                 scl)
1011                         if test x"${scl}" = xtrue ; then
1012                                 DEFAULTLISP=scl
1013                         else
1014                                 AC_MSG_ERROR(scl not enabled)
1015                         fi
1016                         ;;
1017                 sbcl)
1018                         if test x"${sbcl}" = xtrue ; then
1019                                 DEFAULTLISP=sbcl
1020                         else
1021                                 AC_MSG_ERROR(sbcl not enabled)
1022                         fi
1023                         ;;
1024                 gcl)
1025                         if test x"${gcl}" = xtrue ; then
1026                                 DEFAULTLISP=gcl
1027                         else
1028                                 AC_MSG_ERROR(gcl not enabled)
1029                         fi
1030                         ;;
1031                 acl)
1032                         if test x"${acl}" = xtrue ; then
1033                                 DEFAULTLISP=acl
1034                         else
1035                                 AC_MSG_ERROR(acl not enabled)
1036                         fi
1037                         ;;
1038                 openmcl)
1039                         if test x"${openmcl}" = xtrue ; then
1040                                 DEFAULTLISP=openmcl
1041                         else
1042                                 AC_MSG_ERROR(openmcl not enabled)
1043                         fi
1044                         ;;
1045                 ecl)
1046                         if test x"${ecl}" = xtrue ; then
1047                                 DEFAULTLISP=ecl
1048                         else
1049                                 AC_MSG_ERROR(ecl not enabled)
1050                         fi
1051                         ;;
1052                 ccl64)
1053                         if test x"${ccl64}" = xtrue ; then
1054                                 DEFAULTLISP=ccl64
1055                         else
1056                                 AC_MSG_ERROR(ccl64 not enabled)
1057                         fi
1058                         ;;
1059                 abcl)
1060                         if test x"${abcl}" = xtrue ; then
1061                                 DEFAULTLISP=abcl
1062                         else
1063                                 AC_MSG_ERROR(abcl not enabled)
1064                         fi
1065                         ;;
1066                 *)
1067                         AC_MSG_ERROR(Unknown argument ${DEFAULTLISP} to --with-default-lisp)
1068                         ;;
1069         esac],
1070         [if test x"${sbcl}" = xtrue ; then
1071                 DEFAULTLISP=sbcl
1072         elif test x"${cmucl}" = xtrue ; then
1073                 DEFAULTLISP=cmucl
1074         elif test x"${scl}" = xtrue ; then
1075                 DEFAULTLISP=scl
1076         elif test x"${clisp}" = xtrue ; then
1077                 DEFAULTLISP=clisp
1078         elif test x"${gcl}" = xtrue ; then
1079                 DEFAULTLISP=gcl
1080         elif test x"${acl}" = xtrue ; then
1081                 DEFAULTLISP=acl
1082         elif test x"${openmcl}" = xtrue ; then
1083                 DEFAULTLISP=openmcl
1084         elif test x"${ecl}" = xtrue ; then
1085                 DEFAULTLISP=ecl
1086         elif test x"${ccl64}" = xtrue ; then
1087                 DEFAULTLISP=ccl64
1088         elif test x"${abcl}" = xtrue ; then
1089                 DEFAULTLISP=abcl
1090         else
1091                 AC_MSG_ERROR(Internal error. No lisp enabled. Please contact maintainer.)
1092         fi])
1093
1094 AC_SUBST(CLISP_NAME)
1095 AC_SUBST(CLISP_RUNTIME)
1096 AC_SUBST(CLISP_RUNTIME_PATH)
1097 AC_SUBST(CMUCL_NAME)
1098 AC_SUBST(CMUCL_RUNTIME)
1099 AC_SUBST(CMUCL_RUNTIME_PATH)
1100 AC_SUBST(CMUCL_EXEC)
1101 AC_SUBST(SCL_NAME)
1102 AC_SUBST(SCL_RUNTIME)
1103 AC_SUBST(SCL_RUNTIME_PATH)
1104 AC_SUBST(SBCL_NAME)
1105 AC_SUBST(GCL_NAME)
1106 AC_SUBST(ACL_NAME)
1107 AC_SUBST(OPENMCL_NAME)
1108 AC_SUBST(ECL_NAME)
1109 AC_SUBST(CCL64_NAME)
1110 AC_SUBST(DEFAULTLISP)
1111 AC_SUBST(HHC)
1112 AC_SUBST(lisps_enabled)
1113 AC_SUBST(ABCL_JAR)
1114 AC_SUBST(JRE)
1115
1116 AC_ARG_WITH(posix-shell,
1117         [  --with-posix-shell=<path>    Use <shell> for maxima script (default /bin/sh)],
1118         [posix_shell_list="${withval}"],
1119         [posix_shell_list="/bin/sh /bin/bash /usr/bin/bash /usr/local/bin/bash"])
1120
1121 AC_ARG_WITH(wish,
1122         [  --with-wish=<prog>           Use <prog> for Tk wish shell (default wish)],
1123         [WISH="${withval}"],
1124         [WISH="wish"])
1125 AC_SUBST(WISH)
1126
1127
1128 AC_MSG_CHECKING(POSIX shell to see that it contains getopts)
1129 cat <<EOF > conftest-posix-shell.sh
1130 getopts "ab:" opt
1131 result="\$?"
1132 echo "result is \$result"
1133 exit "\$result"
1134 EOF
1135 POSIX_SHELL=""
1136 for shell in $posix_shell_list
1137 do
1138         if test -z "$POSIX_SHELL" ; then
1139                 echo "trying $shell"
1140                 $shell conftest-posix-shell.sh -a > /dev/null 2>&1
1141                 if test "$?" = "0" ; then
1142                         POSIX_SHELL="$shell"
1143                 fi
1144         fi
1145 done
1146 rm -f conftest-posix-shell.sh
1147 if test -n "$POSIX_SHELL" ; then
1148         AC_MSG_RESULT(POSIX shell is $POSIX_SHELL)
1149 else
1150         AC_MSG_WARN(Could not find a shell that supports getopts.
1151 The maxima wrapper script will be unusable. The shell may be specified
1152 with --with-posix-shell=</path/to/shell>)
1153 fi
1154 AC_SUBST(POSIX_SHELL)
1155
1156 if test x"${prefix}" = xNONE ; then
1157         tmp_prefix="/usr/local"
1158 else
1159         tmp_prefix="${prefix}"
1160 fi
1161 if test x"${exec_prefix}" = xNONE ; then
1162         tmp_exec_prefix="${tmp_prefix}"
1163 else
1164         tmp_exec_prefix="${exec_prefix}"
1165 fi
1166 expanded_top_srcdir="$(cd "$top_srcdir" 1>/dev/null 2>/dev/null; pwd)"
1167 expanded_exec_prefix="${tmp_exec_prefix}"
1168 expanded_libdir="$(eval "exec_prefix=\"${tmp_exec_prefix}\";echo ${libdir}")"
1169 expanded_libexecdir="$(eval "exec_prefix=\"${tmp_exec_prefix}\";echo ${libexecdir}")"
1170 expanded_datadir="$(eval "prefix=\"${tmp_prefix}\";datarootdir=\"${datarootdir}\";echo ${datadir}")"
1171 expanded_infodir="$(eval "prefix=\"${tmp_prefix}\";datarootdir=\"${datarootdir}\";echo ${infodir}")"
1172
1173
1174 dnl Find all the directories in share, but remove the share directory
1175 dnl itself and all CVS directories (if any) and fortran directories
1176 dnl and *.t2p directories (created when generating pdf documentation).
1177 dnl Remove the leading "share" part of the path, and add double-quotes
1178 dnl around it.
1179
1180 #default_sharedirs=`find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\);        "\1" \\\\;' | sed '$s;\\\\;;'`
1181 default_sharedirs=`cd $srcdir;find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\);"\1";' | tr '\n' ' '`
1182
1183 AC_SUBST(top_srcdir)
1184 AC_SUBST(abs_top_builddir)
1185 AC_SUBST(abs_top_srcdir)
1186 AC_SUBST(top_builddir)
1187 AC_SUBST(expanded_top_srcdir)
1188 AC_SUBST(expanded_exec_prefix)
1189 AC_SUBST(expanded_libdir)
1190 AC_SUBST(expanded_libexecdir)
1191 AC_SUBST(expanded_datadir)
1192 AC_SUBST(expanded_infodir)
1193 default_layout_autotools="true"
1194 AC_SUBST(default_layout_autotools)
1195 AC_SUBST(LDFLAGS)
1196 AC_SUBST(default_sharedirs)
1197
1198 AC_ARG_WITH(emacs-prefix,
1199         [  --emacs-prefix=<path>        Where to install the emacs modes to],
1200         [EMACSDIR="$withval"],
1201         [EMACSDIR="${datarootdir}/emacs/site-lisp"])
1202 AC_SUBST(EMACSDIR)
1203
1204 dnl Tell defsystem that this isn't a lisp-only build
1205 lisp_only_build="nil"
1206 AC_SUBST(lisp_only_build)
1207 dnl Extra files we want to clean from the src dir
1208 if test x"$srcdir" = x"." ; then
1209    DISTCLEAN_EXTRA_SRC_FILES=""
1210 else
1211    DISTCLEAN_EXTRA_SRC_FILES=share_subdirs.lisp
1212 fi
1213 AC_SUBST(DISTCLEAN_EXTRA_SRC_FILES)
1214
1215
1216 dnl Look for grep that can handle long lines and -e.
1217 AC_PROG_EGREP
1218 AC_SUBST(EGREP)
1219 AC_PATH_PROG([CAT],[cat])
1220 AC_PROG_SED
1221 AC_PROG_AWK
1222 AC_SUBST(SED)
1223
1224 # Configure these files and make them executable
1225 AC_CONFIG_FILES([maxima-local], chmod +x maxima-local)
1226 AC_CONFIG_FILES([src/startmaxima_abcl.sh], chmod +x src/startmaxima_abcl.sh)
1227 AC_CONFIG_FILES([xmaxima-local], chmod +x xmaxima-local)
1228 AC_CONFIG_FILES([tests/test.sh], chmod +x tests/test.sh)
1229 AC_CONFIG_FILES([doc/info/build_html.sh], chmod +x doc/info/build_html.sh)
1230 AC_CONFIG_FILES([doc/info/de/build_html.sh], chmod +x doc/info/de/build_html.sh)
1231 AC_CONFIG_FILES([doc/info/ja/build_html.sh], chmod +x doc/info/ja/build_html.sh)
1232 AC_CONFIG_FILES([src/maxima], chmod +x src/maxima)
1233 AC_CONFIG_FILES([src/maxima.bat])
1234
1235 AC_CONFIG_FILES([Makefile maxima.spec maxima.iss \
1236 admin/Makefile src/Makefile src/rmaxima src/autoconf-variables.lisp \
1237 src/share-subdirs_autogenerated.lisp \
1238 lisp-utils/Makefile tests/Makefile doc/Makefile \
1239 crosscompile-windows/Makefile \
1240 doc/emaxima/Makefile doc/info/Makefile doc/info/include-maxima.texi \
1241 desktopintegration/Makefile \
1242 doc/info/category-macros.texi \
1243 doc/info/texi2html.init \
1244 doc/info/figures/Makefile \
1245 doc/info/de/Makefile \
1246 doc/info/es/Makefile \
1247 doc/info/ja/Makefile \
1248 doc/info/ja/include-maxima.texi \
1249 doc/info/pt/Makefile \
1250 doc/info/pt/include-maxima.texi \
1251 doc/info/pt_BR/Makefile \
1252 doc/info/ru/Makefile \
1253 doc/intromax/Makefile doc/man/Makefile doc/man/maxima.1 doc/man/ru/Makefile doc/man/ru/maxima.1 doc/man/de/Makefile doc/man/de/maxima.1 \
1254 doc/share/Makefile interfaces/Makefile interfaces/emacs/Makefile \
1255 interfaces/emacs/emaxima/Makefile interfaces/emacs/imaxima/Makefile \
1256 interfaces/emacs/misc/Makefile interfaces/xmaxima/Makefile \
1257 interfaces/xmaxima/autoconf-variables.tcl interfaces/xmaxima/Tkmaxima/Header.tcl \
1258 interfaces/xmaxima/doc/Makefile interfaces/xmaxima/doc/figures/Makefile \
1259 interfaces/xmaxima/msgs/Makefile interfaces/xmaxima/win32/Makefile \
1260 plotting/mgnuplot share/Makefile demo/Makefile plotting/Makefile locale/Makefile \
1261 share/contrib/Makefile share/contrib/integration/Makefile \
1262 share/contrib/maxima-odesolve/Makefile \
1263 share/contrib/symplectic_ode/Makefile \
1264 share/draw/Makefile share/logic/Makefile  doc/info/es/include-maxima.texi \
1265 src/lisp])
1266 AC_OUTPUT
1267
1268 # The default of 4096 is sometimes too little for the test suite.
1269 if test x"${sbcl}" = xtrue ; then
1270    AC_MSG_CHECKING(Testing if sbcl complains if we try to enlarge the thread-local storage)
1271    echo "(quit)" | ${SBCL_NAME} --tls-limit 8192 > /dev/null 2>&1
1272    if test "$?" = "0" ; then
1273         SBCL_EXTRA_ARGS="--tls-limit 8192"
1274         AC_MSG_RESULT(Yes)
1275    else
1276         SBCL_EXTRA_ARGS=""
1277         AC_MSG_RESULT(No)
1278    fi
1279 fi
1280 AC_SUBST(SBCL_EXTRA_ARGS)
1281
1282 if test x"${clisp}" = xtrue ; then
1283         echo
1284         AC_MSG_WARN("CLISP 2.49 is known to sporadically produce garbled data if the front-end is fast enough to acknowledge a data packet while a next data packet is still being prepared.")
1285 fi
1286 echo
1287 echo "Summary:"
1288 if test x"${clisp}" = xtrue ; then
1289         echo "Compiling a maxima image using \"${CLISP_NAME}\"",
1290         echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
1291         if test x"${clisp_exec}" = xtrue ; then
1292                 echo "clisp executable image enabled for maxima."
1293         else
1294                 echo Use "--enable-clisp-exec to build a standalone executable instead."
1295         fi
1296 fi
1297 if test x"${cmucl}" = xtrue ; then
1298         echo "Compiling a maxima image using \"${CMUCL_NAME}\""
1299         echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
1300         if test x"${cmucl_exec}" = xtrue; then
1301                 echo "CMUCL executable image enabled for maxima."
1302         else
1303                 echo Use "--enable-cmucl-exec to build a standalone executable instead."
1304         fi
1305 fi
1306 if test x"${scl}" = xtrue ; then
1307         echo "SCL enabled, using \"${SCL_NAME}\""
1308         echo "SCL runtime is \"${SCL_RUNTIME_PATH}\""
1309 fi
1310 if test x"${sbcl}" = xtrue ; then
1311         echo "Compiling a maxima image using \"${SBCL_NAME}\""
1312         if test x"${sbcl_exec}" = xtrue ; then
1313                 echo "sbcl executable image enabled for maxima."
1314         else
1315                 echo Use "--enable-sbcl-exec to build a standalone executable instead."
1316         fi
1317 fi
1318 if test x"${gcl}" = xtrue ; then
1319         echo "Compiling a maxima image using \"${GCL_NAME}\""
1320         if test x"${gcl_alt_link}" = xtrue ; then
1321                 echo "    GCL alternative linking method enabled."
1322         fi
1323 fi
1324 if test x"${acl}" = xtrue ; then
1325         echo "ACL enabled. Executable name: \"${ACL_NAME}\""
1326 fi
1327 if test x"${openmcl}" = xtrue ; then
1328         echo "Compiling a maxima image using \"${OPENMCL_NAME}\""
1329         if test x"${openmcl_exec}" = xtrue ; then
1330                 echo "OpenMCL executable image enabled for maxima."
1331         else
1332                 echo Use "--enable-openmcl-exec to build a standalone executable instead."
1333         fi
1334 fi
1335 if test x"${ccl64}" = xtrue ; then
1336         echo "Compiling a maxima image using \"${CCL64_NAME}\""
1337         if test x"${ccl64_exec}" = xtrue ; then
1338                 echo "CCL64 executable image enabled for maxima."
1339         else
1340                 echo Use "--enable-ccl64-exec to build a standalone executable instead."
1341         fi
1342 fi
1343
1344 if test x"${ecl}" = xtrue ; then
1345         if test x"$srcdir" = x"." ; then
1346                 echo "Compiling maxima using \"${ECL_NAME}\""
1347         else
1348                 echo "ECL enabled. Executable name: \"${ECL_NAME}\""
1349                 AC_MSG_ERROR(For ECL out-of-tree builds aren't supported. See src/maxima.system for details.)
1350         fi
1351 fi
1352
1353 if test x"${abcl}" = xtrue ; then
1354         if test x"$srcdir" = x"." ; then
1355                 echo "Compiling maxima using \"${ABCL_JAR}\""
1356         else
1357                 echo "ABCL enabled. ABCL jarfile: \"${ABCL_JAR}\""
1358                 AC_MSG_ERROR(For ABCL out-of-tree builds aren't supported. See src/maxima.system for details.)
1359         fi
1360 fi
1361
1362 echo "default lisp: $DEFAULTLISP"
1363 echo "wish executable name: \"${WISH}\""
1364
1365 if test x"${chm}" = xtrue ; then
1366   echo "CHM help files enabled"
1367   echo "  HHC: \"${HHC}\""
1368 fi
1369 if test x"${xmaxima_exe}" = xtrue ; then
1370    echo "Windows xmaxima.exe enabled"
1371    echo "  GCC version GCCVER: ${GCCVER}"
1372    echo "  TCLKITSH: ${TCLKITSH}"
1373    if ! test -f "${TCLKITSH}" ; then
1374      AC_MSG_WARN(*** TCLKITSH ${TCLKITSH} not found)
1375      xmaxima_exe_prerequisite=notfound
1376    fi
1377    echo "  TCLKIT_RUNTIME: ${TCLKIT_RUNTIME}"
1378    if ! test -f "${TCLKIT_RUNTIME}" ; then
1379      AC_MSG_WARN(*** TCLKIT_RUNTIME ${TCLKIT_RUNTIME} not found)
1380      xmaxima_exe_prerequisite=notfound
1381    fi
1382    echo "  SDXKIT: ${SDXKIT}"
1383    if ! test -f "${SDXKIT}" ; then
1384      AC_MSG_WARN(*** SDXKIT ${SDXKIT} not found)
1385      xmaxima_exe_prerequisite=notfound
1386    fi
1387    echo "  IMGKIT: ${IMGKIT}"
1388    if ! test -f "${IMGKIT}" ; then
1389      AC_MSG_WARN(*** IMGKIT ${IMGKIT} not found)
1390      xmaxima_exe_prerequisite=notfound
1391    fi
1392    if test x${xmaxima_exe_prerequisite} = xnotfound ; then
1393      AC_MSG_WARN([A prerequisite for xmaxima.exe not found.  The missing components can be defined on the make command line.])
1394    fi
1395 fi