| blob | 3af7c01de6dc436e62a28c86d753fc60725ec0b4 |
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.35post])
12 AC_CONFIG_SRCDIR([src/macsys.lisp])
13 AM_INIT_AUTOMAKE([-Wno-portability])
15 AM_PATH_LISPDIR
17 AC_CANONICAL_HOST
19 dnl Don't use AC_EXEEXT as that requires a C compiler
20 case "$host" in
21 *mingw*)
22 win32=true
23 mingw=true
24 EXEEXT=.exe
25 ;;
26 *cygwin*)
27 win32=true
28 mingw=false
29 EXEEXT=.exe
30 ;;
31 *)
32 win32=false
33 mingw=false
34 EXEEXT=
35 esac
36 AC_SUBST(EXEEXT)
37 AC_SUBST(win32)
38 AM_CONDITIONAL(WIN32, test x$win32 = xtrue)
40 explicit_lisp=false
41 lisps_enabled=""
43 dnl n.b. clisp_default_name is hardcoded in "with" message
44 clisp_default_name=clisp
45 AC_ARG_ENABLE(clisp,
46 [ --enable-clisp Use clisp],
47 [case "${enableval}" in
48 yes) clisp=true
49 lisps_enabled="${lisps_enabled} clisp"
50 explicit_lisp=true ;;
51 no) clisp=false ;;
52 *) AC_MSG_ERROR(bad value ${enableval} for --enable-clisp) ;;
53 esac
54 explicit_lisp=true],
55 [clisp=false])
56 AC_ARG_WITH(clisp,
57 [ --with-clisp=<prog> Use clisp executable <prog> (default clisp)],
58 [clisp=true
59 lisps_enabled="${lisps_enabled} clisp"
60 explicit_lisp=true
61 if test "$withval" = "yes"; then
62 CLISP_NAME="${clisp_default_name}"
63 else
64 CLISP_NAME="$withval"
65 fi],
66 [CLISP_NAME=${clisp_default_name}])
67 if test x"${win32}" = x"true" ; then
68 CLISP_RUNTIME="lisp.exe"
69 else
70 CLISP_RUNTIME="lisp.run"
71 fi
72 AC_ARG_WITH(clisp-runtime,
73 [ --with-clisp-runtime=<path> Use clisp runtime <path> (default
74 *lib-directory*/base/lisp.run on unix,
75 *lib-directory*\\lisp.exe on windows) ],
76 [clisp=true
77 lisps_enabled="${lisps_enabled} clisp"
78 CLISP_RUNTIME_PATH="$withval"
79 CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`],
80 [])
81 AC_ARG_ENABLE(clisp-exec,
82 [ --enable-clisp-exec Create a maxima executable image using CLISP.
83 No check is made if the version of
84 CLISP supports executable images],
85 [case "${enableval}" in
86 yes) clisp_exec=true
87 clisp=true
88 lisps_enabled="${lisps_enabled} clisp"
89 explicit_lisp=true ;;
90 no) clisp_exec=false ;;
91 *) AC_MSG_ERROR(bad value ${enableval} for --enable-clisp-exec) ;;
92 esac
93 CLISP_EXEC=${clisp_exec}],
94 [clisp_exec=false
95 CLISP_EXEC=false])
96 if test x"${clisp}" = xtrue ; then
97 if test `echo "$CLISP_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
98 if test -x "$CLISP_NAME" ; then
99 clisp_found=true
100 else
101 clisp_found=false
102 fi
103 else
104 AC_CHECK_PROG(clisp_found,$CLISP_NAME,true,false)
105 fi
106 if test x"${clisp_found}" = xfalse ; then
107 AC_MSG_WARN(clisp executable ${CLISP_NAME} not found in PATH)
108 fi
109 fi
112 dnl See if git exists. If it does, update VERSION to include a git tag
113 AC_CHECK_PROG(git_found, git, true, false)
114 if test x"${git_found}" = xtrue; then
115 # Test to see if git describe works (discarding any output). If
116 # it works, use it. Otherwise, keep existing value of VERSION.
117 # (git describe fails if git is executed in a non-Git directory, e.g.,
118 # an unpacked tarball. Since the exit codes of git describe are undocumented,
119 # we cannot distinguish that from a missing annotated tag.
120 # Play it safe by refusing to change VERSION.)
121 if git describe > /dev/null 2>&1; then
122 VERSION="`git describe --dirty`"
123 # When building RPMs, hyphens in the version are not allowed, so
124 # replace them with underscores.
125 VERSION=`echo $VERSION | sed 's;-;_;g'`
126 fi
127 fi
129 dnl Parses the version number for the manual
130 manual_version=`echo $VERSION | sed 's+branch_++; s+_base++; s+_dirty++; s+_+.+g'`
131 AC_SUBST(manual_version)
133 dnl n.b. cmucl_default_name is hardcoded in "with" message
134 cmucl_default_name=lisp
135 CMUCL_RUNTIME=lisp
136 AC_ARG_ENABLE(cmucl,
137 [ --enable-cmucl Use CMUCL],
138 [case "${enableval}" in
139 yes) cmucl=true
140 lisps_enabled="${lisps_enabled} cmucl"
141 explicit_lisp=true ;;
142 no) cmucl=false ;;
143 *) AC_MSG_ERROR(bad value ${enableval} for --enable-cmucl) ;;
144 esac
145 explicit_lisp=true],
146 [cmucl=false])
147 AC_ARG_WITH(cmucl,
148 [ --with-cmucl=<prog> Use CMUCL executable <prog> (default lisp)],
149 [cmucl=true
150 lisps_enabled="${lisps_enabled} cmucl"
151 explicit_lisp=true
152 if test "$withval" = "yes"; then
153 CMUCL_NAME="${cmucl_default_name}"
154 else
155 CMUCL_NAME="$withval"
156 fi],
157 [CMUCL_NAME=${cmucl_default_name}])
158 AC_ARG_WITH(cmucl-runtime,
159 [ --with-cmucl-runtime=<path> Use CMUCL runtime <path> (default
160 *cmucl-lib*/../bin/lisp)],
161 [cmucl=true
162 lisps_enabled="${lisps_enabled} cmucl"
163 CMUCL_RUNTIME_PATH="$withval"
164 CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`],
165 [])
166 AC_ARG_ENABLE(cmucl-exec,
167 [ --enable-cmucl-exec Create a maxima executable image using CMUCL.
168 No check is made if the version of
169 CMUCL supports executable images],
170 [case "${enableval}" in
171 yes) cmucl_exec=true
172 cmucl=true
173 lisps_enabled="${lisps_enabled} cmucl"
174 explicit_lisp=true ;;
175 no) cmucl_exec=false ;;
176 *) AC_MSG_ERROR(bad value ${enableval} for --enable-cmucl-exec) ;;
177 esac
178 CMUCL_EXEC=${cmucl_exec}],
179 [cmucl_exec=false
180 CMUCL_EXEC=false])
181 if test x"${cmucl}" = xtrue ; then
182 if test `echo "$CMUCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
183 if test -x "$CMUCL_NAME" ; then
184 cmucl_found=true
185 else
186 cmucl_found=false
187 fi
188 else
189 AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
190 fi
191 AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
192 if test x"${cmucl_found}" = xfalse ; then
193 AC_MSG_WARN(cmucl executable ${CMUCL_NAME} not found in PATH)
194 fi
195 fi
197 dnl n.b. scl_default_name is hardcoded in "with" message
198 scl_default_name=scl
199 SCL_RUNTIME=lisp
200 AC_ARG_ENABLE(scl,
201 [ --enable-scl Use SCL],
202 [case "${enableval}" in
203 yes) scl=true
204 lisps_enabled="${lisps_enabled} scl"
205 explicit_lisp=true ;;
206 no) scl=false ;;
207 *) AC_MSG_ERROR(bad value ${enableval} for --enable-scl) ;;
208 esac
209 explicit_lisp=true],
210 [scl=false])
211 AC_ARG_WITH(scl,
212 [ --with-scl=<prog> Use SCL executable <prog> (default scl)],
213 [scl=true
214 lisps_enabled="${lisps_enabled} scl"
215 explicit_lisp=true
216 if test "$withval" = "yes"; then
217 SCL_NAME="${scl_default_name}"
218 else
219 SCL_NAME="$withval"
220 fi],
221 [SCL_NAME=${scl_default_name}])
222 AC_ARG_WITH(scl-runtime,
223 [ --with-scl-runtime=<path> Use SCL runtime <path> (default
224 file://library/../bin/lisp)],
225 [scl=true
226 lisps_enabled="${lisps_enabled} scl"
227 SCL_RUNTIME_PATH="$withval"
228 SCL_RUNTIME=`basename ${SCL_RUNTIME_PATH}`],
229 [])
230 if test x"${scl}" = xtrue ; then
231 if test `echo "$SCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
232 if test -x "$SCL_NAME" ; then
233 scl_found=true
234 else
235 scl_found=false
236 fi
237 else
238 AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
239 fi
240 AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
241 if test x"${scl_found}" = xfalse ; then
242 AC_MSG_WARN(scl executable ${SCL_NAME} not found in PATH)
243 fi
244 fi
246 dnl n.b. sbcl_default_name is hardcoded in "with" message
247 sbcl_default_name=sbcl
248 AC_ARG_ENABLE(sbcl,
249 [ --enable-sbcl Use SBCL],
250 [case "${enableval}" in
251 yes) sbcl=true
252 lisps_enabled="${lisps_enabled} sbcl"
253 explicit_lisp=true ;;
254 no) sbcl=false ;;
255 *) AC_MSG_ERROR(bad value ${enableval} for --enable-sbcl) ;;
256 esac
257 explicit_lisp=true],
258 [sbcl=false])
259 AC_ARG_WITH(sbcl,
260 [ --with-sbcl=<prog> Use SBCL executable <prog> (default sbcl)],
261 [sbcl=true
262 lisps_enabled="${lisps_enabled} sbcl"
263 explicit_lisp=true
264 if test "$withval" = "yes"; then
265 SBCL_NAME="${sbcl_default_name}"
266 else
267 SBCL_NAME="$withval"
268 fi],
269 [SBCL_NAME="${sbcl_default_name}"])
270 AC_ARG_ENABLE(sbcl-exec,
271 [ --enable-sbcl-exec Create a maxima executable image using SBCL.
272 No check is made if the version of
273 SBCL supports executable images],
274 [case "${enableval}" in
275 yes) sbcl_exec=true
276 sbcl=true
277 lisps_enabled="${lisps_enabled} sbcl"
278 explicit_lisp=true ;;
279 no) sbcl_exec=false ;;
280 *) AC_MSG_ERROR(bad value ${enableval} for --enable-sbcl-exec) ;;
281 esac
282 SBCL_EXEC=${sbcl_exec}],
283 [sbcl_exec=false
284 SBCL_EXEC=false])
285 if test x"${sbcl}" = xtrue ; then
286 if test `echo "$SBCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
287 if test -x "$SBCL_NAME" ; then
288 sbcl_found=true
289 else
290 sbcl_found=false
291 fi
292 else
293 AC_CHECK_PROG(sbcl_found,"$SBCL_NAME",true,false)
294 fi
295 AC_CHECK_PROG(sbcl_found,"$SBCL_NAME",true,false)
296 if test x"${sbcl_found}" = xfalse ; then
297 AC_MSG_WARN(sbcl executable "${SBCL_NAME}" not found in PATH)
298 fi
299 fi
301 dnl n.b. acl_default_name is hardcoded in "with" message
302 acl_default_name=lisp
303 AC_ARG_ENABLE(acl,
304 [ --enable-acl Use ACL],
305 [case "${enableval}" in
306 yes) acl=true
307 lisps_enabled="${lisps_enabled} acl"
308 explicit_lisp=true ;;
309 no) acl=false ;;
310 *) AC_MSG_ERROR(bad value ${enableval} for --enable-acl) ;;
311 esac
312 explicit_lisp=true],
313 [acl=false])
314 AC_ARG_WITH(acl,
315 [ --with-acl=<prog> Use ACL executable <prog> (default lisp)],
316 [acl=true
317 lisps_enabled="${lisps_enabled} acl"
318 explicit_lisp=true
319 if test "$withval" = "yes"; then
320 ACL_NAME="${acl_default_name}"
321 else
322 ACL_NAME="$withval"
323 fi],
324 [ACL_NAME=${acl_default_name}])
325 if test x"${acl}" = xtrue ; then
326 if test `echo "$ACL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
327 if test -x "$ACL_NAME" ; then
328 acl_found=true
329 else
330 acl_found=false
331 fi
332 else
333 AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
334 fi
335 AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
336 if test x"${acl_found}" = xfalse ; then
337 AC_MSG_WARN(acl executable ${ACL_NAME} not found in PATH)
338 fi
339 fi
341 dnl n.b. gcl_default_name is hardcoded in "with" message
342 gcl_default_name=gcl
343 AC_ARG_ENABLE(gcl,
344 [ --enable-gcl Use GCL],
345 [case "${enableval}" in
346 yes) gcl=true
347 lisps_enabled="${lisps_enabled} gcl"
348 explicit_lisp=true;;
349 no) gcl=false ;;
350 *) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl) ;;
351 esac],
352 [gcl=false])
353 AC_ARG_WITH(gcl,
354 [ --with-gcl=<prog> Use GCL executable <prog> (default gcl)],
355 [gcl=true
356 lisps_enabled="${lisps_enabled} gcl"
357 explicit_lisp=true
358 if test "$withval" = "yes"; then
359 GCL_NAME="${gcl_default_name}"
360 else
361 GCL_NAME="$withval"
362 fi],
363 [GCL_NAME=${gcl_default_name}])
364 if test x"${gcl}" = xtrue ; then
365 if test `echo "$GCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
366 if test -x "$GCL_NAME" ; then
367 gcl_found=true
368 else
369 gcl_found=false
370 fi
371 else
372 AC_CHECK_PROG(gcl_found,$GCL_NAME,true,false)
373 fi
374 if test x"${gcl_found}" = xfalse ; then
375 AC_MSG_WARN(gcl executable ${GCL_NAME} not found in PATH)
376 fi
377 fi
379 dnl n.b. openmcl_default_name is hardcoded in "with" message
380 openmcl_default_name=openmcl
381 AC_ARG_ENABLE(openmcl,
382 [ --enable-openmcl Use OpenMCL],
383 [case "${enableval}" in
384 yes) openmcl=true
385 lisps_enabled="${lisps_enabled} openmcl"
386 explicit_lisp=true;;
387 no) openmcl=false ;;
388 *) AC_MSG_ERROR(bad value ${enableval} for --enable-openmcl) ;;
389 esac],
390 [openmcl=false])
391 AC_ARG_WITH(openmcl,
392 [ --with-openmcl=<prog> Use OpenMCL executable <prog> (default openmcl)],
393 [openmcl=true
394 lisps_enabled="${lisps_enabled} openmcl"
395 explicit_lisp=true
396 if test "$withval" = "yes"; then
397 OPENMCL_NAME="${openmcl_default_name}"
398 else
399 OPENMCL_NAME="$withval"
400 fi],
401 [OPENMCL_NAME=${openmcl_default_name}])
402 AC_ARG_ENABLE(openmcl-exec,
403 [ --enable-openmcl-exec Create a maxima executable image using OPENMCL.
404 No check is made if the version of
405 OPENMCL supports executable images],
406 [case "${enableval}" in
407 yes) openmcl_exec=true
408 openmcl=true
409 lisps_enabled="${lisps_enabled} openmcl"
410 explicit_lisp=true;;
411 no) openmcl_exec=false ;;
412 *) AC_MSG_ERROR(bad value ${enableval} for --enable-openmcl-exec) ;;
413 esac
414 OPENMCL_EXEC=${openmcl_exec}],
415 [openmcl_exec=false
416 OPENMCL_EXEC=false])
418 dnl Define ccl as an alias (essentially) for openmcl
419 AC_ARG_ENABLE(ccl,
420 [ --enable-ccl Use CCL (Clozure Common Lisp)],
421 [case "${enableval}" in
422 yes) openmcl=true
423 lisps_enabled="${lisps_enabled} openmcl"
424 explicit_lisp=true;;
425 no) openmcl=false ;;
426 *) AC_MSG_ERROR(bad value ${enableval} for --enable-ccl) ;;
427 esac],
428 [openmcl=false])
429 AC_ARG_WITH(ccl,
430 [ --with-ccl=<prog> Use OpenMCL executable <prog> (default ccl)],
431 [openmcl=true
432 lisps_enabled="${lisps_enabled} openmcl"
433 explicit_lisp=true
434 if test "$withval" = "yes"; then
435 OPENMCL_NAME="${openmcl_default_name}"
436 else
437 OPENMCL_NAME="$withval"
438 fi],
439 [OPENMCL_NAME=${openmcl_default_name}])
440 AC_ARG_ENABLE(ccl-exec,
441 [ --enable-ccl-exec Create a maxima executable image using CCL.
442 No check is made if the version of
443 CCL supports executable images],
444 [case "${enableval}" in
445 yes) openmcl_exec=true
446 openmcl=true
447 lisps_enabled="${lisps_enabled} openmcl"
448 explicit_lisp=true;;
449 no) openmcl_exec=false ;;
450 *) AC_MSG_ERROR(bad value ${enableval} for --enable-ccl-exec) ;;
451 esac
452 OPENMCL_EXEC=${openmcl_exec}],
453 [openmcl_exec=false
454 OPENMCL_EXEC=false])
456 if test x"${openmcl}" = xtrue ; then
457 if test `echo "$OPENMCL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
458 if test -x "$OPENMCL_NAME" ; then
459 openmcl_found=true
460 else
461 openmcl_found=false
462 fi
463 else
464 AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
465 fi
466 if test x"${openmcl_found}" = xfalse ; then
467 AC_MSG_WARN(openmcl executable ${OPENMCL_NAME} not found in PATH)
468 fi
469 fi
471 dnl n.b. ecl_default_name is hardcoded in "with" message
472 ecl_default_name=ecl
473 AC_ARG_ENABLE(ecl,
474 [ --enable-ecl Use ECL],
475 [case "${enableval}" in
476 yes) ecl=true
477 lisps_enabled="${lisps_enabled} ecl"
478 explicit_lisp=true;;
479 no) ecl=false ;;
480 *) AC_MSG_ERROR(bad value ${enableval} for --enable-ecl) ;;
481 esac],
482 [ecl=false])
483 AC_ARG_WITH(ecl,
484 [ --with-ecl=<prog> Use ECL executable <prog> (default ecl)],
485 [ecl=true
486 lisps_enabled="${lisps_enabled} ecl"
487 explicit_lisp=true
488 if test "$withval" = "yes"; then
489 ECL_NAME="${ecl_default_name}"
490 else
491 ECL_NAME="$withval"
492 fi],
493 [ECL_NAME=${ecl_default_name}])
494 if test x"${ecl}" = xtrue ; then
495 if test `echo "$ECL_NAME" | sed 's/\(.\).*/\1/'` = "/" ; then
496 if test -x "$ECL_NAME" ; then
497 ecl_found=true
498 else
499 ecl_found=false
500 fi
501 else
502 AC_CHECK_PROG(ecl_found,$ECL_NAME,true,false)
503 fi
504 if test x"${ecl_found}" = xfalse ; then
505 AC_MSG_WARN(ecl executable ${ECL_NAME} not found in PATH)
506 fi
507 fi
509 dnl xgettext
510 AC_ARG_ENABLE(gettext,
511 [ --enable-gettext Locale support],
512 [case "${enableval}" in
513 yes) enable_gettext=true ;;
514 no) enable_gettext=false ;;
515 *) AC_MSG_ERROR(bad value ${enableval} for --enable-gettext) ;;
516 esac],
517 [enable_gettext=false])
520 AM_CONDITIONAL(ENABLE_GETTEXT, test x$enable_gettext = xtrue)
522 dnl languages
523 AC_ARG_ENABLE(lang-de,
524 [ --enable-lang-de German language support],
525 [case "${enableval}" in
526 yes) lang_de=true ;;
527 no) lang_de=false ;;
528 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-de) ;;
529 esac],
530 [lang_de=false])
532 AM_CONDITIONAL(LANG_DE, test x$lang_de = xtrue)
534 AC_ARG_ENABLE(lang-de-utf8,
535 [ --enable-lang-de-utf8 German language support (UTF-8)],
536 [case "${enableval}" in
537 yes) lang_de_utf8=true ;;
538 no) lang_de_utf8=false ;;
539 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-de-utf8) ;;
540 esac],
541 [lang_de_utf8=false])
543 AM_CONDITIONAL(LANG_DE_UTF8, test x$lang_de_utf8 = xtrue)
545 AC_ARG_ENABLE(lang-es,
546 [ --enable-lang-es Spanish language support],
547 [case "${enableval}" in
548 yes) lang_es=true ;;
549 no) lang_es=false ;;
550 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-es) ;;
551 esac],
552 [lang_es=false])
554 AC_SUBST(lang_es)
555 AM_CONDITIONAL(LANG_ES, test x$lang_es = xtrue)
557 AC_ARG_ENABLE(lang-es-utf8,
558 [ --enable-lang-es-utf8 Spanish language support (UTF-8)],
559 [case "${enableval}" in
560 yes) lang_es_utf8=true ;;
561 no) lang_es_utf8=false ;;
562 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-es-utf8) ;;
563 esac],
564 [lang_es_utf8=false])
566 AM_CONDITIONAL(LANG_ES_UTF8, test x$lang_es_utf8 = xtrue)
568 AC_ARG_ENABLE(lang-pt,
569 [ --enable-lang-pt Portuguese language support],
570 [case "${enableval}" in
571 yes) lang_pt=true ;;
572 no) lang_pt=false ;;
573 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt) ;;
574 esac],
575 [lang_pt=false])
577 AC_SUBST(lang_pt)
578 AM_CONDITIONAL(LANG_PT, test x$lang_pt = xtrue)
580 AC_ARG_ENABLE(lang-pt-utf8,
581 [ --enable-lang-pt-utf8 Portuguese language support (UTF-8)],
582 [case "${enableval}" in
583 yes) lang_pt_utf8=true ;;
584 no) lang_pt_utf8=false ;;
585 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt-utf8) ;;
586 esac],
587 [lang_pt_utf8=false])
589 AM_CONDITIONAL(LANG_PT_UTF8, test x$lang_pt_utf8 = xtrue)
591 AC_ARG_ENABLE(lang-pt_BR,
592 [ --enable-lang-pt_BR Brazilian Portuguese language support],
593 [case "${enableval}" in
594 yes) lang_pt_br=true ;;
595 no) lang_pt_br=false ;;
596 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt_BR) ;;
597 esac],
598 [lang_pt_br=false])
600 AC_SUBST(lang_pt_br)
601 AM_CONDITIONAL(LANG_PT_BR, test x$lang_pt_br = xtrue)
603 AC_ARG_ENABLE(lang-pt_BR-utf8,
604 [ --enable-lang-pt_BR-utf8 Brazilian Portuguese language support (UTF-8)],
605 [case "${enableval}" in
606 yes) lang_pt_br_utf8=true ;;
607 no) lang_pt_br_utf8=false ;;
608 *) AC_MSG_ERROR(bad value ${enableval} for --enable-lang-pt_BR-utf8) ;;
609 esac],
610 [lang_pt_br_utf8=false])
612 AM_CONDITIONAL(LANG_PT_BR_UTF8, test x$lang_pt_br_utf8 = xtrue)
614 AC_ARG_ENABLE(recode,
615 [ --enable-recode Use recode for charset conversion],
616 [case "${enableval}" in
617 yes) use_recode=true ;;
618 no) use_recode=false ;;
619 *) AC_MSG_ERROR(bad value ${enableval} for --enable-recode) ;;
620 esac],
621 [use_recode=false])
623 dnl iconv and/or recode
624 AC_CHECK_PROG(iconv_found,iconv,true,false)
625 AC_CHECK_PROG(recode_found,recode,true,false)
627 if test x"${use_recode}" = xtrue ; then
628 if test x"${recode_found}" = xfalse ; then
629 AC_MSG_ERROR(No recode found)
630 fi
631 elif test x"${iconv_found}" = xfalse ; then
632 use_recode=true
633 else
634 use_recode=false
635 fi
637 AM_CONDITIONAL(USE_RECODE, test x$use_recode = xtrue)
639 dnl Optionally build the windows CHM help files
640 dnl default to false as requires win32 and Microsoft HTML Help Workshop
641 AC_ARG_ENABLE(chm,
642 [ --enable-chm Build Windows CHM help files],
643 [case "${enableval}" in
644 yes) chm=true ;;
645 no) chm=false ;;
646 *) AC_MSG_ERROR(bad value ${enableval} for --enable-chm) ;;
647 esac],
648 [chm=false])
649 AM_CONDITIONAL(CHM, test x$chm = xtrue)
650 dnl hhc is the HTML Help Compiler for CHM documentation
651 hhc_default_name=hhc$EXEEXT
652 AC_ARG_WITH(hhc,
653 [ --with-hhc=<prog> Use HTML Help Compiler executable <prog> (default hhc)],
654 [hhc=true
655 if test "$withval" = "yes"; then
656 HHC="${hhc_default_name}"
657 else
658 HHC="$withval"
659 fi],
660 [HHC="${hhc_default_name}"])
662 # Check that hhc exists, using AC_CHECK_PROG
663 if test x$chm = xtrue; then
664 if test -x "${HHC}"; then
665 # HHC was a path to the executable, and it existed, which is
666 # great! We still say something to the caller, since this is
667 # probably less confusing.
668 AC_MSG_CHECKING([for hhc])
669 AC_MSG_RESULT([yes])
670 else
671 AC_CHECK_PROG(hhc_found, ${HHC}, yes)
672 if test x"${hhc_found}" != x"yes"; then
673 AC_MSG_ERROR([HTML Help Compiler executable ${HHC} not found])
674 fi
675 fi
676 fi
678 dnl Optionally build xmaxima.exe under windows
679 dnl default to false as additional software
680 AC_ARG_ENABLE(xmaxima_exe,
681 [ --enable-xmaxima-exe Build Windows xmaxima.exe for installer],
682 [case "${enableval}" in
683 yes) xmaxima_exe=true ;;
684 no) xmaxima_exe=false ;;
685 *) AC_MSG_ERROR(bad value ${enableval} for --enable-xmaxima-exe) ;;
686 esac],
687 [xmaxima_exe=false])
688 AM_CONDITIONAL(XMAXIMA_EXE, test x$xmaxima_exe = xtrue)
690 dnl Optionally build xmaxima.exe under windows
691 dnl default to false as additional software
692 AC_ARG_ENABLE(winkill_exe,
693 [ --enable-winkill Build Windows winkill.exe and winkill_lib.dll for installer],
694 [case "${enableval}" in
695 yes) winkill_exe=true ;;
696 no) winkill_exe=false ;;
697 *) AC_MSG_ERROR(bad value ${enableval} for --enable-winkill-exe) ;;
698 esac],
699 [winkill_exe=false])
700 AM_CONDITIONAL(WINKILL_EXE, test x$winkill_exe = xtrue)
702 dnl Tools for building xmaxima.exe on windows
703 dnl Hard code the filenames for now. Can over-ride on make command line
704 GCCVER=undefined
705 if test x${xmaxima_exe} = xtrue ; then
706 GCCVER=`gcc -dumpversion`
707 dnl http://tclkits.rkeene.org/fossil/wiki?name=Downloads
708 dnl and http://www.tcl.tk/starkits/
709 TCLKITSH=/c/programs/star/tclkitsh-8.6.3-win32-ix86.exe
710 TCLKIT_RUNTIME=/c/programs/star/tclkit-8.6.3-win32-ix86.exe
711 SDXKIT=/c/programs/star/sdx.kit
712 IMGKIT=/c/programs/star/img.kit
713 fi
715 AC_SUBST(GCCVER)
716 AC_SUBST(TCLKITSH)
717 AC_SUBST(TCLKIT_RUNTIME)
718 AC_SUBST(SDXKIT)
719 AC_SUBST(IMGKIT)
720 AM_CONDITIONAL(GCC331, test x${GCCVER} = x3.3.1)
722 if test x"${explicit_lisp}" = xfalse ; then
723 dnl See if any of the lisps can be found
724 AC_CHECK_PROG(clisp_found,${clisp_default_name},true,false)
725 AC_CHECK_PROG(gcl_found,${gcl_default_name},true,false)
726 AC_CHECK_PROG(cmucl_found,$CMUCL_NAME,true,false)
727 AC_CHECK_PROG(scl_found,$SCL_NAME,true,false)
728 AC_CHECK_PROG(sbcl_found,$SBCL_NAME,true,false)
729 AC_CHECK_PROG(acl_found,$ACL_NAME,true,false)
730 AC_CHECK_PROG(openmcl_found,$OPENMCL_NAME,true,false)
731 AC_CHECK_PROG(ecl_found,$ECL_NAME,true,false)
733 if test x"${clisp_found}" = xtrue ; then
734 clisp=true
735 lisps_enabled="${lisps_enabled} clisp"
736 elif test x"${gcl_found}" = xtrue ; then
737 gcl=true
738 lisps_enabled="${lisps_enabled} gcl"
739 elif test x"${cmucl_found}" = xtrue ; then
740 cmucl=true
741 lisps_enabled="${lisps_enabled} cmucl"
742 elif test x"${scl_found}" = xtrue ; then
743 scl=true
744 lisps_enabled="${lisps_enabled} scl"
745 elif test x"${sbcl_found}" = xtrue ; then
746 sbcl=true
747 lisps_enabled="${lisps_enabled} sbcl"
748 elif test x"${acl_found}" = xtrue ; then
749 acl=true
750 lisps_enabled="${lisps_enabled} acl"
751 elif test x"${ecl_found}" = xtrue ; then
752 ecl=true
753 lisps_enabled="${lisps_enabled} ecl"
754 else
755 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)
756 fi
757 fi
759 AM_CONDITIONAL(CLISP, test x$clisp = xtrue)
760 AM_CONDITIONAL(CLISP_EXEC, test x$clisp_exec = xtrue)
761 AM_CONDITIONAL(GCL, test x$gcl = xtrue)
762 AM_CONDITIONAL(CMUCL, test x$cmucl = xtrue)
763 AM_CONDITIONAL(CMUCL_EXEC, test x${cmucl_exec} = xtrue)
764 AM_CONDITIONAL(SCL, test x$scl = xtrue)
765 AM_CONDITIONAL(SBCL, test x$sbcl = xtrue)
766 AM_CONDITIONAL(SBCL_EXEC, test x$sbcl_exec = xtrue)
767 AM_CONDITIONAL(ACL, test x$acl = xtrue)
768 AM_CONDITIONAL(OPENMCL, test x$openmcl = xtrue)
769 AM_CONDITIONAL(OPENMCL_EXEC, test x${openmcl_exec} = xtrue)
770 AM_CONDITIONAL(ECL, test x$ecl = xtrue)
772 if test x"${clisp}" = xtrue; then
773 if test x"${CLISP_RUNTIME_PATH}" = x"" ; then
774 if test x"${mingw}" = xtrue ; then
775 CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~a${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
776 else
777 CLISP_RUNTIME_PATH=`${CLISP_NAME} -norc -q -x "(format nil \"~abase/${CLISP_RUNTIME}\" (namestring *lib-directory*))"|sed 's/\"\\(.*\\)\"/\\1/'`
778 fi
779 fi
780 if test -x ${CLISP_RUNTIME_PATH} ; then
781 echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
782 else
783 AC_MSG_ERROR(clisp runtime \"${CLISP_RUNTIME_PATH}\" is not an executable)
784 fi
785 CLISP_RUNTIME=`basename ${CLISP_RUNTIME_PATH}`
786 fi
788 if test x"${cmucl}" = xtrue; then
789 if test x"${CMUCL_RUNTIME_PATH}" = x"" ; then
790 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)'`
791 fi
792 if test -x "${CMUCL_RUNTIME_PATH}" ; then
793 echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
794 else
795 dnl last chance: find CMUCL_NAME in path. Use it if it doesn't appear to
796 dnl be a shell script.
797 cmucl_path=`type -p "${CMUCL_NAME}"`
798 if test x"`grep -c '#!.*bin.*sh.*' ${cmucl_path}`" = x"0" ; then
799 CMUCL_RUNTIME_PATH="${cmucl_path}"
800 else
801 AC_MSG_ERROR([Unable to determine CMUCL runtime path.
802 The best guess for CMUCL runtime, \"${CMUCL_RUNTIME_PATH}\", is not
803 an executable. Use the argument
804 --with-cmucl-runtime=<path>
805 to set the actual CMUCL executable. If the CMUCL lisp command is a shell
806 script the CMUCL executable is the program exec'd by that shell script.])
807 fi
808 fi
809 CMUCL_RUNTIME=`basename ${CMUCL_RUNTIME_PATH}`
811 dnl cmucl final check
812 result=`"${CMUCL_RUNTIME_PATH}" -quiet -eval '(format t "MAXIMA_CMUCL_TEST_SUCCESS%")(quit)'`
813 retval=$?
814 if test ! x"${retval}" = x"0" ; then
815 AC_MSG_ERROR(unable to run cmucl runtime = "${CMUCL_RUNTIME_PATH}".
816 Please specify the full path of the cmucl runtime using the
817 --with-cmucl-runtime=<path>
818 flag.)
819 fi
820 count=`echo "${result}" | grep -c "MAXIMA_CMUCL_TEST_SUCCESS"`
821 if test ! "${count}" = "1" ; then
822 AC_MSG_ERROR(an error occured while checking cmucl runtime)
823 fi
824 fi
826 if test x"${scl}" = xtrue; then
827 if test x"${SCL_RUNTIME_PATH}" = x"" ; then
828 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))'`
829 fi
830 if test -x "${SCL_RUNTIME_PATH}" ; then
831 echo "scl runtime is \"${SCL_RUNTIME_PATH}\""
832 else
833 dnl last chance: find SCL_NAME in path. Use it if it doesn't appear to
834 dnl be a shell script.
835 scl_path=`type -p "${SCL_NAME}"`
836 if test x"`grep -c '#!.*bin.*sh.*' ${scl_path}`" = x"0" ; then
837 SCL_RUNTIME_PATH="${scl_path}"
838 else
839 AC_MSG_ERROR([Unable to determine SCL runtime path.
840 The best guess for SCL runtime, \"${SCL_RUNTIME_PATH}\", is not
841 an executable. Use the argument
842 --with-scl-runtime=<path>
843 to set the actual SCL executable. If the SCL lisp command is a shell
844 script the SCL executable is the program exec'd by that shell script.])
845 fi
846 fi
847 SCL_RUNTIME=`basename ${SCL_RUNTIME_PATH}`
848 fi
850 if test x"${gcl}" = xtrue; then
851 result=`"${GCL_NAME}" -batch -eval '#+ansi-cl (format t "MAXIMA_GCL_ANSI_TEST_SUCCESS~%") #-ansi-cl (format t "MAXIMA_GCL_ANSI_TEST_FAILURE~%")' -eval '(bye)'`
852 retval=$?
853 if test ! x"${retval}" = x"0" ; then
854 AC_MSG_ERROR(unable to run gcl executable \"${GCL_NAME}\".)
855 fi
856 count=`echo "${result}" | grep -c "MAXIMA_GCL_ANSI_TEST_SUCCESS"`
857 if test ! "${count}" = "1" ; then
858 AC_MSG_ERROR([The gcl executable \"${GCL_NAME}\" was not compiled with
859 the --enable-ansi flag, which is required for Maxima.
860 The gcl ANSI-CL check returned
861 \"${result}\".])
862 fi
863 fi
865 AC_ARG_ENABLE(gcl-alt-link,
866 [ --enable-gcl-alt-link Use GCL's alternate linking mechanism],
867 [case "${enableval}" in
868 yes) gcl_alt_link=true ;;
869 no) gcl_alt_link=false ;;
870 *) AC_MSG_ERROR(bad value ${enableval} for --enable-gcl-alt-link) ;;
871 esac],
872 [gcl_alt_link=false])
874 AM_CONDITIONAL(GCL_ALT_LINK, test x$gcl_alt_link = xtrue)
876 AC_ARG_WITH(default-lisp,
877 [ --with-default-lisp=<lisp> Set default lisp implementation to <lisp>],
878 [case "${withval}" in
879 clisp)
880 if test x"${clisp}" = xtrue ; then
881 DEFAULTLISP=clisp
882 else
883 AC_MSG_ERROR(clisp not enabled)
884 fi
885 ;;
886 cmucl)
887 if test x"${cmucl}" = xtrue ; then
888 DEFAULTLISP=cmucl
889 else
890 AC_MSG_ERROR(cmucl not enabled)
891 fi
892 ;;
893 scl)
894 if test x"${scl}" = xtrue ; then
895 DEFAULTLISP=scl
896 else
897 AC_MSG_ERROR(scl not enabled)
898 fi
899 ;;
900 sbcl)
901 if test x"${sbcl}" = xtrue ; then
902 DEFAULTLISP=sbcl
903 else
904 AC_MSG_ERROR(sbcl not enabled)
905 fi
906 ;;
907 gcl)
908 if test x"${gcl}" = xtrue ; then
909 DEFAULTLISP=gcl
910 else
911 AC_MSG_ERROR(gcl not enabled)
912 fi
913 ;;
914 acl)
915 if test x"${acl}" = xtrue ; then
916 DEFAULTLISP=acl
917 else
918 AC_MSG_ERROR(acl not enabled)
919 fi
920 ;;
921 openmcl)
922 if test x"${openmcl}" = xtrue ; then
923 DEFAULTLISP=openmcl
924 else
925 AC_MSG_ERROR(openmcl not enabled)
926 fi
927 ;;
928 ecl)
929 if test x"${ecl}" = xtrue ; then
930 DEFAULTLISP=ecl
931 else
932 AC_MSG_ERROR(ecl not enabled)
933 fi
934 ;;
935 *)
936 AC_MSG_ERROR(Unknown argument ${DEFAULTLISP} to --with-default-lisp)
937 ;;
938 esac],
939 [if test x"${clisp}" = xtrue ; then
940 DEFAULTLISP=clisp
941 elif test x"${cmucl}" = xtrue ; then
942 DEFAULTLISP=cmucl
943 elif test x"${scl}" = xtrue ; then
944 DEFAULTLISP=scl
945 elif test x"${sbcl}" = xtrue ; then
946 DEFAULTLISP=sbcl
947 elif test x"${gcl}" = xtrue ; then
948 DEFAULTLISP=gcl
949 elif test x"${acl}" = xtrue ; then
950 DEFAULTLISP=acl
951 elif test x"${openmcl}" = xtrue ; then
952 DEFAULTLISP=openmcl
953 elif test x"${ecl}" = xtrue ; then
954 DEFAULTLISP=ecl
955 else
956 AC_MSG_ERROR(Internal error. No lisp enabled. Please contact maintainer.)
957 fi])
959 AC_SUBST(CLISP_NAME)
960 AC_SUBST(CLISP_RUNTIME)
961 AC_SUBST(CLISP_RUNTIME_PATH)
962 AC_SUBST(CMUCL_NAME)
963 AC_SUBST(CMUCL_RUNTIME)
964 AC_SUBST(CMUCL_RUNTIME_PATH)
965 AC_SUBST(CMUCL_EXEC)
966 AC_SUBST(SCL_NAME)
967 AC_SUBST(SCL_RUNTIME)
968 AC_SUBST(SCL_RUNTIME_PATH)
969 AC_SUBST(SBCL_NAME)
970 AC_SUBST(GCL_NAME)
971 AC_SUBST(ACL_NAME)
972 AC_SUBST(OPENMCL_NAME)
973 AC_SUBST(ECL_NAME)
974 AC_SUBST(DEFAULTLISP)
975 AC_SUBST(HHC)
976 AC_SUBST(lisps_enabled)
978 AC_ARG_WITH(posix-shell,
979 [ --with-posix-shell=<path> Use <shell> for maxima script (default /bin/sh)],
980 [posix_shell_list="${withval}"],
981 [posix_shell_list="/bin/sh /bin/bash /usr/bin/bash /usr/local/bin/bash"])
983 AC_ARG_WITH(wish,
984 [ --with-wish=<prog> Use <prog> for Tk wish shell (default wish)],
985 [WISH="${withval}"],
986 [WISH="wish"])
987 AC_SUBST(WISH)
990 AC_MSG_CHECKING(POSIX shell to see that it contains getopts)
991 cat <<EOF > conftest-posix-shell.sh
992 getopts "ab:" opt
993 result="\$?"
994 echo "result is \$result"
995 exit "\$result"
996 EOF
997 POSIX_SHELL=""
998 for shell in $posix_shell_list
999 do
1000 if test -z "$POSIX_SHELL" ; then
1001 echo "trying $shell"
1002 $shell conftest-posix-shell.sh -a > /dev/null 2>&1
1003 if test "$?" = "0" ; then
1004 POSIX_SHELL="$shell"
1005 fi
1006 fi
1007 done
1008 rm -f conftest-posix-shell.sh
1009 if test -n "$POSIX_SHELL" ; then
1010 AC_MSG_RESULT(POSIX shell is $POSIX_SHELL)
1011 else
1012 AC_MSG_WARN(Could not find a shell that supports getopts.
1013 The maxima wrapper script will be unusable. The shell may be specified
1014 with --with-posix-shell=</path/to/shell>)
1015 fi
1016 AC_SUBST(POSIX_SHELL)
1018 if test x"${prefix}" = xNONE ; then
1019 tmp_prefix="/usr/local"
1020 else
1021 tmp_prefix="${prefix}"
1022 fi
1023 if test x"${exec_prefix}" = xNONE ; then
1024 tmp_exec_prefix="${tmp_prefix}"
1025 else
1026 tmp_exec_prefix="${exec_prefix}"
1027 fi
1028 expanded_top_srcdir="`(cd \"$top_srcdir\" 1>/dev/null 2>/dev/null; pwd)`"
1029 expanded_exec_prefix="${tmp_exec_prefix}"
1030 expanded_libdir="`eval \"exec_prefix=\\\"${tmp_exec_prefix}\\\";echo ${libdir}\"`"
1031 expanded_libexecdir="`eval \"exec_prefix=\\\"${tmp_exec_prefix}\\\";echo ${libexecdir}\"`"
1032 expanded_datadir="`eval \"prefix=\\\"${tmp_prefix}\\\";datarootdir=\\\"${datarootdir}\\\";echo ${datadir}\"`"
1033 expanded_infodir="`eval \"prefix=\\\"${tmp_prefix}\\\";datarootdir=\\\"${datarootdir}\\\";echo ${infodir}\"`"
1036 dnl Find all the directories in share, but remove the share directory
1037 dnl itself and all CVS directories (if any) and fortran directories.
1038 dnl Remove the leading "share" part of the path, and add double-quotes
1039 dnl around it.
1041 #default_sharedirs=`find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\); "\1" \\\\;' | sed '$s;\\\\;;'`
1042 default_sharedirs=`find share -type d | sort | egrep -v 'share$|CVS|/fortran' | sed 's;share/\(.*\);"\1";' | tr '\n' ' '`
1044 AC_SUBST(expanded_top_srcdir)
1045 AC_SUBST(expanded_exec_prefix)
1046 AC_SUBST(expanded_libdir)
1047 AC_SUBST(expanded_libexecdir)
1048 AC_SUBST(expanded_datadir)
1049 AC_SUBST(expanded_infodir)
1050 default_layout_autotools="true"
1051 AC_SUBST(default_layout_autotools)
1052 AC_SUBST(LDFLAGS)
1053 AC_SUBST(default_sharedirs)
1055 dnl Look for grep that can handle long lines and -e.
1056 AC_PROG_EGREP
1057 AC_SUBST(EGREP)
1060 # Configure these files and make them executable
1061 AC_CONFIG_FILES([maxima-local], chmod +x maxima-local)
1062 AC_CONFIG_FILES([xmaxima-local], chmod +x xmaxima-local)
1064 # Convert maxima.bat to DOS line ending
1065 # sed-3.02 in old mingw distribution doesn't support -i or \r
1066 # dos2unix may not be present, but perl is required elsewhere
1067 # perl -i interferes with binmode so need to use a temporary file
1068 AC_CONFIG_FILES([src/maxima.bat], (perl -ne 'BEGIN{binmode(STDOUT,":crlf")};' -e 'print' < src/maxima.bat > src/maxima.bat.tmp; mv src/maxima.bat.tmp src/maxima.bat))
1070 AC_OUTPUT(Makefile maxima.spec maxima.iss \
1071 admin/Makefile src/Makefile src/maxima src/rmaxima src/autoconf-variables.lisp \
1072 src/share-subdirs.lisp \
1073 lisp-utils/Makefile tests/Makefile doc/Makefile \
1074 doc/emaxima/Makefile doc/info/Makefile doc/info/include-maxima.texi \
1075 doc/info/de/Makefile \
1076 doc/info/de.utf8/Makefile doc/info/es/Makefile doc/info/es.utf8/Makefile \
1077 doc/info/pt/Makefile doc/info/pt.utf8/Makefile \
1078 doc/info/pt/include-maxima.texi \
1079 doc/info/pt_BR/Makefile doc/info/pt_BR.utf8/Makefile \
1080 doc/intromax/Makefile doc/man/Makefile doc/man/maxima.1 doc/man/ru/maxima.1 \
1081 doc/share/Makefile interfaces/Makefile interfaces/emacs/Makefile \
1082 interfaces/emacs/emaxima/Makefile interfaces/emacs/imaxima/Makefile \
1083 interfaces/emacs/misc/Makefile interfaces/xmaxima/Makefile \
1084 interfaces/xmaxima/autoconf-variables.tcl interfaces/xmaxima/Tkmaxima/Header.tcl \
1085 interfaces/xmaxima/doc/Makefile interfaces/xmaxima/doc/figures/Makefile \
1086 interfaces/xmaxima/msgs/Makefile interfaces/xmaxima/win32/Makefile \
1087 plotting/mgnuplot share/Makefile demo/Makefile plotting/Makefile locale/Makefile \
1088 share/contrib/Makefile share/contrib/integration/Makefile \
1089 share/draw/Makefile share/logic/Makefile doc/info/es/include-maxima.texi \
1090 src/lisp)
1092 echo
1093 echo "Summary:"
1094 if test x"${clisp}" = xtrue ; then
1095 echo "clisp enabled. Executable name: \"${CLISP_NAME}\""
1096 echo "clisp runtime is \"${CLISP_RUNTIME_PATH}\""
1097 fi
1098 if test x"${clisp_exec}" = xtrue ; then
1099 echo "clisp executable image enabled for maxima."
1100 fi
1101 if test x"${cmucl}" = xtrue ; then
1102 echo "CMUCL enabled. Executable name: \"${CMUCL_NAME}\""
1103 echo "cmucl runtime is \"${CMUCL_RUNTIME_PATH}\""
1104 fi
1105 if test x"${cmucl_exec}" = xtrue; then
1106 echo "CMUCL executable image enabled for maxima."
1107 fi
1108 if test x"${scl}" = xtrue ; then
1109 echo "SCL enabled. Executable name: \"${SCL_NAME}\""
1110 echo "SCL runtime is \"${SCL_RUNTIME_PATH}\""
1111 fi
1112 if test x"${sbcl}" = xtrue ; then
1113 echo "SBCL enabled. Executable name: \"${SBCL_NAME}\""
1114 fi
1115 if test x"${sbcl_exec}" = xtrue ; then
1116 echo "sbcl executable image enabled for maxima."
1117 fi
1118 if test x"${gcl}" = xtrue ; then
1119 echo "GCL enabled. Executable name: \"${GCL_NAME}\""
1120 if test x"${gcl_alt_link}" = xtrue ; then
1121 echo " GCL alternative linking method enabled."
1122 fi
1123 fi
1124 if test x"${acl}" = xtrue ; then
1125 echo "ACL enabled. Executable name: \"${ACL_NAME}\""
1126 fi
1127 if test x"${openmcl}" = xtrue ; then
1128 echo "OpenMCL enabled. Executable name: \"${OPENMCL_NAME}\""
1129 fi
1130 if test x"${openmcl_exec}" = xtrue ; then
1131 echo "OpenMCL executable image enabled for maxima."
1132 fi
1133 if test x"${ecl}" = xtrue ; then
1134 echo "ECL enabled. Executable name: \"${ECL_NAME}\""
1135 fi
1136 echo "default lisp: $DEFAULTLISP"
1137 echo "wish executable name: \"${WISH}\""
1139 if test x"${chm}" = xtrue ; then
1140 echo "CHM help files enabled"
1141 echo " HHC: \"${HHC}\""
1142 fi
1143 if test x"${xmaxima_exe}" = xtrue ; then
1144 echo "Windows xmaxima.exe enabled"
1145 echo " GCC version GCCVER: ${GCCVER}"
1146 echo " TCLKITSH: ${TCLKITSH}"
1147 if ! test -f "${TCLKITSH}" ; then
1148 AC_MSG_WARN(*** TCLKITSH ${TCLKITSH} not found)
1149 xmaxima_exe_prerequisite=notfound
1150 fi
1151 echo " TCLKIT_RUNTIME: ${TCLKIT_RUNTIME}"
1152 if ! test -f "${TCLKIT_RUNTIME}" ; then
1153 AC_MSG_WARN(*** TCLKIT_RUNTIME ${TCLKIT_RUNTIME} not found)
1154 xmaxima_exe_prerequisite=notfound
1155 fi
1156 echo " SDXKIT: ${SDXKIT}"
1157 if ! test -f "${SDXKIT}" ; then
1158 AC_MSG_WARN(*** SDXKIT ${SDXKIT} not found)
1159 xmaxima_exe_prerequisite=notfound
1160 fi
1161 echo " IMGKIT: ${IMGKIT}"
1162 if ! test -f "${IMGKIT}" ; then
1163 AC_MSG_WARN(*** IMGKIT ${IMGKIT} not found)
1164 xmaxima_exe_prerequisite=notfound
1165 fi
1166 if test x${xmaxima_exe_prerequisite} = xnotfound ; then
1167 AC_MSG_WARN([A prerequisite for xmaxima.exe not found. The missing components can be defined on the make command line.])
1168 fi
1169 fi