Correct typo in Texinfo: cdf_tributions --> distributions
[maxima/cygwin.git] / configure.ac
blobcc035d5e1ed444460dcb4150f97decdf34000340
1 dnl Process this file with autoconf to produce a configure script.
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.47post])
12 AC_CONFIG_SRCDIR([src/macsys.lisp])
13 AM_INIT_AUTOMAKE([-Wno-portability tar-ustar])
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
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
24 AM_PATH_LISPDIR
26 AC_CANONICAL_HOST
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)
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"])
66 explicit_lisp=false
67 lisps_enabled=""
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"])
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
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         
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
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)
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
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
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
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
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
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])
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])
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
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.
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])
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
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])
617 AM_CONDITIONAL(ENABLE_GETTEXT, test x$enable_gettext = xtrue)
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])
629 AM_CONDITIONAL(ENABLE_BUILD_DOCS, test x$enable_build_docs = xtrue)
631 AC_CHECK_PROG(makeinfo_found,makeinfo,true,false)
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
638     dnl Check the version number.  First get the first line from
639     dnl 'makeinfo --version' and extract out the version digits.
640     makeinfo_old=false
641     if test x"${makeinfo_found}" = xtrue; then
642         AC_MSG_CHECKING([if makeinfo version >= 5.1])
643         dnl expr is looking for something like "junk<digits-or-dots>"
644         dnl assuming that the end of the version string contains the
645         dnl version number consisting of digits separated by a period.
646         dnl This allows for version numbers like 6.8.90.
647         makeinfo_version_string=`expr "\`makeinfo --version | head -1\`" : '.* \([[.0-9]]\+\)'`
648         dnl echo Makeinfo version ${makeinfo_version}
650         dnl From makeinfo_version, extract out the major and minor
651         dnl version numbers.  We only need the major and minor version
652         dnl numbers.
653         makeinfo_major=`expr $makeinfo_version_string : '\([[0-9]]\+\)'`
654         makeinfo_minor=`expr $makeinfo_version_string : '[[0-9]]\+\.\([[0-9]]\+\)'`
655         dnl echo major ${makeinfo_major}
656         dnl echo minor ${makeinfo_minor}
658         dnl Create a numerical version number by multiplying the major
659         dnl version by 100 and adding the minor version.  This assumes
660         dnl the minor version is always less than or equal to 99.
661         makeinfo_version=`expr ${makeinfo_major} \* 100 \+ ${makeinfo_minor}`
662         
663         dnl If version is older than 5.1, it's too old for generating
664         dnl maxima docs.
665         if test ${makeinfo_version} -lt 501; then
666             AC_MSG_ERROR([Makeinfo version (${makeinfo_version_string}) too old; consider --disable-build-docs])
667         else
668             AC_MSG_RESULT([${makeinfo_version_string} (6.8 or later preferred)])
669         fi
671         dnl Makeinfo version 7.0 and later needs a different init
672         dnl file.  Figure which one to use, and also substitute this
673         dnl value in build_html.sh.in.
674         if test ${makeinfo_version} -ge 700; then
675             TEXI2HTML=texi2html-7.init
676         else
677             TEXI2HTML=texi2html.init
678         fi
679         AC_SUBST(TEXI2HTML)
681         dnl If the makeinfo version is older than 6.8, we need to
682         dnl include MathJax ourselves when building the HTML files.
683         need_mathjax=false
684         if test ${makeinfo_version} -lt 608; then
685             need_mathjax=true
686         fi
687         if test x"${need_mathjax}" = xtrue; then
688             dnl Need to include Mathjax.
689             NEED_MATHJAX='<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>'
690             dnl This also means that makeinfo doesn't support
691             dnl @displaymath, so we need to do something else.
692             NO_DISPLAYMATH='true'
693             AC_SUBST(NEED_MATHJAX)
694             AC_SUBST(NO_DISPLAYMATH)
695         fi
696     fi
699 dnl languages
700 AC_ARG_ENABLE(lang-de,
701         [  --enable-lang-de             German language support],
702         [case "${enableval}" in
703                 yes) lang_de=true  ;;
704                 no)  lang_de=false ;;
705                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-de) ;;
706         esac],
707         [lang_de=false])
709 AM_CONDITIONAL(LANG_DE, test x$lang_de = xtrue)
711 AC_ARG_ENABLE(lang-ja,
712         [  --enable-lang-ja             Japanese language support],
713         [case "${enableval}" in
714                 yes) lang_ja=true  ;;
715                 no)  lang_ja=false ;;
716                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-ja) ;;
717         esac],
718         [lang_ja=false])
720 AM_CONDITIONAL(LANG_JA, test x$lang_ja = xtrue)
722 AC_ARG_ENABLE(lang-es,
723         [  --enable-lang-es             Spanish language support],
724         [case "${enableval}" in
725                 yes) lang_es=true  ;;
726                 no)  lang_es=false ;;
727                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-es) ;;
728         esac],
729         [lang_es=false])
731 AC_SUBST(lang_es)
732 AM_CONDITIONAL(LANG_ES, test x$lang_es = xtrue)
734 AC_ARG_ENABLE(lang-pt,
735         [  --enable-lang-pt             Portuguese language support],
736         [case "${enableval}" in
737                 yes) lang_pt=true  ;;
738                 no)  lang_pt=false ;;
739                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt) ;;
740         esac],
741         [lang_pt=false])
743 AC_SUBST(lang_pt)
744 AM_CONDITIONAL(LANG_PT, test x$lang_pt = xtrue)
746 AC_ARG_ENABLE(lang-pt_BR,
747         [  --enable-lang-pt_BR          Brazilian Portuguese language support],
748         [case "${enableval}" in
749                 yes) lang_pt_br=true  ;;
750                 no)  lang_pt_br=false ;;
751                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt_BR) ;;
752         esac],
753         [lang_pt_br=false])
755 AC_SUBST(lang_pt_br)
756 AM_CONDITIONAL(LANG_PT_BR, test x$lang_pt_br = xtrue)
758 AC_ARG_ENABLE(lang-ru,
759         [  --enable-lang-ru             Russian language support],
760         [case "${enableval}" in
761                 yes) lang_ru=true  ;;
762                 no)  lang_ru=false ;;
763                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-ru) ;;
764         esac],
765         [lang_ru=false])
767 AM_CONDITIONAL(LANG_RU, test x$lang_ru = xtrue)
769 dnl Optionally build the windows CHM help files
770 dnl default to false as requires win32 and Microsoft HTML Help Workshop
771 AC_ARG_ENABLE(chm,
772   [  --enable-chm                 Build Windows CHM help files],
773   [case "${enableval}" in
774                 yes) chm=true ;;
775                 no)  chm=false ;;
776                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-chm) ;;
777    esac],
778    [chm=false])
779 AM_CONDITIONAL(CHM, test x$chm = xtrue)
780 dnl hhc is the HTML Help Compiler for CHM documentation
781 hhc_default_name=hhc$EXEEXT
782 AC_ARG_WITH(hhc,
783         [  --with-hhc=<prog>            Use HTML Help Compiler executable <prog> (default hhc)],
784         [hhc=true
785         if test "$withval" = "yes"; then
786                 HHC="${hhc_default_name}"
787         else
788                 HHC="$withval"
789         fi],
790         [HHC="${hhc_default_name}"])
792 # Check that hhc exists, using AC_CHECK_PROG
793 if test x$chm = xtrue; then
794   if test -x "${HHC}"; then
795     # HHC was a path to the executable, and it existed, which is
796     # great! We still say something to the caller, since this is
797     # probably less confusing.
798     AC_MSG_CHECKING([for hhc])
799     AC_MSG_RESULT([yes])
800   else
801     AC_CHECK_PROG(hhc_found, ${HHC}, yes)
802     if test x"${hhc_found}" != x"yes"; then
803       AC_MSG_ERROR([HTML Help Compiler executable ${HHC} not found])
804     fi
805   fi
808 dnl Make the build quiet
809 AC_ARG_ENABLE(quiet_build,
810   [  --enable-quiet-build         Make the build quieter],
811   [case "${enableval}" in
812      yes) quiet_build=true ;;
813      no)  quiet_build=false ;;
814      *) AC_MSG_ERROR(bad value ${enableval} for --enable-quiet-build) ;;
815    esac],
816   [quiet_build=false])
817 AM_CONDITIONAL(QUIET_BUILD, test x${quiet_build} = xtrue)
819 dnl Optionally build xmaxima.exe under windows
820 dnl default to false as additional software
821 AC_ARG_ENABLE(xmaxima_exe,
822   [  --enable-xmaxima-exe         Build Windows xmaxima.exe for installer],
823   [case "${enableval}" in
824                 yes) xmaxima_exe=true ;;
825                 no)  xmaxima_exe=false ;;
826                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-xmaxima-exe) ;;
827    esac],
828    [xmaxima_exe=false])
829 AM_CONDITIONAL(XMAXIMA_EXE, test x$xmaxima_exe = xtrue)
831 dnl Optionally build xmaxima.exe under windows
832 dnl default to false as additional software
833 AC_ARG_ENABLE(winkill_exe,
834   [  --enable-winkill             Build Windows winkill.exe and winkill_lib.dll for installer],
835   [case "${enableval}" in
836                 yes) winkill_exe=true ;;
837                 no)  winkill_exe=false ;;
838                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-winkill-exe) ;;
839    esac],
840    [winkill_exe=false])
841 AM_CONDITIONAL(WINKILL_EXE, test x$winkill_exe = xtrue)
843 dnl Should we build a win64 installer?
844 AC_ARG_ENABLE(win64-installer,
845   [  --enable-win64-installer     Build a 64bit installer on Windows],
846   [case "${enableval}" in
847                 yes) win64_installer=true ;;
848                 no) win64_installer=false ;;
849                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-win64-installer) ;;
850   esac],
851   [win64_installer=false])
852 AM_CONDITIONAL(WIN64_INSTALLER, test x$win64_installer = xtrue)
853 AC_SUBST(win64_installer)
855 dnl Tools for building xmaxima.exe on windows
856 dnl Hard code the filenames for now.  Can over-ride on make command line
857 GCCVER=undefined
858 if test x${xmaxima_exe} = xtrue ; then
859   GCCVER=`gcc -dumpversion`
860   dnl http://tclkits.rkeene.org/fossil/wiki?name=Downloads
861   dnl and https://www.tcl.tk/starkits/
862   TCLKITSH=/c/programs/star/tclkitsh-8.6.3-win32-ix86.exe
863   TCLKIT_RUNTIME=/c/programs/star/tclkit-8.6.3-win32-ix86.exe
864   SDXKIT=/c/programs/star/sdx.kit
865   IMGKIT=/c/programs/star/img.kit
868 AC_SUBST(GCCVER)
869 AC_SUBST(TCLKITSH)
870 AC_SUBST(TCLKIT_RUNTIME)
871 AC_SUBST(SDXKIT)
872 AC_SUBST(IMGKIT)
873 AM_CONDITIONAL(GCC331, test x${GCCVER} = x3.3.1)
875 if test x"${explicit_lisp}" = xfalse ; then
876         dnl See if any of the lisps can be found
877         AC_CHECK_PROG(clisp_found,${clisp_default_name},true,false)
878         AC_CHECK_PROG(gcl_found,${gcl_default_name},true,false)
879         AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
880         AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
881         AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
882         AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
883         AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
884         AC_CHECK_PROG(ccl64_found,$CCL64_NAME,true,false)
885         AC_CHECK_PROG(ecl_found,$ECL_NAME,true,false)
887         if test x"${clisp_found}" = xtrue ; then
888                 clisp=true
889                 lisps_enabled="${lisps_enabled} clisp"
890         fi
891         if test x"${gcl_found}" = xtrue ; then
892            AC_MSG_CHECKING([if gcl version >= 2.6.13])
893            dnl       Check gcl version
894            GCL_VERSION=`${GCL_NAME} -eval '(princ (lisp-implementation-version))' -batch | sed 's/GCL \([[0-9.]]\+\).*/\1/'`
895         Â´  dnl echo GCL version = $GCL_VERSION
896            dnl Assume GCL_VERSION looks like p.q.r where p, q, and r are
897            dnl digits.  Then extract each set of digits to get the numbers to
898            dnl create a version number for comparison.
899            gcl_major=`expr $GCL_VERSION : '\([[0-9]]\+\)'`
900            gcl_minor=`expr $GCL_VERSION : '[[0-9]]\+\.\([[0-9]]\+\)'`
901            gcl_sub=`expr $GCL_VERSION : '[[0-9]]\+\.[[0-9]]\+\.\([[0-9]]\+\)'`
902            gcl_version=`expr ${gcl_major} \* 10000 \+ ${gcl_minor} \* 100 \+ ${gcl_sub}`
903            if test ${gcl_version} -lt 20613; then
904                    AC_MSG_RESULT([GCL autodetected, but its version ${GCL_VERSION} is too old])
905            else
906                    gcl=true
907                    lisps_enabled="${lisps_enabled} gcl"
908            fi
909         fi
910         if test x"${cmucl_found}" = xtrue ; then
911                 cmucl=true
912                 lisps_enabled="${lisps_enabled} cmucl"
913         fi
914         if test x"${scl_found}" = xtrue ; then
915                 scl=true
916                 lisps_enabled="${lisps_enabled} scl"
917         fi
918         if test x"${sbcl_found}" = xtrue ; then
919                 sbcl=true
920                 lisps_enabled="${lisps_enabled} sbcl"
921         fi
922         if test x"${acl_found}" = xtrue ; then
923                 acl=true
924                 lisps_enabled="${lisps_enabled} acl"
925         fi
926         if test x"${ecl_found}" = xtrue ; then
927                 ecl=true
928                 lisps_enabled="${lisps_enabled} ecl"
929         fi
930         if test x"${lisps_enabled}" = x; then
931                 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)
932         fi
935 AM_CONDITIONAL(ABCL, test x$abcl = xtrue)
936 AM_CONDITIONAL(CLISP, test x$clisp = xtrue)
937 AM_CONDITIONAL(CLISP_EXEC, test x$clisp_exec = xtrue)
938 AM_CONDITIONAL(GCL, test x$gcl = xtrue)
939 AM_CONDITIONAL(CMUCL, test x$cmucl = xtrue)
940 AM_CONDITIONAL(CMUCL_EXEC, test x${cmucl_exec} = xtrue)
941 AM_CONDITIONAL(SCL, test x$scl = xtrue)
942 AM_CONDITIONAL(SBCL, test x$sbcl = xtrue)
943 AM_CONDITIONAL(SBCL_EXEC, test x$sbcl_exec = xtrue)
944 AM_CONDITIONAL(ACL, test x$acl = xtrue)
945 AM_CONDITIONAL(OPENMCL, test x$openmcl = xtrue)
946 AM_CONDITIONAL(OPENMCL_EXEC, test x${openmcl_exec} = xtrue)
947 AM_CONDITIONAL(ECL, test x$ecl = xtrue)
948 AM_CONDITIONAL(CCL64, test x$ccl64 = xtrue)
949 AM_CONDITIONAL(CCL64_EXEC, test x${ccl64_exec} = xtrue)
951 if test x"${clisp}" = xtrue; then
952     if test x"${CLISP_RUNTIME_PATH}" = x"" ; then
953         if test x"${mingw}" = xtrue ; then
954             CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~a${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
955         else
956             CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~abase/${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
957         fi
958     fi
959     if test -x ${CLISP_RUNTIME_PATH} ; then
960         echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
961     else
962         AC_MSG_ERROR(clisp runtime "${CLISP_RUNTIME_PATH}" is not an executable)
963     fi
964     CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`
967 if test x"${cmucl}" = xtrue; then
968     if test x"${CMUCL_RUNTIME_PATH}" = x"" ; then
969         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)'`
970     fi
971     if test -x "${CMUCL_RUNTIME_PATH}" ; then
972         echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
973     else
974 dnl last chance: find CMUCL_NAME in path. Use it if it doesn't appear to
975 dnl be a shell script.
976         cmucl_path=`type -p "${CMUCL_NAME}"`
977         if test x"`grep -c '#!.*bin.*sh.*' ${cmucl_path}`" = x"0" ; then
978                 CMUCL_RUNTIME_PATH="${cmucl_path}"
979         else
980                 AC_MSG_ERROR([Unable to determine CMUCL runtime path.
981 The best guess for CMUCL runtime, "${CMUCL_RUNTIME_PATH}", is not
982 an executable. Use the argument
983    --with-cmucl-runtime=<path>
984 to set the actual CMUCL executable. If the CMUCL lisp command is a shell
985 script the CMUCL executable is the program exec'd by that shell script.])
986         fi
987     fi
988     CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`
990 dnl cmucl final check
991    result=`"${CMUCL_RUNTIME_PATH}" -quiet -eval '(format t "MAXIMA_CMUCL_TEST_SUCCESS%")(quit)'`
992    retval=$?
993    if test ! x"${retval}" = x"0" ; then
994       AC_MSG_ERROR(unable to run cmucl runtime = "${CMUCL_RUNTIME_PATH}". 
995 Please specify the full path of the cmucl runtime using the 
996     --with-cmucl-runtime=<path>
997 flag.)
998    fi
999    count=`echo "${result}" | grep -c "MAXIMA_CMUCL_TEST_SUCCESS"`
1000    if test ! "${count}" = "1" ; then
1001       AC_MSG_ERROR(an error occurred while checking cmucl runtime)
1002    fi
1005 if test x"${scl}" = xtrue; then
1006     if test x"${SCL_RUNTIME_PATH}" = x"" ; then
1007         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))'`
1008     fi
1009     if test -x "${SCL_RUNTIME_PATH}" ; then
1010         echo "scl runtime is \"${SCL_RUNTIME_PATH}\""
1011     else
1012 dnl last chance: find SCL_NAME in path. Use it if it doesn't appear to
1013 dnl be a shell script.
1014         scl_path=`type -p "${SCL_NAME}"`
1015         if test x"`grep -c '#!.*bin.*sh.*' ${scl_path}`" = x"0" ; then
1016                 SCL_RUNTIME_PATH="${scl_path}"
1017         else
1018                 AC_MSG_ERROR([Unable to determine SCL runtime path.
1019 The best guess for SCL runtime, "${SCL_RUNTIME_PATH}", is not
1020 an executable. Use the argument
1021    --with-scl-runtime=<path>
1022 to set the actual SCL executable. If the SCL lisp command is a shell
1023 script the SCL executable is the program exec'd by that shell script.])
1024         fi
1025     fi
1026     SCL_RUNTIME=`basename ${SCL_RUNTIME_PATH}`
1029 if test x"${gcl}" = xtrue; then
1030    AC_MSG_CHECKING([if gcl version >= 2.6.13])
1031    dnl Check gcl version
1032    GCL_VERSION=`${GCL_NAME} -eval '(princ (lisp-implementation-version))' -batch | sed 's/GCL \([[0-9.]]\+\).*/\1/'`
1033    dnl echo GCL version = $GCL_VERSION
1034    dnl Assume GCL_VERSION looks like p.q.r where p, q, and r are
1035    dnl digits.  Then extract each set of digits to get the numbers to
1036    dnl create a version number for comparison.
1037    gcl_major=`expr $GCL_VERSION : '\([[0-9]]\+\)'`
1038    gcl_minor=`expr $GCL_VERSION : '[[0-9]]\+\.\([[0-9]]\+\)'`
1039    gcl_sub=`expr $GCL_VERSION : '[[0-9]]\+\.[[0-9]]\+\.\([[0-9]]\+\)'`
1040    dnl echo gcl major = $gcl_major
1041    dnl echo gcl_minor = $gcl_minor
1042    dnl echo gcl_sub = $gcl_sub
1043    dnl Create a numerical version number
1044    gcl_version=`expr ${gcl_major} \* 10000 \+ ${gcl_minor} \* 100 \+ ${gcl_sub}`
1046    if test ${gcl_version} -lt 20613; then
1047        AC_MSG_ERROR([GCL version ${GCL_VERSION} too old])
1048    else
1049        AC_MSG_RESULT([${GCL_VERSION}])
1050    fi
1052    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)'`
1053    retval=$?
1054    if test ! x"${retval}" = x"0" ; then
1055       AC_MSG_ERROR(unable to run gcl executable "${GCL_NAME}".)
1056    fi
1057    count=`echo "${result}" | grep -c "MAXIMA_GCL_ANSI_TEST_SUCCESS"`
1058    if test ! "${count}" = "1" ; then
1059       AC_MSG_ERROR([The gcl executable "${GCL_NAME}" was not compiled with
1060 the --enable-ansi flag, which is required for Maxima.
1061 The gcl ANSI-CL check returned
1062 "${result}".])
1063    fi
1066 AC_ARG_ENABLE(gcl-alt-link,
1067         [  --enable-gcl-alt-link        Use GCL's alternate linking mechanism],
1068         [case "${enableval}" in
1069                 yes) gcl_alt_link=true ;;
1070                 no)  gcl_alt_link=false ;;
1071                 *) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl-alt-link) ;;
1072         esac],
1073         [gcl_alt_link=false])
1075 AM_CONDITIONAL(GCL_ALT_LINK, test x$gcl_alt_link = xtrue)
1077 AC_ARG_WITH(default-lisp,
1078         [  --with-default-lisp=<lisp>   Set default lisp implementation to <lisp>],
1079         [case "${withval}" in
1080                 clisp)
1081                         if test x"${clisp}" = xtrue ; then
1082                                 DEFAULTLISP=clisp
1083                         else
1084                                 AC_MSG_ERROR(clisp not enabled)
1085                         fi
1086                         ;;
1087                 cmucl)
1088                         if test x"${cmucl}" = xtrue ; then
1089                                 DEFAULTLISP=cmucl
1090                         else
1091                                 AC_MSG_ERROR(cmucl not enabled)
1092                         fi
1093                         ;;
1094                 scl)
1095                         if test x"${scl}" = xtrue ; then
1096                                 DEFAULTLISP=scl
1097                         else
1098                                 AC_MSG_ERROR(scl not enabled)
1099                         fi
1100                         ;;
1101                 sbcl)
1102                         if test x"${sbcl}" = xtrue ; then
1103                                 DEFAULTLISP=sbcl
1104                         else
1105                                 AC_MSG_ERROR(sbcl not enabled)
1106                         fi
1107                         ;;
1108                 gcl)
1109                         if test x"${gcl}" = xtrue ; then
1110                                 DEFAULTLISP=gcl
1111                         else
1112                                 AC_MSG_ERROR(gcl not enabled)
1113                         fi
1114                         ;;      
1115                 acl)
1116                         if test x"${acl}" = xtrue ; then
1117                                 DEFAULTLISP=acl
1118                         else
1119                                 AC_MSG_ERROR(acl not enabled)
1120                         fi
1121                         ;;      
1122                 openmcl)
1123                         if test x"${openmcl}" = xtrue ; then
1124                                 DEFAULTLISP=openmcl
1125                         else
1126                                 AC_MSG_ERROR(openmcl not enabled)
1127                         fi
1128                         ;;              
1129                 ecl)
1130                         if test x"${ecl}" = xtrue ; then
1131                                 DEFAULTLISP=ecl
1132                         else
1133                                 AC_MSG_ERROR(ecl not enabled)
1134                         fi
1135                         ;;
1136                 ccl64)          
1137                         if test x"${ccl64}" = xtrue ; then
1138                                 DEFAULTLISP=ccl64
1139                         else
1140                                 AC_MSG_ERROR(ccl64 not enabled)
1141                         fi
1142                         ;;              
1143                 abcl)           
1144                         if test x"${abcl}" = xtrue ; then
1145                                 DEFAULTLISP=abcl
1146                         else
1147                                 AC_MSG_ERROR(abcl not enabled)
1148                         fi
1149                         ;;              
1150                 *) 
1151                         AC_MSG_ERROR(Unknown argument ${DEFAULTLISP} to --with-default-lisp) 
1152                         ;;
1153         esac],
1154         [if test x"${sbcl}" = xtrue ; then
1155                 DEFAULTLISP=sbcl
1156         elif test x"${cmucl}" = xtrue ; then
1157                 DEFAULTLISP=cmucl
1158         elif test x"${scl}" = xtrue ; then
1159                 DEFAULTLISP=scl
1160         elif test x"${clisp}" = xtrue ; then
1161                 DEFAULTLISP=clisp
1162         elif test x"${gcl}" = xtrue ; then
1163                 DEFAULTLISP=gcl
1164         elif test x"${acl}" = xtrue ; then
1165                 DEFAULTLISP=acl
1166         elif test x"${openmcl}" = xtrue ; then
1167                 DEFAULTLISP=openmcl
1168         elif test x"${ecl}" = xtrue ; then
1169                 DEFAULTLISP=ecl
1170         elif test x"${ccl64}" = xtrue ; then
1171                 DEFAULTLISP=ccl64
1172         elif test x"${abcl}" = xtrue ; then
1173                 DEFAULTLISP=abcl
1174         else
1175                 AC_MSG_ERROR(Internal error. No lisp enabled. Please contact maintainer.)
1176         fi])
1178 AC_SUBST(CLISP_NAME)
1179 AC_SUBST(CLISP_RUNTIME)
1180 AC_SUBST(CLISP_RUNTIME_PATH)
1181 AC_SUBST(CMUCL_NAME)
1182 AC_SUBST(CMUCL_RUNTIME)
1183 AC_SUBST(CMUCL_RUNTIME_PATH)
1184 AC_SUBST(CMUCL_EXEC)
1185 AC_SUBST(SCL_NAME)
1186 AC_SUBST(SCL_RUNTIME)
1187 AC_SUBST(SCL_RUNTIME_PATH)
1188 AC_SUBST(SBCL_NAME)
1189 AC_SUBST(GCL_NAME)
1190 AC_SUBST(ACL_NAME)
1191 AC_SUBST(OPENMCL_NAME)
1192 AC_SUBST(ECL_NAME)
1193 AC_SUBST(CCL64_NAME)
1194 AC_SUBST(DEFAULTLISP)
1195 AC_SUBST(HHC)
1196 AC_SUBST(lisps_enabled)
1197 AC_SUBST(ABCL_JAR)
1198 AC_SUBST(JRE)
1200 AC_ARG_WITH(posix-shell,
1201         [  --with-posix-shell=<path>    Use <shell> for maxima script (default /bin/sh)],
1202         [posix_shell_list="${withval}"],
1203         [posix_shell_list="/bin/sh /bin/bash /usr/bin/bash /usr/local/bin/bash"])
1205 AC_ARG_WITH(wish,
1206         [  --with-wish=<prog>           Use <prog> for Tk wish shell (default wish)],
1207         [WISH="${withval}"],
1208         [WISH="wish"])
1209 AC_SUBST(WISH)
1212 AC_MSG_CHECKING(POSIX shell to see that it contains getopts)
1213 cat <<EOF > conftest-posix-shell.sh
1214 getopts "ab:" opt
1215 result="\$?"
1216 echo "result is \$result"
1217 exit "\$result"
1219 POSIX_SHELL=""
1220 for shell in $posix_shell_list
1222         if test -z "$POSIX_SHELL" ; then
1223                 echo "trying $shell"
1224                 $shell conftest-posix-shell.sh -a > /dev/null 2>&1
1225                 if test "$?" = "0" ; then
1226                         POSIX_SHELL="$shell"
1227                 fi
1228         fi
1229 done
1230 rm -f conftest-posix-shell.sh
1231 if test -n "$POSIX_SHELL" ; then
1232         AC_MSG_RESULT(POSIX shell is $POSIX_SHELL)
1233 else
1234         AC_MSG_WARN(Could not find a shell that supports getopts. 
1235 The maxima wrapper script will be unusable. The shell may be specified
1236 with --with-posix-shell=</path/to/shell>)
1238 AC_SUBST(POSIX_SHELL)
1240 if test x"${prefix}" = xNONE ; then
1241         tmp_prefix="/usr/local"
1242 else
1243         tmp_prefix="${prefix}"
1245 if test x"${exec_prefix}" = xNONE ; then
1246         tmp_exec_prefix="${tmp_prefix}"
1247 else
1248         tmp_exec_prefix="${exec_prefix}"
1250 expanded_top_srcdir="$(cd "$top_srcdir" 1>/dev/null 2>/dev/null; pwd)"
1251 expanded_exec_prefix="${tmp_exec_prefix}"
1252 expanded_libdir="$(eval "exec_prefix=\"${tmp_exec_prefix}\";echo ${libdir}")"
1253 expanded_libexecdir="$(eval "exec_prefix=\"${tmp_exec_prefix}\";echo ${libexecdir}")"
1254 expanded_datadir="$(eval "prefix=\"${tmp_prefix}\";datarootdir=\"${datarootdir}\";echo ${datadir}")"
1255 expanded_infodir="$(eval "prefix=\"${tmp_prefix}\";datarootdir=\"${datarootdir}\";echo ${infodir}")"
1258 dnl Find all the directories in share, but remove the share directory
1259 dnl itself and all CVS directories (if any) and fortran directories
1260 dnl and *.t2p directories (created when generating pdf documentation).
1261 dnl Remove the leading "share" part of the path, and add double-quotes
1262 dnl around it.
1264 #default_sharedirs=`find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\);        "\1" \\\\;' | sed '$s;\\\\;;'`
1265 default_sharedirs=`cd $srcdir;find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\);"\1";' | tr '\n' ' '`
1267 AC_SUBST(top_srcdir)
1268 AC_SUBST(abs_top_builddir)
1269 AC_SUBST(abs_top_srcdir)
1270 AC_SUBST(top_builddir)
1271 AC_SUBST(expanded_top_srcdir)
1272 AC_SUBST(expanded_exec_prefix)
1273 AC_SUBST(expanded_libdir)
1274 AC_SUBST(expanded_libexecdir)
1275 AC_SUBST(expanded_datadir)
1276 AC_SUBST(expanded_infodir)
1277 default_layout_autotools="true"
1278 AC_SUBST(default_layout_autotools)
1279 AC_SUBST(LDFLAGS)
1280 AC_SUBST(default_sharedirs)
1282 AC_ARG_WITH(emacs-prefix,
1283         [  --emacs-prefix=<path>        Where to install the emacs modes to],
1284         [EMACSDIR="$withval"],
1285         [EMACSDIR="${datarootdir}/emacs/site-lisp"])
1286 AC_SUBST(EMACSDIR)
1288 dnl Tell defsystem that this isn't a lisp-only build
1289 lisp_only_build="nil"
1290 AC_SUBST(lisp_only_build)
1291 dnl Extra files we want to clean from the src dir
1292 if test x"$srcdir" = x"." ; then
1293    DISTCLEAN_EXTRA_SRC_FILES=""
1294 else
1295    DISTCLEAN_EXTRA_SRC_FILES=share_subdirs.lisp
1297 AC_SUBST(DISTCLEAN_EXTRA_SRC_FILES)
1300 dnl Look for grep that can handle long lines and -e.
1301 AC_PROG_EGREP
1302 AC_SUBST(EGREP)
1303 AC_PATH_PROG([CAT],[cat])
1304 AC_PROG_SED
1305 AC_PROG_AWK
1306 AC_SUBST(SED)
1308 # Configure these files and make them executable
1309 AC_CONFIG_FILES([maxima-local], chmod +x maxima-local)
1310 AC_CONFIG_FILES([src/startmaxima_abcl.sh], chmod +x src/startmaxima_abcl.sh)
1311 AC_CONFIG_FILES([xmaxima-local], chmod +x xmaxima-local)
1312 AC_CONFIG_FILES([tests/test.sh], chmod +x tests/test.sh)
1313 AC_CONFIG_FILES([doc/info/build_html.sh], chmod +x doc/info/build_html.sh)
1314 AC_CONFIG_FILES([src/maxima], chmod +x src/maxima)
1315 AC_CONFIG_FILES([src/maxima.bat])
1317 AC_CONFIG_FILES([Makefile maxima.spec maxima.iss \
1318 admin/Makefile src/Makefile src/rmaxima src/autoconf-variables.lisp \
1319 src/share-subdirs_autogenerated.lisp \
1320 lisp-utils/Makefile tests/Makefile doc/Makefile \
1321 crosscompile-windows/Makefile \
1322 doc/emaxima/Makefile doc/info/Makefile doc/info/include-maxima.texi \
1323 desktopintegration/Makefile \
1324 doc/info/category-macros.texi \
1325 doc/info/texi2html.init \
1326 doc/info/texi2html-7.init \
1327 doc/info/math.m4 \
1328 doc/info/figures/Makefile \
1329 doc/info/de/Makefile \
1330 doc/info/de/include-maxima.texi \
1331 doc/info/es/Makefile \
1332 doc/info/ja/Makefile \
1333 doc/info/ja/include-maxima.texi \
1334 doc/info/pt_BR/include-maxima.texi \
1335 doc/info/pt/Makefile \
1336 doc/info/pt/include-maxima.texi \
1337 doc/info/pt_BR/Makefile \
1338 doc/info/ru/Makefile \
1339 doc/info/ru/include-maxima.texi \
1340 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 \
1341 doc/share/Makefile interfaces/Makefile interfaces/emacs/Makefile \
1342 interfaces/emacs/emaxima/Makefile interfaces/emacs/imaxima/Makefile \
1343 interfaces/emacs/misc/Makefile interfaces/xmaxima/Makefile \
1344 interfaces/xmaxima/autoconf-variables.tcl interfaces/xmaxima/Tkmaxima/Header.tcl \
1345 interfaces/xmaxima/doc/Makefile interfaces/xmaxima/doc/figures/Makefile \
1346 interfaces/xmaxima/msgs/Makefile interfaces/xmaxima/win32/Makefile \
1347 plotting/mgnuplot share/Makefile demo/Makefile plotting/Makefile locale/Makefile \
1348 share/contrib/Makefile share/contrib/integration/Makefile \
1349 share/contrib/maxima-odesolve/Makefile \
1350 share/contrib/symplectic_ode/Makefile \
1351 share/nelder_mead/Makefile \
1352 share/draw/Makefile share/logic/Makefile  doc/info/es/include-maxima.texi \
1353 src/lisp])
1354 AC_OUTPUT
1356 # The default of 4096 is sometimes too little for the test suite.
1357 if test x"${sbcl}" = xtrue ; then
1358    AC_MSG_CHECKING(if sbcl complains if we try to enlarge the thread-local storage)
1359    echo "(quit)" | ${SBCL_NAME} --tls-limit 8192 > /dev/null 2>&1
1360    if test "$?" = "0" ; then
1361         SBCL_EXTRA_ARGS="--tls-limit 8192"
1362         AC_MSG_RESULT(Yes)
1363    else
1364         SBCL_EXTRA_ARGS=""
1365         AC_MSG_RESULT(No)
1366    fi
1368 AC_SUBST(SBCL_EXTRA_ARGS)
1370 echo
1371 echo "Summary:"
1372 if test x"${clisp}" = xtrue ; then
1373         echo "Compiling a maxima image using \"${CLISP_NAME}\"",
1374         echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
1375         if test x"${clisp_exec}" = xtrue ; then
1376                 echo "clisp executable image enabled for maxima."
1377         else
1378                 echo Use "--enable-clisp-exec to build a standalone executable instead."
1379         fi
1381 if test x"${cmucl}" = xtrue ; then
1382         echo "Compiling a maxima image using \"${CMUCL_NAME}\""
1383         echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
1384         if test x"${cmucl_exec}" = xtrue; then
1385                 echo "CMUCL executable image enabled for maxima."
1386         else
1387                 echo Use "--enable-cmucl-exec to build a standalone executable instead."
1388         fi
1390 if test x"${scl}" = xtrue ; then
1391         echo "SCL enabled, using \"${SCL_NAME}\""
1392         echo "SCL runtime is \"${SCL_RUNTIME_PATH}\""
1394 if test x"${sbcl}" = xtrue ; then
1395         echo "Compiling a maxima image using \"${SBCL_NAME}\""
1396         if test x"${sbcl_exec}" = xtrue ; then
1397                 echo "sbcl executable image enabled for maxima."
1398         else
1399                 echo Use "--enable-sbcl-exec to build a standalone executable instead."
1400         fi
1402 if test x"${gcl}" = xtrue ; then
1403         echo "Compiling a maxima image using \"${GCL_NAME}\""
1404         if test x"${gcl_alt_link}" = xtrue ; then
1405                 echo "    GCL alternative linking method enabled."
1406         fi
1408 if test x"${acl}" = xtrue ; then
1409         echo "ACL enabled. Executable name: \"${ACL_NAME}\""
1411 if test x"${openmcl}" = xtrue ; then
1412         echo "Compiling a maxima image using \"${OPENMCL_NAME}\""
1413         if test x"${openmcl_exec}" = xtrue ; then
1414                 echo "OpenMCL executable image enabled for maxima."
1415         else
1416                 echo Use "--enable-openmcl-exec to build a standalone executable instead."
1417         fi
1419 if test x"${ccl64}" = xtrue ; then
1420         echo "Compiling a maxima image using \"${CCL64_NAME}\""
1421         if test x"${ccl64_exec}" = xtrue ; then
1422                 echo "CCL64 executable image enabled for maxima."
1423         else
1424                 echo Use "--enable-ccl64-exec to build a standalone executable instead."
1425         fi
1428 if test x"${ecl}" = xtrue ; then
1429         if test x"$srcdir" = x"." ; then
1430                 echo "Compiling maxima using \"${ECL_NAME}\""
1431         else
1432                 echo "ECL enabled. Executable name: \"${ECL_NAME}\""
1433                 AC_MSG_ERROR(For ECL out-of-tree builds aren't supported. See src/maxima.system for details.)
1434         fi
1437 if test x"${abcl}" = xtrue ; then
1438         if test x"$srcdir" = x"." ; then
1439                 echo "Compiling maxima using \"${ABCL_JAR}\""
1440         else
1441                 echo "ABCL enabled. ABCL jarfile: \"${ABCL_JAR}\""
1442                 AC_MSG_ERROR(For ABCL out-of-tree builds aren't supported. See src/maxima.system for details.)
1443         fi
1446 echo "default lisp: $DEFAULTLISP"
1447 echo "wish executable name: \"${WISH}\""
1449 if test x"${chm}" = xtrue ; then
1450   echo "CHM help files enabled"
1451   echo "  HHC: \"${HHC}\""
1453 if test x"${xmaxima_exe}" = xtrue ; then
1454    echo "Windows xmaxima.exe enabled"
1455    echo "  GCC version GCCVER: ${GCCVER}"
1456    echo "  TCLKITSH: ${TCLKITSH}"
1457    if ! test -f "${TCLKITSH}" ; then
1458      AC_MSG_WARN(*** TCLKITSH ${TCLKITSH} not found)
1459      xmaxima_exe_prerequisite=notfound
1460    fi
1461    echo "  TCLKIT_RUNTIME: ${TCLKIT_RUNTIME}"
1462    if ! test -f "${TCLKIT_RUNTIME}" ; then
1463      AC_MSG_WARN(*** TCLKIT_RUNTIME ${TCLKIT_RUNTIME} not found)
1464      xmaxima_exe_prerequisite=notfound
1465    fi
1466    echo "  SDXKIT: ${SDXKIT}"
1467    if ! test -f "${SDXKIT}" ; then
1468      AC_MSG_WARN(*** SDXKIT ${SDXKIT} not found)
1469      xmaxima_exe_prerequisite=notfound
1470    fi
1471    echo "  IMGKIT: ${IMGKIT}"
1472    if ! test -f "${IMGKIT}" ; then
1473      AC_MSG_WARN(*** IMGKIT ${IMGKIT} not found)
1474      xmaxima_exe_prerequisite=notfound
1475    fi
1476    if test x${xmaxima_exe_prerequisite} = xnotfound ; then
1477      AC_MSG_WARN([A prerequisite for xmaxima.exe not found.  The missing components can be defined on the make command line.])
1478    fi