| blob | cc035d5e1ed444460dcb4150f97decdf34000340 |
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_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}`
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
697 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
806 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
866 fi
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
933 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}`
965 fi
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
1003 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}`
1027 fi
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
1064 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"
1218 EOF
1219 POSIX_SHELL=""
1220 for shell in $posix_shell_list
1221 do
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>)
1237 fi
1238 AC_SUBST(POSIX_SHELL)
1240 if test x"${prefix}" = xNONE ; then
1241 tmp_prefix="/usr/local"
1242 else
1243 tmp_prefix="${prefix}"
1244 fi
1245 if test x"${exec_prefix}" = xNONE ; then
1246 tmp_exec_prefix="${tmp_prefix}"
1247 else
1248 tmp_exec_prefix="${exec_prefix}"
1249 fi
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
1296 fi
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
1367 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
1380 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
1389 fi
1390 if test x"${scl}" = xtrue ; then
1391 echo "SCL enabled, using \"${SCL_NAME}\""
1392 echo "SCL runtime is \"${SCL_RUNTIME_PATH}\""
1393 fi
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
1401 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
1407 fi
1408 if test x"${acl}" = xtrue ; then
1409 echo "ACL enabled. Executable name: \"${ACL_NAME}\""
1410 fi
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
1418 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
1426 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
1435 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
1444 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}\""
1452 fi
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
1479 fi