src/Makefile.am

   1 ## Lisp normally uses ASDF for compiling big projects, an extensible make-like utility.
   2 ## ASDF also allows to build maxima on systems that don't contain autotools.
   3 ## It therefore is natural to use make only for initiating the build process
   4 ## and to use the autotools for setting up all files, but to use the standard lisp
   5 ## tools for the actual build.
   6 ##
   7 ## The ASDF equivalent of a makefile is named maxima.system.
   8 ## For details about its syntax see
   9 ## https://common-lisp.net/project/asdf/asdf/The-defsystem-form.html
  10
  11 include $(top_srcdir)/common.mk
  12
  13 if WIN32
  14 bin_SCRIPTS = maxima-command.ico maxima.bat set_lang.vbs
  15 else
  16 bin_SCRIPTS = maxima rmaxima
  17 endif
  18
  19 ## In instsrcdir, we install the lisp source files in src/ (including
  20 ## the numerical subdirectories).
  21 ## TODO: Should we also be installing the .system and .asd files here?
  22 real_lisp_sources := $(shell echo $(srcdir)/*.lisp $(srcdir)/numerical/*.lisp $(srcdir)/numerical/slatec/*.lisp)
  23 nobase_dist_instsrc_DATA = $(real_lisp_sources)
  24 EXTRA_DIST = \
  25   maxima.asd maxima.system \
  26   numerical/slatec/fortran \
  27   maxima-build.lisp maxima-command.ico set_lang.vbs \
  28   lisp \
  29   $(real_lisp_sources)
  30
  31 ## If we can, we use Automake's blah_SCRIPTS targets to install
  32 ## stuff. When doing this, we have to populate EXTRA_SCRIPTS, so we
  33 ## use += and initialise here.
  34 EXTRA_SCRIPTS =
  35
  36 ## A debugging tool. If you're trying to understand the value of the
  37 ## variable $(foo) when make runs, call "make echo_foo" and it will be
  38 ## printed.
  39 echo_%:
  40         @echo "$(subst echo_,,$@)=$($(subst echo_,,$@))"
  41         @echo "origin $(subst echo_,,$@) returns $(origin $(subst echo_,,$@))"
  42
  43 ## "all" depends on sharefiles.mk and whatever files we choose to
  44 ## build. These are listed in BUILT_FILES, which is populated in the
  45 ## implementation-dependent sections below.
  46 ##
  47 BUILT_FILES =
  48 all-local: $(BUILT_FILES)
  49
  50 DISTCLEAN_FILES=$(DISTCLEAN_EXTRA_SRC_FILES)
  51
  52 ## The "clean" rule always just deletes some files and they are
  53 ## specified in the conditional sections by adding
  54 ## implementation-specific targets to the list CLEAN_TARGETS.
  55 CLEAN_TARGETS =
  56 clean-local: $(CLEAN_TARGETS)
  57
  58 ## Tell make clean to delete all the <foo>-depends.mk files.
  59 DEPENDS_FILES = \
  60   clisp-depends.mk cmucl-depends.mk scl-depends.mk acl-depends.mk \
  61   sbcl-depends.mk gcl-depends.mk openmcl-depends.mk ecl-depends.mk abcl-depends.mk
  62 CLEANFILES = $(DEPENDS_FILES) tools/sys-proclaim.lisp
  63
  64 ## Similarly, we do something hacky with the install rule. Most of the
  65 ## time, we can actually use Automake's tools for this, but for the
  66 ## crazy "install another copy of the implementation" approach that we
  67 ## use with SCL and CLISP, we need to do it by hand.
  68 WEIRD_INSTALL_TARGETS =
  69 WEIRD_UNINSTALL_TARGETS =
  70 install-exec-local: $(WEIRD_INSTALL_TARGETS)
  71 uninstall-hook: $(WEIRD_UNINSTALL_TARGETS)
  72
  73 ## A rule to build binary directories of the form binary-<lispname>
  74 ## and subdirectories ./numerical and ./numerical/slatec
  75 binary_subdirs = / /numerical /numerical/slatec
  76 lisps_enabled = @lisps_enabled@
  77 .PHONY: bd
  78 bd:
  79         for l in $(lisps_enabled); do for d in $(binary_subdirs); do $(MKDIR_P) binary-$$l$$d; done; done
  80
  81 ## Some hunks of lisp that get used by more than one implementation
  82 LOADDEFSYSTEM = (load "$(top_srcdir)/lisp-utils/defsystem.lisp") (mk:add-registry-location "$(top_srcdir)/src/")
  83 LOADMAKEDEPENDS = (load "$(top_srcdir)/lisp-utils/make-depends.lisp")
  84 DS_OOS = funcall (intern (symbol-name :operate-on-system) :mk) "maxima"
  85 if QUIET_BUILD
  86 QUIET="(setf *compile-print* nil) (setq *compile-verbose* nil)"
  87 DEFSYSTEMCOMPILE = ($(DS_OOS) :compile :verbose nil)
  88 DEFSYSTEMLOAD = ($(DS_OOS) :load :verbose nil )
  89 else
  90 # Set QUIET to an empty list, so that --eval '$(QUIET)' works.
  91 QUIET="()"
  92 DEFSYSTEMCOMPILE = ($(DS_OOS) :compile :verbose t)
  93 DEFSYSTEMLOAD = ($(DS_OOS) :load :verbose t)
  94 endif
  95 DEFSYSTEMTESTLOAD = ($(DS_OOS) :load :verbose t :test t)
  96
  97 ## A function that takes: $(1) = the target name or names (either a
  98 ## string or a list of strings); $(2) = <foo>-depends.mk; $(3) = any
  99 ## postscript that should be added. It outputs lisp code
 100 ## that, when run, should create the dependency Makefile fragments.
 101 MAKE_DEPENDS = '$(LOADDEFSYSTEM) $(LOADMAKEDEPENDS) (funcall (intern "CREATE-DEPENDENCY-FILE" :mk) $(1) "$(2)") $(3)'
 102
 103 ## CLISP #######################################################################
 104 if CLISP
 105
 106 EXTRA_SCRIPTS += $(CLISP_MAXIMA)
 107
 108 if CLISP_EXEC
 109 CLISP_MAXIMA = binary-clisp/maxima$(EXEEXT)
 110 clisplib_SCRIPTS = $(CLISP_MAXIMA)
 111 clispexeflag = :EXECUTABLE t
 112 else
 113 CLISP_MAXIMA = binary-clisp/maxima.mem
 114 clisplib_DATA = $(CLISP_MAXIMA)
 115 clispexeflag =
 116 ## Rather crazily, we install an extra copy of clisp. Maybe there's a
 117 ## more sensible approach than this?!
 118 WEIRD_INSTALL_TARGETS += install-clisp-copy
 119 WEIRD_UNINSTALL_TARGETS += uninstall-clisp-copy
 120 install-clisp-copy:
 121         $(mkinstalldirs) $(DESTDIR)$(clisplibdir)
 122         $(INSTALL_PROGRAM) @CLISP_RUNTIME_PATH@ "$(DESTDIR)$(clisplibdir)/@CLISP_RUNTIME@"
 123 uninstall-clisp-copy:
 124         rm -f "$(DESTDIR)$(clisplibdir)/@CLISP_RUNTIME@"
 125 endif
 126
 127 EXECUTECLISP = $(CLISP_NAME) -norc -q
 128 clisplibdir = $(verpkglibdir)/binary-clisp
 129
 130 BUILT_FILES += $(CLISP_MAXIMA)
 131
 132 clisp: $(CLISP_MAXIMA)
 133
 134 $(CLISP_MAXIMA):
 135         $(MAKE) bd
 136         echo '$(QUIET) $(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE)' > clisp-command.lisp
 137         $(EXECUTECLISP) clisp-command.lisp
 138         echo '$(LOADDEFSYSTEM) $(DEFSYSTEMLOAD) (ext:saveinitmem "$@" :init-function (function cl-user::run) $(clispexeflag))' > clisp-command.lisp
 139         $(EXECUTECLISP) clisp-command.lisp
 140         rm clisp-command.lisp
 141
 142 clisp-depends.mk: maxima.system Makefile *.lisp
 143         echo $(call MAKE_DEPENDS,"$(CLISP_MAXIMA)",clisp-depends.mk.tmp) > clisp-command2.lisp
 144         $(EXECUTECLISP) clisp-command2.lisp
 145         cat clisp-depends.mk.tmp | sed -e "s#\\\\#/#g" > clisp-depends.mk
 146
 147 -include clisp-depends.mk
 148 endif CLISP
 149
 150 clean-clisp:
 151         rm -rf binary-clisp clisp-command.lisp clisp-command2.lisp
 152 CLEAN_TARGETS += clean-clisp
 153
 154 ## CMUCL #######################################################################
 155 if CMUCL
 156
 157 EXTRA_SCRIPTS += $(CMU_MAXIMA) lisp
 158
 159 if CMUCL_EXEC
 160 CMU_MAXIMA = binary-cmucl/maxima
 161 cmucllib_SCRIPTS = $(CMU_MAXIMA)
 162 cmuflag = :executable t :init-function '\''cl-user::run
 163 else
 164 CMU_MAXIMA = binary-cmucl/maxima.core
 165 cmucllib_SCRIPTS = lisp
 166 cmucllib_DATA = $(CMU_MAXIMA)
 167 cmuflag =
 168 endif
 169
 170 # Newer versions of CMUCL have an INTL package that is compatible with
 171 # maxima's.  We just bind intl::*default-domain* here so that when we
 172 # compile the files, we will get appropriate translations.  (Otherwise
 173 # we have to put (intl:textdomain "maxima") in each Lisp file.
 174 INITINTL = (when (find-package "INTL") (set (find-symbol "*DEFAULT-DOMAIN*" "INTL") "maxima"))
 175 CMU_COMPILE = echo '$(QUIET) $(INITINTL) $(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE)' | $(EXECUTECMUCL)
 176 CMU_WRITE = echo '$(LOADDEFSYSTEM) $(DEFSYSTEMLOAD) (ext:save-lisp "$(CMU_MAXIMA)" $(cmuflag))' | $(EXECUTECMUCL)
 177 CMU_BUILD = ($(CMU_COMPILE)) && ($(CMU_WRITE))
 178 EXECUTECMUCL = $(CMUCL_NAME) -noinit -batch
 179
 180 cmucllibdir = $(verpkglibdir)/binary-cmucl
 181 BUILT_FILES += $(CMU_MAXIMA)
 182
 183 cmucl: $(CMU_MAXIMA)
 184
 185 $(CMU_MAXIMA):
 186         $(MAKE) bd
 187         $(CMU_BUILD)
 188
 189 cmucl-depends.mk: maxima.system Makefile *.lisp
 190         echo $(call MAKE_DEPENDS,"$(CMU_MAXIMA)",cmucl-depends.mk.tmp) | $(EXECUTECMUCL)
 191         cat cmucl-depends.mk.tmp | sed -e "s#\\\\#/#g" > cmucl-depends.mk
 192
 193 -include cmucl-depends.mk
 194 endif
 195
 196 clean-cmucl:
 197         rm -rf binary-cmucl
 198 CLEAN_TARGETS += clean-cmucl
 199
 200 ## SCL #########################################################################
 201 if SCL
 202
 203 scllibdir = $(verpkglibdir)/binary-scl
 204
 205 EXECUTESCL = $(SCL_NAME) -noinit -batch
 206 BUILT_FILES += binary-scl/maxima.core
 207 scllib_DATA = binary-scl/maxima.core
 208
 209 scl: binary-scl/maxima.core
 210
 211 binary-scl/maxima.core:
 212         $(MAKE) bd
 213         (echo '$(QUIET) $(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE)' | $(EXECUTESCL)) && \
 214         (echo '$(LOADDEFSYSTEM) $(DEFSYSTEMLOAD) (ext:save-lisp "binary-scl/maxima.core")' | $(EXECUTESCL))
 215
 216 ## Just like with clisp, we install an extra copy of SCL. No, I don't
 217 ## understand either. Also, I just read the SCL license agreement. Is
 218 ## the user even allowed to do this?!
 219 WEIRD_INSTALL_TARGETS += install-scl-copy
 220 WEIRD_UNINSTALL_TARGETS += uninstall-scl-copy
 221 install-scl-copy:
 222         $(mkinstalldirs) $(DESTDIR)$(scllibdir)
 223         $(INSTALL_PROGRAM) @SCL_RUNTIME_PATH@ "$(DESTDIR)$(scllibdir)/@SCL_RUNTIME@"
 224 uninstall-scl-copy:
 225         rm -f "$(DESTDIR)$(scllibdir)/@SCL_RUNTIME@"
 226
 227 scl-depends.mk: maxima.system Makefile *.lisp
 228         echo $(call MAKE_DEPENDS,"binary-scl/maxima.core",scl-depends.mk.tmp) | $(EXECUTESCL)
 229         cat scl-depends.mk.tmp | sed -e "s#\\\\#/#g" > scl-depends.mk
 230
 231 -include scl-depends.mk
 232
 233 endif
 234
 235 clean-scl:
 236         rm -rf binary-scl
 237 CLEAN_TARGETS += clean-scl
 238
 239 ## ACL #########################################################################
 240 if ACL
 241
 242 acllibdir = $(verpkglibdir)/binary-acl
 243
 244 EXECUTEACL = $(ACL_NAME) -batch
 245 BUILT_FILES += binary-acl/maxima.dxl
 246
 247 acllib_DATA = binary-acl/maxima.dxl
 248
 249 acl: binary-acl/maxima.dxl
 250
 251 binary-acl/maxima.dxl:
 252         $(MAKE) bd
 253         (echo '$(QUIET) $(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE)' | $(EXECUTEACL)) && \
 254         (echo '$(LOADDEFSYSTEM) $(DEFSYSTEMLOAD) (excl:dumplisp :name "binary-acl/maxima.dxl")' | $(EXECUTEACL))
 255
 256 acl-depends.mk: maxima.system Makefile *.lisp
 257         echo $(call MAKE_DEPENDS,"binary-acl/maxima.dxl",acl-depends.mk.tmp) | $(EXECUTEACL)
 258         cat acl-depends.mk.tmp | sed -e "s#\\\\#/#g" > acl-depends.mk
 259
 260 -include acl-depends.mk
 261 endif
 262
 263 clean-acl:
 264         rm -rf binary-acl
 265 CLEAN_TARGETS += clean-acl
 266
 267 ## SBCL ########################################################################
 268 if SBCL
 269
 270 sbcllibdir = $(verpkglibdir)/binary-sbcl
 271
 272 EXTRA_SCRIPTS += $(SBCL_MAXIMA)
 273
 274 if SBCL_EXEC
 275 SBCL_MAXIMA = binary-sbcl/maxima$(EXEEXT)
 276 sbcllib_SCRIPTS = $(SBCL_MAXIMA)
 277 sb_slad = (sb-ext:save-lisp-and-die "$@" :executable t)
 278 else
 279 SBCL_MAXIMA = binary-sbcl/maxima.core
 280 sbcllib_DATA = $(SBCL_MAXIMA)
 281 sb_slad = (sb-ext:save-lisp-and-die "$@")
 282 endif
 283
 284 EXECUTESBCL = "$(SBCL_NAME)" --noinform --noprint $(SBCL_EXTRA_ARGS)
 285 BUILT_FILES += $(SBCL_MAXIMA)
 286
 287 COMPILE_SBCL = echo '$(QUIET) $(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE) (sb-ext:quit)' | $(EXECUTESBCL)
 288 WRITE_SBCL = echo '$(LOADDEFSYSTEM) $(DEFSYSTEMLOAD) $(sb_slad) (sb-ext:quit)' | $(EXECUTESBCL)
 289 BUILD_SBCL = $(COMPILE_SBCL) && $(WRITE_SBCL)
 290
 291 sbcl: $(SBCL_MAXIMA)
 292
 293 $(SBCL_MAXIMA):
 294         $(MAKE) bd
 295         $(BUILD_SBCL)
 296
 297 sbcl-depends.mk: maxima.system Makefile *.lisp
 298         echo $(call MAKE_DEPENDS,"$(SBCL_MAXIMA)",sbcl-depends.mk.tmp,(sb-ext:quit)) | $(EXECUTESBCL)
 299         cat sbcl-depends.mk.tmp | sed -e "s#\\\\#/#g" > sbcl-depends.mk
 300
 301 -include sbcl-depends.mk
 302
 303 endif
 304
 305 clean-sbcl:
 306         rm -rf binary-sbcl numerical/binary-sbcl numerical/slatec/binary-sbcl
 307 CLEAN_TARGETS += clean-sbcl
 308
 309 ## GCL #########################################################################
 310 #
 311 # For gcl we execute all commands from a temp file for the following motive:
 312 #
 313 # Some versions of GCL 2.6.12 don't automatically close at the end of a lisp
 314 # file that contains the commands needed for compiling maxima and crash if
 315 # they reach a (quit). In newer versions of 2.6.12 sending the (quit) from the
 316 # command-line causes a crash.
 317 # GCL's --eval switch adds an implicit (progn) that breaks defsystem's
 318 # (mk:add-registry-location).
 319 # And when executing commands from stdin some GCL versions get the
 320 # end-of-file from the end of the command list too early and therefore close
 321 # before the last command has been processed.
 322 # Providing all commands from the command-line and ending them with a
 323 # (quit) so it doesn't matter if lisp automatically closes at the last
 324 # or the second last command seems to work, though.
 325
 326 if GCL
 327
 328 gcllibdir = $(verpkglibdir)/binary-gcl
 329
 330 EXTRA_SCRIPTS += binary-gcl/maxima
 331 gcllib_SCRIPTS = binary-gcl/maxima
 332
 333 EXECUTEGCL = $(GCL_NAME)
 334 BUILT_FILES += binary-gcl/maxima
 335
 336 sys_proc_dependency = tools/sys-proclaim.lisp
 337 gcl_depends_targets = (list "binary-gcl/maxima" "tools/sys-proclaim.lisp")
 338
 339 tools/sys-proclaim.lisp: maxima.system *.lisp
 340         rm -rf binary-gcl
 341         touch sys-proclaim.lisp
 342         $(MAKE) bd
 343         echo '(load "generate-sys-proclaim.lisp") (system::quit)' | $(EXECUTEGCL)
 344         rm -rf binary-gcl
 345         mkdir -p tools
 346         mv sys-proclaim.lisp tools
 347
 348 gcl: binary-gcl/maxima
 349
 350 binary-gcl/maxima: $(sys_proc_dependency) gcl-depends.mk
 351         $(MAKE) bd
 352 if GCL_ALT_LINK
 353         echo '$(QUIET) $(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE) (system::quit)' | $(EXECUTEGCL)
 354         echo '(let ((com (quote (progn (defvar compiler::*gazonk-prefix* "gazonk") (defun compiler::gazonk-name (&aux tem)(dotimes (i 1000) (unless (probe-file (setq tem (merge-pathnames (format nil "~d~d.lsp" compiler::*gazonk-prefix* i))))(return-from compiler::gazonk-name (pathname tem))))(error "1000 gazonk names used already!"))(let ((compiler::*gazonk-prefix* "maxima_gazonk")(compiler::*keep-gaz* t))$(LOADDEFSYSTEM)$(DEFSYSTEMLOAD))))))(let ((si::*collect-binary-modules* t))(eval com)(let ((compiler::*default-system-p* t))(dolist (l (directory "maxima_gazonk*.lsp")) (compile-file l) (delete-file l)))(compiler::link si::*binary-modules* "binary-gcl/maxima" (format nil "~S" com) "" nil)(dolist (l (directory "maxima_gazonk*.lsp")) (delete-file l)))) (system::quit)' | $(EXECUTEGCL)
 355 else
 356         echo '$(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE) (system::quit)' | $(EXECUTEGCL)
 357         echo '(setq si::*optimize-maximum-pages* nil) $(LOADDEFSYSTEM) $(DEFSYSTEMLOAD) (setq si::*optimize-maximum-pages* t) (si:save-system "binary-gcl/maxima") (system::quit)'  | $(EXECUTEGCL)
 358 endif
 359
 360 gcl-depends.mk: maxima.system Makefile *.lisp
 361         echo $(call MAKE_DEPENDS,$(gcl_depends_targets),gcl-depends.mk.tmp) '(system::quit)' | $(EXECUTEGCL)
 362         cat gcl-depends.mk.tmp | sed -e "s#\\\\#/#g" > gcl-depends.mk
 363 -include gcl-depends.mk
 364
 365 endif
 366
 367 clean-gcl:
 368         rm -rf binary-gcl
 369 CLEAN_TARGETS += clean-gcl
 370
 371 ## OPENMCL / CCL ###############################################################
 372 if OPENMCL
 373
 374 openmcllibdir = $(verpkglibdir)/binary-openmcl
 375 EXTRA_SCRIPTS += $(OPENMCL_MAXIMA)
 376
 377 if OPENMCL_EXEC
 378 OPENMCL_MAXIMA = binary-openmcl/maxima$(EXEEXT)
 379 openmcllib_SCRIPTS = $(OPENMCL_MAXIMA)
 380 omcl_flag = :prepend-kernel t
 381 else
 382 OPENMCL_MAXIMA = binary-openmcl/maxima.image
 383 openmcllib_DATA = $(OPENMCL_MAXIMA)
 384 omcl_flag =
 385 endif
 386
 387 EXECUTEOPENMCL = $(OPENMCL_NAME)
 388 BUILT_FILES += $(OPENMCL_MAXIMA)
 389
 390 COMPILE_OMCL = echo '$(QUIET) (require :defsystem) (mk:add-registry-location "$(top_srcdir)/src/") $(DEFSYSTEMCOMPILE) (ccl::quit)' | $(EXECUTEOPENMCL)
 391 WRITE_OMCL = echo '(require :defsystem) (mk:add-registry-location "$(top_srcdir)/src/") $(DEFSYSTEMLOAD) (ccl:save-application "$@") (ccl::quit)' | $(EXECUTEOPENMCL)
 392 BUILD_OMCL = $(COMPILE_OMCL) && $(WRITE_OMCL)
 393
 394 openmcl: $(OPENMCL_MAXIMA)
 395
 396 $(OPENMCL_MAXIMA):
 397         $(BUILD_OMCL)
 398         echo '(require :defsystem)  $(DEFSYSTEMCOMPILE) (ccl::quit)' | $(EXECUTEOPENMCL) \
 399            && \
 400         echo '(require :defsystem) $(DEFSYSTEMLOAD) (ccl:save-application "$@" $(omcl_flag)) (ccl::quit)' | $(EXECUTEOPENMCL)
 401
 402 openmcl-depends.mk: maxima.system Makefile *.lisp
 403         echo $(call MAKE_DEPENDS,"$(OPENMCL_MAXIMA)",openmcl-depends.mk.tmp,(ccl:quit)) | $(EXECUTEOPENMCL)
 404         cat openmcl-depends.mk.tmp | sed -e "s#\\\\#/#g" > openmcl-depends.mk
 405
 406 -include openmcl-depends.mk
 407
 408 endif
 409
 410 clean-openmcl:
 411         rm -rf binary-openmcl
 412 CLEAN_TARGETS += clean-openmcl
 413
 414 ## CCL64 #######################################################################
 415
 416 if CCL64
 417
 418 ccl64libdir = $(verpkglibdir)/binary-ccl64
 419 EXTRA_SCRIPTS += $(OPENMCL_MAXIMA)
 420
 421 if CCL64_EXEC
 422 CCL64_MAXIMA = binary-ccl64/maxima$(EXEEXT)
 423 ccl64lib_SCRIPTS = $(CCL64_MAXIMA)
 424 omcl_flag = :prepend-kernel t
 425 else
 426 CCL64_MAXIMA = binary-ccl64/maxima.image
 427 ccl64lib_DATA = $(CCL64_MAXIMA)
 428 omcl_flag =
 429 endif
 430
 431 EXECUTECCL64 = $(CCL64_NAME)
 432 BUILT_FILES += $(CCL64_MAXIMA)
 433
 434 COMPILE_CCL64 = $(EXECUTECCL64) --eval '$(QUIET)' --eval '(require :defsystem)' --eval '(mk:add-registry-location "$(top_srcdir)/src/")' --eval '$(DEFSYSTEMCOMPILE)' --eval '(ccl::quit)'
 435 WRITE_CCL64 = $(EXECUTECCL64) --eval '(require :defsystem)' --eval '(mk:add-registry-location "$(top_srcdir)/src/")' --eval '$(DEFSYSTEMLOAD)' --eval '(ccl:save-application "$@")' --eval '(ccl::quit)'
 436 BUILD_CCL64 = $(COMPILE_CCL64) && $(WRITE_CCL64)
 437
 438 ccl64: $(CCL64_MAXIMA)
 439
 440 $(CCL64_MAXIMA):
 441         $(BUILD_CCL64)
 442         $(EXECUTECCL64) --eval '(require :defsystem)' --eval '$(DEFSYSTEMCOMPILE)' --eval '(ccl::quit)' && \
 443         $(EXECUTECCL64) --eval '(require :defsystem)' --eval '$(DEFSYSTEMLOAD)' --eval '(ccl:save-application "$@" $(omcl_flag))' --eval '(ccl::quit)'
 444
 445 ccl64-depends.mk: maxima.system Makefile *.lisp
 446         echo $(call MAKE_DEPENDS,"$(CCL64_MAXIMA)",ccl64-depends.mk.tmp,(ccl:quit)) >ccl64-depends.mk.tmp
 447         $(EXECUTECCL64) --load ccl64-depends.mk.tmp | sed -e "s#\\\\#/#g" > ccl64-depends.mk
 448
 449 -include ccl64-depends.mk
 450
 451
 452 endif
 453
 454 clean-ccl64:
 455         rm -rf binary-ccl64
 456 CLEAN_TARGETS += clean-ccl64
 457
 458 ## ECL #########################################################################
 459 if ECL
 460
 461 ecllibdir = $(verpkglibdir)/binary-ecl
 462 EXTRA_SCRIPTS += binary-ecl/maxima
 463 ecllib_SCRIPTS = binary-ecl/maxima
 464
 465 EXECUTEECL = $(ECL_NAME) -norc
 466 BUILT_FILES += binary-ecl/maxima
 467
 468 ecl:binary-ecl/maxima
 469
 470 binary-ecl/maxima:
 471         $(MAKE) bd
 472         echo '$(QUIET) $(LOADDEFSYSTEM) $(DEFSYSTEMCOMPILE) (build-maxima-lib) (ext:quit)' | $(EXECUTEECL)
 473
 474 ecl-depends.mk: maxima.system Makefile *.lisp
 475         echo $(call MAKE_DEPENDS,"binary-ecl/maxima",ecl-depends.mk.tmp,(quit)) | $(EXECUTEECL)
 476         cat ecl-depends.mk.tmp | sed -e "s#\\\\#/#g" > ecl-depends.mk
 477
 478 -include ecl-depends.mk
 479 endif
 480
 481 clean-ecl:
 482         rm -rf binary-ecl libmaxima.a
 483 CLEAN_TARGETS += clean-ecl
 484
 485 ## ABCL ########################################################################
 486 if ABCL
 487
 488 # ABCL compiles the individual files maxima is comprised of. But they aren't
 489 # compiled into a single .jar archive, but need to be loaded by abcl in the
 490 # right order => We need to copy all the stuff defsystem needs into the binary
 491 # folder and need to use defsystem for loading all the files in the Right Order.
 492
 493 abcllibdir = $(verpkglibdir)/binary-abcl
 494 EXTRA_SCRIPTS += binary-abcl/maxima
 495 abcllib_SCRIPTS = binary-abcl/maxima
 496
 497 EXECUTEABCL = $(JRE) -jar $(ABCL_JAR) --noinit
 498 BUILT_FILES += binary-abcl/maxima
 499
 500 WEIRD_INSTALL_TARGETS += install-abcl-folder
 501 WEIRD_UNINSTALL_TARGETS += uninstall-abcl-folder
 502
 503 install-abcl-folder:
 504         $(mkinstalldirs) $(DESTDIR)$(abcllibdir)
 505         cp -r binary-abcl/* "$(DESTDIR)$(abcllibdir)"
 506         chmod +x $(DESTDIR)$(abcllibdir)/maxima
 507 uninstall-abcl-folder:
 508         if test x"$(abcllibdir)" = x"" ; then echo "Error: No known maxima version"; exit -1; else rm -f "$(DESTDIR)$(abcllibdir)/*"; fi
 509
 510 abcl:binary-abcl/maxima
 511
 512
 513 binary-abcl/maxima: Makefile.am startmaxima_abcl.sh
 514         $(MAKE) bd
 515 if QUIET_BUILD
 516         $(EXECUTEABCL) --eval '(setq *compile-verbose* nil)' --eval '(setf *compile-print* nil)' --eval '(load "$(top_srcdir)/lisp-utils/defsystem.lisp")' --eval '(mk:add-registry-location "$(top_srcdir)/src/")' --eval '($(DS_OOS) :compile :verbose nil)' --eval '(quit)'
 517 else
 518         $(EXECUTEABCL) --eval '(load "$(top_srcdir)/lisp-utils/defsystem.lisp")' --eval '(mk:add-registry-location "$(top_srcdir)/src/")' --eval '($(DS_OOS) :compile :verbose t)' --eval '(quit)'
 519 endif
 520         cat $(srcdir)/maxima.system | sed -e 's#"binary-abcl"#(ext:getenv "MAXIMA_IMAGESDIR_BIN")#g' > binary-abcl/maxima.system
 521         cp $(srcdir)/maxima-package.lisp binary-abcl
 522         cp $(srcdir)/autol.lisp binary-abcl
 523         cp $(srcdir)/init-cl.lisp binary-abcl
 524         cp $(srcdir)/max_ext.lisp binary-abcl
 525         cp autoconf-variables.lisp binary-abcl
 526         cp $(ABCL_JAR) binary-abcl/abcl.jar
 527         cp $(srcdir)/../lisp-utils/defsystem.lisp binary-abcl
 528         cp -a startmaxima_abcl.sh binary-abcl/maxima
 529         touch binary-abcl/maxima
 530         chmod +x binary-abcl/maxima
 531
 532 abcl-depends.mk: maxima.system Makefile *.lisp
 533         echo $(call MAKE_DEPENDS,"binary-abcl/maxima",abcl-depends.mk.tmp,(quit)) | $(EXECUTEABCL)
 534         cat abcl-depends.mk.tmp | sed -e "s#\\\\#/#g" > abcl-depends.mk
 535
 536 -include abcl-depends.mk
 537 endif
 538
 539 clean-abcl:
 540         rm -rf binary-abcl libmaxima.a
 541 CLEAN_TARGETS += clean-abcl
 542
 543 distclean-local:
 544         rm -f sbcl-depends.mk.tmp