| blob | 700ed346d260ce56c317a0f79a1f17828d881263 |
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.45post])
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
637 fi
639 dnl languages
640 AC_ARG_ENABLE(lang-de,
641 [ --enable-lang-de German language support],
642 [case "${enableval}" in
643 yes) lang_de=true ;;
644 no) lang_de=false ;;
645 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-de) ;;
646 esac],
647 [lang_de=false])
649 AM_CONDITIONAL(LANG_DE, test x$lang_de = xtrue)
651 AC_ARG_ENABLE(lang-de-utf8,
652 [ --enable-lang-de-utf8 German language support (UTF-8)],
653 [case "${enableval}" in
654 yes) lang_de_utf8=true ;;
655 no) lang_de_utf8=false ;;
656 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-de-utf8) ;;
657 esac],
658 [lang_de_utf8=false])
660 AM_CONDITIONAL(LANG_DE_UTF8, test x$lang_de_utf8 = xtrue)
662 AC_ARG_ENABLE(lang-ja,
663 [ --enable-lang-ja Japanese language support],
664 [case "${enableval}" in
665 yes) lang_ja=true ;;
666 no) lang_ja=false ;;
667 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-ja) ;;
668 esac],
669 [lang_ja=false])
671 AM_CONDITIONAL(LANG_JA, test x$lang_ja = xtrue)
673 AC_ARG_ENABLE(lang-es,
674 [ --enable-lang-es Spanish language support],
675 [case "${enableval}" in
676 yes) lang_es=true ;;
677 no) lang_es=false ;;
678 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-es) ;;
679 esac],
680 [lang_es=false])
682 AC_SUBST(lang_es)
683 AM_CONDITIONAL(LANG_ES, test x$lang_es = xtrue)
685 AC_ARG_ENABLE(lang-es-utf8,
686 [ --enable-lang-es-utf8 Spanish language support (UTF-8)],
687 [case "${enableval}" in
688 yes) lang_es_utf8=true ;;
689 no) lang_es_utf8=false ;;
690 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-es-utf8) ;;
691 esac],
692 [lang_es_utf8=false])
694 AM_CONDITIONAL(LANG_ES_UTF8, test x$lang_es_utf8 = xtrue)
696 AC_ARG_ENABLE(lang-pt,
697 [ --enable-lang-pt Portuguese language support],
698 [case "${enableval}" in
699 yes) lang_pt=true ;;
700 no) lang_pt=false ;;
701 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt) ;;
702 esac],
703 [lang_pt=false])
705 AC_SUBST(lang_pt)
706 AM_CONDITIONAL(LANG_PT, test x$lang_pt = xtrue)
708 AC_ARG_ENABLE(lang-pt-utf8,
709 [ --enable-lang-pt-utf8 Portuguese language support (UTF-8)],
710 [case "${enableval}" in
711 yes) lang_pt_utf8=true ;;
712 no) lang_pt_utf8=false ;;
713 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt-utf8) ;;
714 esac],
715 [lang_pt_utf8=false])
717 AM_CONDITIONAL(LANG_PT_UTF8, test x$lang_pt_utf8 = xtrue)
719 AC_ARG_ENABLE(lang-pt_BR,
720 [ --enable-lang-pt_BR Brazilian Portuguese language support],
721 [case "${enableval}" in
722 yes) lang_pt_br=true ;;
723 no) lang_pt_br=false ;;
724 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt_BR) ;;
725 esac],
726 [lang_pt_br=false])
728 AC_SUBST(lang_pt_br)
729 AM_CONDITIONAL(LANG_PT_BR, test x$lang_pt_br = xtrue)
731 AC_ARG_ENABLE(lang-pt_BR-utf8,
732 [ --enable-lang-pt_BR-utf8 Brazilian Portuguese language support (UTF-8)],
733 [case "${enableval}" in
734 yes) lang_pt_br_utf8=true ;;
735 no) lang_pt_br_utf8=false ;;
736 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt_BR-utf8) ;;
737 esac],
738 [lang_pt_br_utf8=false])
740 AM_CONDITIONAL(LANG_PT_BR_UTF8, test x$lang_pt_br_utf8 = xtrue)
742 AC_ARG_ENABLE(recode,
743 [ --enable-recode Use recode for charset conversion],
744 [case "${enableval}" in
745 yes) use_recode=true ;;
746 no) use_recode=false ;;
747 *) AC_MSG_ERROR(bad value ${enableval} for --enable-recode) ;;
748 esac],
749 [use_recode=false])
751 dnl iconv and/or recode
752 AC_CHECK_PROG(iconv_found,iconv,true,false)
753 AC_CHECK_PROG(recode_found,recode,true,false)
755 if test x"${use_recode}" = xtrue ; then
756 if test x"${recode_found}" = xfalse ; then
757 AC_MSG_ERROR(No recode found)
758 fi
759 elif test x"${iconv_found}" = xfalse ; then
760 use_recode=true
761 else
762 use_recode=false
763 fi
765 AM_CONDITIONAL(USE_RECODE, test x$use_recode = xtrue)
767 dnl Optionally build the windows CHM help files
768 dnl default to false as requires win32 and Microsoft HTML Help Workshop
769 AC_ARG_ENABLE(chm,
770 [ --enable-chm Build Windows CHM help files],
771 [case "${enableval}" in
772 yes) chm=true ;;
773 no) chm=false ;;
774 *) AC_MSG_ERROR(bad value ${enableval} for --enable-chm) ;;
775 esac],
776 [chm=false])
777 AM_CONDITIONAL(CHM, test x$chm = xtrue)
778 dnl hhc is the HTML Help Compiler for CHM documentation
779 hhc_default_name=hhc$EXEEXT
780 AC_ARG_WITH(hhc,
781 [ --with-hhc=<prog> Use HTML Help Compiler executable <prog> (default hhc)],
782 [hhc=true
783 if test "$withval" = "yes"; then
784 HHC="${hhc_default_name}"
785 else
786 HHC="$withval"
787 fi],
788 [HHC="${hhc_default_name}"])
790 # Check that hhc exists, using AC_CHECK_PROG
791 if test x$chm = xtrue; then
792 if test -x "${HHC}"; then
793 # HHC was a path to the executable, and it existed, which is
794 # great! We still say something to the caller, since this is
795 # probably less confusing.
796 AC_MSG_CHECKING([for hhc])
797 AC_MSG_RESULT([yes])
798 else
799 AC_CHECK_PROG(hhc_found, ${HHC}, yes)
800 if test x"${hhc_found}" != x"yes"; then
801 AC_MSG_ERROR([HTML Help Compiler executable ${HHC} not found])
802 fi
803 fi
804 fi
806 dnl Make the build quiet
807 AC_ARG_ENABLE(quiet_build,
808 [ --enable-quiet-build Make the build quieter],
809 [case "${enableval}" in
810 yes) quiet_build=true ;;
811 no) quiet_build=false ;;
812 *) AC_MSG_ERROR(bad value ${enableval} for --enable-quiet-build) ;;
813 esac],
814 [quiet_build=false])
815 AM_CONDITIONAL(QUIET_BUILD, test x${quiet_build} = xtrue)
817 dnl Optionally build xmaxima.exe under windows
818 dnl default to false as additional software
819 AC_ARG_ENABLE(xmaxima_exe,
820 [ --enable-xmaxima-exe Build Windows xmaxima.exe for installer],
821 [case "${enableval}" in
822 yes) xmaxima_exe=true ;;
823 no) xmaxima_exe=false ;;
824 *) AC_MSG_ERROR(bad value ${enableval} for --enable-xmaxima-exe) ;;
825 esac],
826 [xmaxima_exe=false])
827 AM_CONDITIONAL(XMAXIMA_EXE, test x$xmaxima_exe = xtrue)
829 dnl Optionally build xmaxima.exe under windows
830 dnl default to false as additional software
831 AC_ARG_ENABLE(winkill_exe,
832 [ --enable-winkill Build Windows winkill.exe and winkill_lib.dll for installer],
833 [case "${enableval}" in
834 yes) winkill_exe=true ;;
835 no) winkill_exe=false ;;
836 *) AC_MSG_ERROR(bad value ${enableval} for --enable-winkill-exe) ;;
837 esac],
838 [winkill_exe=false])
839 AM_CONDITIONAL(WINKILL_EXE, test x$winkill_exe = xtrue)
841 dnl Should we build a win64 installer?
842 AC_ARG_ENABLE(win64-installer,
843 [ --enable-win64-installer Build a 64bit installer on Windows],
844 [case "${enableval}" in
845 yes) win64_installer=true ;;
846 no) win64_installer=false ;;
847 *) AC_MSG_ERROR(bad valu ${enableval} for --enable-win64-installer) ;;
848 esac],
849 [win64_installer=false])
850 AM_CONDITIONAL(WIN64_INSTALLER, test x$win64_installer = xtrue)
851 AC_SUBST(win64_installer)
853 dnl Enable use of MathJax in the html documentation. This just loads
854 dnl MathJax in each html file. The texi files need to put the
855 dnl appropriate @html/@end html text to generate the equations for MathJax.
856 AC_ARG_ENABLE(mathjax,
857 [ --enable-mathjax Enable MathJax support for html manual],
858 [case "${enableval}" in
859 yes) mathjax=true
860 mathjax_enable='@set mathjax true'
861 mathjax_script='<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.9/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>'
862 ;;
863 no) mathjax=false
864 mathjax_enable='@clear mathjax'
865 mathjax_script="";;
866 *) AC_MSG_ERROR(bad value ${enableval} for --enable-mathjax) ;;
867 esac],
868 [mathjax=false])
869 AM_CONDITIONAL(MATHJAX, test x$mathjax = xtrue)
870 AC_SUBST(mathjax_script)
871 AC_SUBST(mathjax_enable)
873 dnl Tools for building xmaxima.exe on windows
874 dnl Hard code the filenames for now. Can over-ride on make command line
875 GCCVER=undefined
876 if test x${xmaxima_exe} = xtrue ; then
877 GCCVER=`gcc -dumpversion`
878 dnl http://tclkits.rkeene.org/fossil/wiki?name=Downloads
879 dnl and http://www.tcl.tk/starkits/
880 TCLKITSH=/c/programs/star/tclkitsh-8.6.3-win32-ix86.exe
881 TCLKIT_RUNTIME=/c/programs/star/tclkit-8.6.3-win32-ix86.exe
882 SDXKIT=/c/programs/star/sdx.kit
883 IMGKIT=/c/programs/star/img.kit
884 fi
886 AC_SUBST(GCCVER)
887 AC_SUBST(TCLKITSH)
888 AC_SUBST(TCLKIT_RUNTIME)
889 AC_SUBST(SDXKIT)
890 AC_SUBST(IMGKIT)
891 AM_CONDITIONAL(GCC331, test x${GCCVER} = x3.3.1)
893 if test x"${explicit_lisp}" = xfalse ; then
894 dnl See if any of the lisps can be found
895 AC_CHECK_PROG(clisp_found,${clisp_default_name},true,false)
896 AC_CHECK_PROG(gcl_found,${gcl_default_name},true,false)
897 AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
898 AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
899 AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
900 AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
901 AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
902 AC_CHECK_PROG(ccl64_found,$CCL64_NAME,true,false)
903 AC_CHECK_PROG(ecl_found,$ECL_NAME,true,false)
905 if test x"${clisp_found}" = xtrue ; then
906 clisp=true
907 lisps_enabled="${lisps_enabled} clisp"
908 elif test x"${gcl_found}" = xtrue ; then
909 gcl=true
910 lisps_enabled="${lisps_enabled} gcl"
911 elif test x"${cmucl_found}" = xtrue ; then
912 cmucl=true
913 lisps_enabled="${lisps_enabled} cmucl"
914 elif test x"${scl_found}" = xtrue ; then
915 scl=true
916 lisps_enabled="${lisps_enabled} scl"
917 elif test x"${sbcl_found}" = xtrue ; then
918 sbcl=true
919 lisps_enabled="${lisps_enabled} sbcl"
920 elif test x"${acl_found}" = xtrue ; then
921 acl=true
922 lisps_enabled="${lisps_enabled} acl"
923 elif test x"${ecl_found}" = xtrue ; then
924 ecl=true
925 lisps_enabled="${lisps_enabled} ecl"
926 else
927 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)
928 fi
929 fi
931 AM_CONDITIONAL(ABCL, test x$abcl = xtrue)
932 AM_CONDITIONAL(CLISP, test x$clisp = xtrue)
933 AM_CONDITIONAL(CLISP_EXEC, test x$clisp_exec = xtrue)
934 AM_CONDITIONAL(GCL, test x$gcl = xtrue)
935 AM_CONDITIONAL(CMUCL, test x$cmucl = xtrue)
936 AM_CONDITIONAL(CMUCL_EXEC, test x${cmucl_exec} = xtrue)
937 AM_CONDITIONAL(SCL, test x$scl = xtrue)
938 AM_CONDITIONAL(SBCL, test x$sbcl = xtrue)
939 AM_CONDITIONAL(SBCL_EXEC, test x$sbcl_exec = xtrue)
940 AM_CONDITIONAL(ACL, test x$acl = xtrue)
941 AM_CONDITIONAL(OPENMCL, test x$openmcl = xtrue)
942 AM_CONDITIONAL(OPENMCL_EXEC, test x${openmcl_exec} = xtrue)
943 AM_CONDITIONAL(ECL, test x$ecl = xtrue)
944 AM_CONDITIONAL(CCL64, test x$ccl64 = xtrue)
945 AM_CONDITIONAL(CCL64_EXEC, test x${ccl64_exec} = xtrue)
947 if test x"${clisp}" = xtrue; then
948 if test x"${CLISP_RUNTIME_PATH}" = x"" ; then
949 if test x"${mingw}" = xtrue ; then
950 CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~a${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
951 else
952 CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~abase/${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
953 fi
954 fi
955 if test -x ${CLISP_RUNTIME_PATH} ; then
956 echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
957 else
958 AC_MSG_ERROR(clisp runtime \"${CLISP_RUNTIME_PATH}\" is not an executable)
959 fi
960 CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`
961 fi
963 if test x"${cmucl}" = xtrue; then
964 if test x"${CMUCL_RUNTIME_PATH}" = x"" ; then
965 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)'`
966 fi
967 if test -x "${CMUCL_RUNTIME_PATH}" ; then
968 echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
969 else
970 dnl last chance: find CMUCL_NAME in path. Use it if it doesn't appear to
971 dnl be a shell script.
972 cmucl_path=`type -p "${CMUCL_NAME}"`
973 if test x"`grep -c '#!.*bin.*sh.*' ${cmucl_path}`" = x"0" ; then
974 CMUCL_RUNTIME_PATH="${cmucl_path}"
975 else
976 AC_MSG_ERROR([Unable to determine CMUCL runtime path.
977 The best guess for CMUCL runtime, \"${CMUCL_RUNTIME_PATH}\", is not
978 an executable. Use the argument
979 --with-cmucl-runtime=<path>
980 to set the actual CMUCL executable. If the CMUCL lisp command is a shell
981 script the CMUCL executable is the program exec'd by that shell script.])
982 fi
983 fi
984 CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`
986 dnl cmucl final check
987 result=`"${CMUCL_RUNTIME_PATH}" -quiet -eval '(format t "MAXIMA_CMUCL_TEST_SUCCESS%")(quit)'`
988 retval=$?
989 if test ! x"${retval}" = x"0" ; then
990 AC_MSG_ERROR(unable to run cmucl runtime = "${CMUCL_RUNTIME_PATH}".
991 Please specify the full path of the cmucl runtime using the
992 --with-cmucl-runtime=<path>
993 flag.)
994 fi
995 count=`echo "${result}" | grep -c "MAXIMA_CMUCL_TEST_SUCCESS"`
996 if test ! "${count}" = "1" ; then
997 AC_MSG_ERROR(an error occurred while checking cmucl runtime)
998 fi
999 fi
1001 if test x"${scl}" = xtrue; then
1002 if test x"${SCL_RUNTIME_PATH}" = x"" ; then
1003 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))'`
1004 fi
1005 if test -x "${SCL_RUNTIME_PATH}" ; then
1006 echo "scl runtime is \"${SCL_RUNTIME_PATH}\""
1007 else
1008 dnl last chance: find SCL_NAME in path. Use it if it doesn't appear to
1009 dnl be a shell script.
1010 scl_path=`type -p "${SCL_NAME}"`
1011 if test x"`grep -c '#!.*bin.*sh.*' ${scl_path}`" = x"0" ; then
1012 SCL_RUNTIME_PATH="${scl_path}"
1013 else
1014 AC_MSG_ERROR([Unable to determine SCL runtime path.
1015 The best guess for SCL runtime, \"${SCL_RUNTIME_PATH}\", is not
1016 an executable. Use the argument
1017 --with-scl-runtime=<path>
1018 to set the actual SCL executable. If the SCL lisp command is a shell
1019 script the SCL executable is the program exec'd by that shell script.])
1020 fi
1021 fi
1022 SCL_RUNTIME=`basename ${SCL_RUNTIME_PATH}`
1023 fi
1025 if test x"${gcl}" = xtrue; then
1026 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)'`
1027 retval=$?
1028 if test ! x"${retval}" = x"0" ; then
1029 AC_MSG_ERROR(unable to run gcl executable \"${GCL_NAME}\".)
1030 fi
1031 count=`echo "${result}" | grep -c "MAXIMA_GCL_ANSI_TEST_SUCCESS"`
1032 if test ! "${count}" = "1" ; then
1033 AC_MSG_ERROR([The gcl executable \"${GCL_NAME}\" was not compiled with
1034 the --enable-ansi flag, which is required for Maxima.
1035 The gcl ANSI-CL check returned
1036 \"${result}\".])
1037 fi
1038 fi
1040 AC_ARG_ENABLE(gcl-alt-link,
1041 [ --enable-gcl-alt-link Use GCL's alternate linking mechanism],
1042 [case "${enableval}" in
1043 yes) gcl_alt_link=true ;;
1044 no) gcl_alt_link=false ;;
1045 *) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl-alt-link) ;;
1046 esac],
1047 [gcl_alt_link=false])
1049 AM_CONDITIONAL(GCL_ALT_LINK, test x$gcl_alt_link = xtrue)
1051 AC_ARG_WITH(default-lisp,
1052 [ --with-default-lisp=<lisp> Set default lisp implementation to <lisp>],
1053 [case "${withval}" in
1054 clisp)
1055 if test x"${clisp}" = xtrue ; then
1056 DEFAULTLISP=clisp
1057 else
1058 AC_MSG_ERROR(clisp not enabled)
1059 fi
1060 ;;
1061 cmucl)
1062 if test x"${cmucl}" = xtrue ; then
1063 DEFAULTLISP=cmucl
1064 else
1065 AC_MSG_ERROR(cmucl not enabled)
1066 fi
1067 ;;
1068 scl)
1069 if test x"${scl}" = xtrue ; then
1070 DEFAULTLISP=scl
1071 else
1072 AC_MSG_ERROR(scl not enabled)
1073 fi
1074 ;;
1075 sbcl)
1076 if test x"${sbcl}" = xtrue ; then
1077 DEFAULTLISP=sbcl
1078 else
1079 AC_MSG_ERROR(sbcl not enabled)
1080 fi
1081 ;;
1082 gcl)
1083 if test x"${gcl}" = xtrue ; then
1084 DEFAULTLISP=gcl
1085 else
1086 AC_MSG_ERROR(gcl not enabled)
1087 fi
1088 ;;
1089 acl)
1090 if test x"${acl}" = xtrue ; then
1091 DEFAULTLISP=acl
1092 else
1093 AC_MSG_ERROR(acl not enabled)
1094 fi
1095 ;;
1096 openmcl)
1097 if test x"${openmcl}" = xtrue ; then
1098 DEFAULTLISP=openmcl
1099 else
1100 AC_MSG_ERROR(openmcl not enabled)
1101 fi
1102 ;;
1103 ecl)
1104 if test x"${ecl}" = xtrue ; then
1105 DEFAULTLISP=ecl
1106 else
1107 AC_MSG_ERROR(ecl not enabled)
1108 fi
1109 ;;
1110 ccl64)
1111 if test x"${ccl64}" = xtrue ; then
1112 DEFAULTLISP=ccl64
1113 else
1114 AC_MSG_ERROR(ccl64 not enabled)
1115 fi
1116 ;;
1117 abcl)
1118 if test x"${abcl}" = xtrue ; then
1119 DEFAULTLISP=abcl
1120 else
1121 AC_MSG_ERROR(abcl not enabled)
1122 fi
1123 ;;
1124 *)
1125 AC_MSG_ERROR(Unknown argument ${DEFAULTLISP} to --with-default-lisp)
1126 ;;
1127 esac],
1128 [if test x"${sbcl}" = xtrue ; then
1129 DEFAULTLISP=sbcl
1130 elif test x"${cmucl}" = xtrue ; then
1131 DEFAULTLISP=cmucl
1132 elif test x"${scl}" = xtrue ; then
1133 DEFAULTLISP=scl
1134 elif test x"${clisp}" = xtrue ; then
1135 DEFAULTLISP=clisp
1136 elif test x"${gcl}" = xtrue ; then
1137 DEFAULTLISP=gcl
1138 elif test x"${acl}" = xtrue ; then
1139 DEFAULTLISP=acl
1140 elif test x"${openmcl}" = xtrue ; then
1141 DEFAULTLISP=openmcl
1142 elif test x"${ecl}" = xtrue ; then
1143 DEFAULTLISP=ecl
1144 elif test x"${ccl64}" = xtrue ; then
1145 DEFAULTLISP=ccl64
1146 elif test x"${abcl}" = xtrue ; then
1147 DEFAULTLISP=abcl
1148 else
1149 AC_MSG_ERROR(Internal error. No lisp enabled. Please contact maintainer.)
1150 fi])
1152 AC_SUBST(CLISP_NAME)
1153 AC_SUBST(CLISP_RUNTIME)
1154 AC_SUBST(CLISP_RUNTIME_PATH)
1155 AC_SUBST(CMUCL_NAME)
1156 AC_SUBST(CMUCL_RUNTIME)
1157 AC_SUBST(CMUCL_RUNTIME_PATH)
1158 AC_SUBST(CMUCL_EXEC)
1159 AC_SUBST(SCL_NAME)
1160 AC_SUBST(SCL_RUNTIME)
1161 AC_SUBST(SCL_RUNTIME_PATH)
1162 AC_SUBST(SBCL_NAME)
1163 AC_SUBST(GCL_NAME)
1164 AC_SUBST(ACL_NAME)
1165 AC_SUBST(OPENMCL_NAME)
1166 AC_SUBST(ECL_NAME)
1167 AC_SUBST(CCL64_NAME)
1168 AC_SUBST(DEFAULTLISP)
1169 AC_SUBST(HHC)
1170 AC_SUBST(lisps_enabled)
1171 AC_SUBST(ABCL_JAR)
1172 AC_SUBST(JRE)
1174 AC_ARG_WITH(posix-shell,
1175 [ --with-posix-shell=<path> Use <shell> for maxima script (default /bin/sh)],
1176 [posix_shell_list="${withval}"],
1177 [posix_shell_list="/bin/sh /bin/bash /usr/bin/bash /usr/local/bin/bash"])
1179 AC_ARG_WITH(wish,
1180 [ --with-wish=<prog> Use <prog> for Tk wish shell (default wish)],
1181 [WISH="${withval}"],
1182 [WISH="wish"])
1183 AC_SUBST(WISH)
1186 AC_MSG_CHECKING(POSIX shell to see that it contains getopts)
1187 cat <<EOF > conftest-posix-shell.sh
1188 getopts "ab:" opt
1189 result="\$?"
1190 echo "result is \$result"
1191 exit "\$result"
1192 EOF
1193 POSIX_SHELL=""
1194 for shell in $posix_shell_list
1195 do
1196 if test -z "$POSIX_SHELL" ; then
1197 echo "trying $shell"
1198 $shell conftest-posix-shell.sh -a > /dev/null 2>&1
1199 if test "$?" = "0" ; then
1200 POSIX_SHELL="$shell"
1201 fi
1202 fi
1203 done
1204 rm -f conftest-posix-shell.sh
1205 if test -n "$POSIX_SHELL" ; then
1206 AC_MSG_RESULT(POSIX shell is $POSIX_SHELL)
1207 else
1208 AC_MSG_WARN(Could not find a shell that supports getopts.
1209 The maxima wrapper script will be unusable. The shell may be specified
1210 with --with-posix-shell=</path/to/shell>)
1211 fi
1212 AC_SUBST(POSIX_SHELL)
1214 if test x"${prefix}" = xNONE ; then
1215 tmp_prefix="/usr/local"
1216 else
1217 tmp_prefix="${prefix}"
1218 fi
1219 if test x"${exec_prefix}" = xNONE ; then
1220 tmp_exec_prefix="${tmp_prefix}"
1221 else
1222 tmp_exec_prefix="${exec_prefix}"
1223 fi
1224 expanded_top_srcdir="$(cd "$top_srcdir" 1>/dev/null 2>/dev/null; pwd)"
1225 expanded_exec_prefix="${tmp_exec_prefix}"
1226 expanded_libdir="$(eval "exec_prefix=\"${tmp_exec_prefix}\";echo ${libdir}")"
1227 expanded_libexecdir="$(eval "exec_prefix=\"${tmp_exec_prefix}\";echo ${libexecdir}")"
1228 expanded_datadir="$(eval "prefix=\"${tmp_prefix}\";datarootdir=\"${datarootdir}\";echo ${datadir}")"
1229 expanded_infodir="$(eval "prefix=\"${tmp_prefix}\";datarootdir=\"${datarootdir}\";echo ${infodir}")"
1232 dnl Find all the directories in share, but remove the share directory
1233 dnl itself and all CVS directories (if any) and fortran directories
1234 dnl and *.t2p directories (created when generating pdf documentation).
1235 dnl Remove the leading "share" part of the path, and add double-quotes
1236 dnl around it.
1238 #default_sharedirs=`find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\); "\1" \\\\;' | sed '$s;\\\\;;'`
1239 default_sharedirs=`cd $srcdir;find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\);"\1";' | tr '\n' ' '`
1241 AC_SUBST(top_srcdir)
1242 AC_SUBST(abs_top_builddir)
1243 AC_SUBST(abs_top_srcdir)
1244 AC_SUBST(top_builddir)
1245 AC_SUBST(expanded_top_srcdir)
1246 AC_SUBST(expanded_exec_prefix)
1247 AC_SUBST(expanded_libdir)
1248 AC_SUBST(expanded_libexecdir)
1249 AC_SUBST(expanded_datadir)
1250 AC_SUBST(expanded_infodir)
1251 default_layout_autotools="true"
1252 AC_SUBST(default_layout_autotools)
1253 AC_SUBST(LDFLAGS)
1254 AC_SUBST(default_sharedirs)
1256 AC_ARG_WITH(emacs-prefix,
1257 [ --emacs-prefix=<path> Where to install the emacs modes to],
1258 [EMACSDIR="$withval"],
1259 [EMACSDIR="${datarootdir}/emacs/site-lisp"])
1260 AC_SUBST(EMACSDIR)
1262 dnl Tell defsystem that this isn't a lisp-only build
1263 lisp_only_build="nil"
1264 AC_SUBST(lisp_only_build)
1265 dnl Extra files we want to clean from the src dir
1266 if test x"$srcdir" = x"." ; then
1267 DISTCLEAN_EXTRA_SRC_FILES=""
1268 else
1269 DISTCLEAN_EXTRA_SRC_FILES=share_subdirs.lisp
1270 fi
1271 AC_SUBST(DISTCLEAN_EXTRA_SRC_FILES)
1274 dnl Look for grep that can handle long lines and -e.
1275 AC_PROG_EGREP
1276 AC_SUBST(EGREP)
1277 AC_PATH_PROG([CAT],[cat])
1278 AC_PROG_SED
1279 AC_PROG_AWK
1280 AC_SUBST(SED)
1282 # Configure these files and make them executable
1283 AC_CONFIG_FILES([maxima-local], chmod +x maxima-local)
1284 AC_CONFIG_FILES([src/startmaxima_abcl.sh], chmod +x src/startmaxima_abcl.sh)
1285 AC_CONFIG_FILES([xmaxima-local], chmod +x xmaxima-local)
1286 AC_CONFIG_FILES([tests/test.sh], chmod +x tests/test.sh)
1287 AC_CONFIG_FILES([doc/info/build_html.sh], chmod +x doc/info/build_html.sh)
1288 AC_CONFIG_FILES([doc/info/de/build_html.sh], chmod +x doc/info/de/build_html.sh)
1289 AC_CONFIG_FILES([doc/info/ja/build_html.sh], chmod +x doc/info/ja/build_html.sh)
1290 AC_CONFIG_FILES([src/maxima], chmod +x src/maxima)
1291 AC_CONFIG_FILES([src/maxima.bat])
1293 AC_CONFIG_FILES([Makefile maxima.spec maxima.iss \
1294 admin/Makefile src/Makefile src/rmaxima src/autoconf-variables.lisp \
1295 src/share-subdirs_autogenerated.lisp \
1296 lisp-utils/Makefile tests/Makefile doc/Makefile \
1297 crosscompile-windows/Makefile \
1298 doc/emaxima/Makefile doc/info/Makefile doc/info/include-maxima.texi \
1299 desktopintegration/Makefile \
1300 doc/info/texi2html.init \
1301 doc/info/figures/Makefile \
1302 doc/info/de/Makefile \
1303 doc/info/de.utf8/Makefile doc/info/es/Makefile doc/info/es.utf8/Makefile \
1304 doc/info/ja/Makefile \
1305 doc/info/ja/include-maxima.texi \
1306 doc/info/pt/Makefile doc/info/pt.utf8/Makefile \
1307 doc/info/pt/include-maxima.texi \
1308 doc/info/pt_BR/Makefile doc/info/pt_BR.utf8/Makefile \
1309 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 \
1310 doc/share/Makefile interfaces/Makefile interfaces/emacs/Makefile \
1311 interfaces/emacs/emaxima/Makefile interfaces/emacs/imaxima/Makefile \
1312 interfaces/emacs/misc/Makefile interfaces/xmaxima/Makefile \
1313 interfaces/xmaxima/autoconf-variables.tcl interfaces/xmaxima/Tkmaxima/Header.tcl \
1314 interfaces/xmaxima/doc/Makefile interfaces/xmaxima/doc/figures/Makefile \
1315 interfaces/xmaxima/msgs/Makefile interfaces/xmaxima/win32/Makefile \
1316 plotting/mgnuplot share/Makefile demo/Makefile plotting/Makefile locale/Makefile \
1317 share/contrib/Makefile share/contrib/integration/Makefile \
1318 share/contrib/maxima-odesolve/Makefile \
1319 share/contrib/symplectic_ode/Makefile \
1320 share/draw/Makefile share/logic/Makefile doc/info/es/include-maxima.texi \
1321 src/lisp])
1322 AC_OUTPUT
1324 # The default of 4096 is sometimes too little for the test suite.
1325 if test x"${sbcl}" = xtrue ; then
1326 AC_MSG_CHECKING(Testing if sbcl complains if we try to enlarge the thread-local storage)
1327 echo "(quit)" | ${SBCL_NAME} --tls-limit 8192 > /dev/null 2>&1
1328 if test "$?" = "0" ; then
1329 SBCL_EXTRA_ARGS="--tls-limit 8192"
1330 AC_MSG_RESULT(Yes)
1331 else
1332 SBCL_EXTRA_ARGS=""
1333 AC_MSG_RESULT(No)
1334 fi
1335 fi
1336 AC_SUBST(SBCL_EXTRA_ARGS)
1338 if test x"${clisp}" = xtrue ; then
1339 echo
1340 AC_MSG_WARN("CLISP 2.49 is known to sporadically produce garbled data if the front-end is fast enough to acknowledge a data packet while a next data packet is still being prepared.")
1341 fi
1342 echo
1343 echo "Summary:"
1344 if test x"${clisp}" = xtrue ; then
1345 echo "Compiling a maxima image using \"${CLISP_NAME}\"",
1346 echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
1347 if test x"${clisp_exec}" = xtrue ; then
1348 echo "clisp executable image enabled for maxima."
1349 else
1350 echo Use "--enable-clisp-exec to build a standalone executable instead."
1351 fi
1352 fi
1353 if test x"${cmucl}" = xtrue ; then
1354 echo "Compiling a maxima image using \"${CMUCL_NAME}\""
1355 echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
1356 if test x"${cmucl_exec}" = xtrue; then
1357 echo "CMUCL executable image enabled for maxima."
1358 else
1359 echo Use "--enable-cmucl-exec to build a standalone executable instead."
1360 fi
1361 fi
1362 if test x"${scl}" = xtrue ; then
1363 echo "SCL enabled, using \"${SCL_NAME}\""
1364 echo "SCL runtime is \"${SCL_RUNTIME_PATH}\""
1365 fi
1366 if test x"${sbcl}" = xtrue ; then
1367 echo "Compiling a maxima image using \"${SBCL_NAME}\""
1368 if test x"${sbcl_exec}" = xtrue ; then
1369 echo "sbcl executable image enabled for maxima."
1370 else
1371 echo Use "--enable-sbcl-exec to build a standalone executable instead."
1372 fi
1373 fi
1374 if test x"${gcl}" = xtrue ; then
1375 echo "Compiling a maxima image using \"${GCL_NAME}\""
1376 if test x"${gcl_alt_link}" = xtrue ; then
1377 echo " GCL alternative linking method enabled."
1378 fi
1379 fi
1380 if test x"${acl}" = xtrue ; then
1381 echo "ACL enabled. Executable name: \"${ACL_NAME}\""
1382 fi
1383 if test x"${openmcl}" = xtrue ; then
1384 echo "Compiling a maxima image using \"${OPENMCL_NAME}\""
1385 if test x"${openmcl_exec}" = xtrue ; then
1386 echo "OpenMCL executable image enabled for maxima."
1387 else
1388 echo Use "--enable-openmcl-exec to build a standalone executable instead."
1389 fi
1390 fi
1391 if test x"${ccl64}" = xtrue ; then
1392 echo "Compiling a maxima image using \"${CCL64_NAME}\""
1393 if test x"${ccl64_exec}" = xtrue ; then
1394 echo "CCL64 executable image enabled for maxima."
1395 else
1396 echo Use "--enable-ccl64-exec to build a standalone executable instead."
1397 fi
1398 fi
1400 if test x"${ecl}" = xtrue ; then
1401 if test x"$srcdir" = x"." ; then
1402 echo "Compiling maxima using \"${ECL_NAME}\""
1403 else
1404 echo "ECL enabled. Executable name: \"${ECL_NAME}\""
1405 AC_MSG_ERROR(For ECL out-of-tree builds aren't supported. See src/maxima.system for details.)
1406 fi
1407 fi
1409 if test x"${abcl}" = xtrue ; then
1410 if test x"$srcdir" = x"." ; then
1411 echo "Compiling maxima using \"${ABCL_JAR}\""
1412 else
1413 echo "ABCL enabled. ABCL jarfile: \"${ABCL_JAR}\""
1414 AC_MSG_ERROR(For ABCL out-of-tree builds aren't supported. See src/maxima.system for details.)
1415 fi
1416 fi
1418 echo "default lisp: $DEFAULTLISP"
1419 echo "wish executable name: \"${WISH}\""
1421 if test x"${chm}" = xtrue ; then
1422 echo "CHM help files enabled"
1423 echo " HHC: \"${HHC}\""
1424 fi
1425 if test x"${xmaxima_exe}" = xtrue ; then
1426 echo "Windows xmaxima.exe enabled"
1427 echo " GCC version GCCVER: ${GCCVER}"
1428 echo " TCLKITSH: ${TCLKITSH}"
1429 if ! test -f "${TCLKITSH}" ; then
1430 AC_MSG_WARN(*** TCLKITSH ${TCLKITSH} not found)
1431 xmaxima_exe_prerequisite=notfound
1432 fi
1433 echo " TCLKIT_RUNTIME: ${TCLKIT_RUNTIME}"
1434 if ! test -f "${TCLKIT_RUNTIME}" ; then
1435 AC_MSG_WARN(*** TCLKIT_RUNTIME ${TCLKIT_RUNTIME} not found)
1436 xmaxima_exe_prerequisite=notfound
1437 fi
1438 echo " SDXKIT: ${SDXKIT}"
1439 if ! test -f "${SDXKIT}" ; then
1440 AC_MSG_WARN(*** SDXKIT ${SDXKIT} not found)
1441 xmaxima_exe_prerequisite=notfound
1442 fi
1443 echo " IMGKIT: ${IMGKIT}"
1444 if ! test -f "${IMGKIT}" ; then
1445 AC_MSG_WARN(*** IMGKIT ${IMGKIT} not found)
1446 xmaxima_exe_prerequisite=notfound
1447 fi
1448 if test x${xmaxima_exe_prerequisite} = xnotfound ; then
1449 AC_MSG_WARN([A prerequisite for xmaxima.exe not found. The missing components can be defined on the make command line.])
1450 fi
1451 fi