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