gnu/packages/lisp.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2014 John Darrington <jmd@gnu.org>
   3 ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
   4 ;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
   5 ;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
   6 ;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
   7 ;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
   8 ;;; Copyright © 2017, 2019 Ricardo Wurmus <rekado@elephly.net>
   9 ;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
  10 ;;; Copyright © 2017, 2019, 2020 Tobias Geerinckx-Rice <me@tobias.gr>
  11 ;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
  12 ;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
  13 ;;; Copyright © 2018, 2019 Pierre Neidhardt <mail@ambrevar.xyz>
  14 ;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com>
  15 ;;; Copyright © 2019, 2020 Katherine Cox-Buday <cox.katherine.e@gmail.com>
  16 ;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
  17 ;;; Copyright © 2019, 2020 Guillaume Le Vaillant <glv@posteo.net>
  18 ;;; Copyright © 2020 Marius Bakke <mbakke@fastmail.com>
  19 ;;;
  20 ;;; This file is part of GNU Guix.
  21 ;;;
  22 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  23 ;;; under the terms of the GNU General Public License as published by
  24 ;;; the Free Software Foundation; either version 3 of the License, or (at
  25 ;;; your option) any later version.
  26 ;;;
  27 ;;; GNU Guix is distributed in the hope that it will be useful, but
  28 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  29 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30 ;;; GNU General Public License for more details.
  31 ;;;
  32 ;;; You should have received a copy of the GNU General Public License
  33 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  34
  35 ;;; This file only contains Common Lisp compilers and tooling.
  36 ;;; Common Lisp libraries go to lisp-xyz.scm.
  37 ;;; Common Lisp applications should go to the most appropriate file,
  38 ;;; e.g. StumpWM is in wm.scm.
  39
  40 (define-module (gnu packages lisp)
  41   #:use-module (gnu packages)
  42   #:use-module ((guix licenses) #:prefix license:)
  43   #:use-module (guix packages)
  44   #:use-module (guix download)
  45   #:use-module (guix git-download)
  46   #:use-module (guix utils)
  47   #:use-module (guix build-system gnu)
  48   #:use-module (guix build-system ant)
  49   #:use-module (guix build-system asdf)
  50   #:use-module (guix build-system trivial)
  51   #:use-module (gnu packages admin)
  52   #:use-module (gnu packages base)
  53   #:use-module (gnu packages bdw-gc)
  54   #:use-module (gnu packages bison)
  55   #:use-module (gnu packages compression)
  56   #:use-module (gnu packages ed)
  57   #:use-module (gnu packages flex)
  58   #:use-module (gnu packages fontutils)
  59   #:use-module (gnu packages gcc)
  60   #:use-module (gnu packages gettext)
  61   #:use-module (gnu packages gl)
  62   #:use-module (gnu packages glib)
  63   #:use-module (gnu packages m4)
  64   #:use-module (gnu packages maths)
  65   #:use-module (gnu packages multiprecision)
  66   #:use-module (gnu packages ncurses)
  67   #:use-module (gnu packages libffcall)
  68   #:use-module (gnu packages libffi)
  69   #:use-module (gnu packages libsigsegv)
  70   #:use-module (gnu packages linux)
  71   #:use-module (gnu packages perl)
  72   #:use-module (gnu packages readline)
  73   #:use-module (gnu packages sdl)
  74   #:use-module (gnu packages tex)
  75   #:use-module (gnu packages tls)
  76   #:use-module (gnu packages texinfo)
  77   #:use-module (gnu packages version-control)
  78   #:use-module (gnu packages xorg)
  79   #:use-module (ice-9 match))
  80
  81 (define (asdf-substitutions lisp)
  82   ;; Prepend XDG_DATA_DIRS/LISP-bundle-systems to ASDF's
  83   ;; 'default-system-source-registry'.
  84   `((("\\(,dir \"systems/\"\\)\\)")
  85      (format #f
  86              "(,dir \"~a-bundle-systems\")))
  87
  88       ,@(loop :for dir :in (xdg-data-dirs \"common-lisp/\")
  89               :collect `(:directory (,dir \"systems\"))"
  90              ,lisp))))
  91
  92 (define-public cl-asdf
  93   (package
  94     (name "cl-asdf")
  95     (version "3.3.3")
  96     (source
  97      (origin
  98        (method url-fetch)
  99        (uri
 100         (string-append "https://common-lisp.net/project/asdf/archives/asdf-"
 101                        version ".lisp"))
 102        (sha256
 103         (base32 "18lr6kxvzhr79c9rx3sdricz30aby866fj0m24w27zxsqlyvn3rd"))))
 104     (build-system trivial-build-system)
 105     (arguments
 106      `(#:modules ((guix build utils)
 107                   (guix build lisp-utils))
 108        #:builder
 109        (begin
 110          (use-modules (guix build utils)
 111                       (guix build lisp-utils))
 112          (let* ((out (string-append (assoc-ref %outputs "out")))
 113                 (asdf-install (string-append out %source-install-prefix
 114                                              "/source/asdf/"))
 115                 (asdf (string-append (assoc-ref %build-inputs "source"))))
 116            (mkdir-p asdf-install)
 117            (copy-file asdf (string-append asdf-install "asdf.lisp"))))))
 118     (home-page "https://common-lisp.net/project/asdf/")
 119     (synopsis "Another System Definition Facility")
 120     (description
 121      "ASDF is what Common Lisp hackers use to build and load software.  It is
 122 the successor of the Lisp DEFSYSTEM of yore.  ASDF stands for Another System
 123 Definition Facility.")
 124     ;; MIT License
 125     (license license:expat)))
 126
 127 (define-public gcl
 128   (let ((commit "d3335e2b3deb63f930eb0328e9b05377744c9512")
 129         (revision "2")) ;Guix package revision
 130     (package
 131       (name "gcl")
 132       (version (string-append "2.6.12-" revision "."
 133                               (string-take commit 7)))
 134       (source
 135        (origin
 136          (method git-fetch)
 137          (uri (git-reference
 138                (url "https://git.savannah.gnu.org/r/gcl.git")
 139                (commit commit)))
 140          (file-name (string-append "gcl-" version "-checkout"))
 141          (sha256
 142           (base32 "05v86lhvsby05nzvcd3c4k0wljvgdgd0i6arzd2fx1yd67dl6fgj"))))
 143       (build-system gnu-build-system)
 144       (arguments
 145        `(#:parallel-build? #f  ; The build system seems not to be thread safe.
 146          #:test-target "ansi-tests/test_results"
 147          #:configure-flags '("--enable-ansi") ; required for use by the maxima package
 148          #:make-flags (list
 149                        (string-append "GCL_CC=" (assoc-ref %build-inputs "gcc")
 150                                       "/bin/gcc")
 151                        (string-append "CC=" (assoc-ref %build-inputs "gcc")
 152                                       "/bin/gcc"))
 153          #:phases
 154          (modify-phases %standard-phases
 155            (add-before 'configure 'pre-conf
 156              (lambda* (#:key inputs #:allow-other-keys)
 157                (chdir "gcl")
 158                (substitute*
 159                    (append
 160                     '("pcl/impl/kcl/makefile.akcl"
 161                       "add-defs"
 162                       "unixport/makefile.dos"
 163                       "add-defs.bat"
 164                       "gcl-tk/makefile.prev"
 165                       "add-defs1")
 166                     (find-files "h" "\\.defs"))
 167                  (("SHELL=/bin/bash")
 168                   (string-append "SHELL=" (which "bash")))
 169                  (("SHELL=/bin/sh")
 170                   (string-append "SHELL=" (which "sh"))))
 171                (substitute* "h/linux.defs"
 172                  (("#CC") "CC")
 173                  (("-fwritable-strings") "")
 174                  (("-Werror") ""))
 175                (substitute* "lsp/gcl_top.lsp"
 176                  (("\"cc\"")
 177                   (string-append "\"" (assoc-ref %build-inputs "gcc")
 178                                  "/bin/gcc\""))
 179                  (("\\(or \\(get-path \\*cc\\*\\) \\*cc\\*\\)") "*cc*")
 180                  (("\"ld\"")
 181                   (string-append "\"" (assoc-ref %build-inputs "binutils")
 182                                  "/bin/ld\""))
 183                  (("\\(or \\(get-path \\*ld\\*\\) \\*ld\\*\\)") "*ld*")
 184                  (("\\(get-path \"objdump --source \"\\)")
 185                   (string-append "\"" (assoc-ref %build-inputs "binutils")
 186                                  "/bin/objdump --source \"")))
 187                #t))
 188            (add-after 'install 'wrap
 189              (lambda* (#:key inputs outputs #:allow-other-keys)
 190                (let* ((gcl (assoc-ref outputs "out"))
 191                       (input-path (lambda (lib path)
 192                                     (string-append
 193                                      (assoc-ref inputs lib) path)))
 194                       (binaries '("binutils")))
 195                  ;; GCC and the GNU binutils are necessary for GCL to be
 196                  ;; able to compile Lisp functions and programs (this is
 197                  ;; a standard feature in Common Lisp). While the
 198                  ;; the location of GCC is specified in the make-flags,
 199                  ;; the GNU binutils must be available in GCL's $PATH.
 200                  (wrap-program (string-append gcl "/bin/gcl")
 201                    `("PATH" prefix ,(map (lambda (binary)
 202                                            (input-path binary "/bin"))
 203                                          binaries))))
 204                #t))
 205            ;; drop strip phase to make maxima build, see
 206            ;; https://www.ma.utexas.edu/pipermail/maxima/2008/009769.html
 207            (delete 'strip))))
 208       (inputs
 209        `(("gmp" ,gmp)
 210          ("readline" ,readline)))
 211       (native-inputs
 212        `(("m4" ,m4)
 213          ("texinfo" ,texinfo)))
 214       (home-page "https://www.gnu.org/software/gcl/")
 215       (synopsis "A Common Lisp implementation")
 216       (description "GCL is an implementation of the Common Lisp language.  It
 217 features the ability to compile to native object code and to load native
 218 object code modules directly into its lisp core.  It also features a
 219 stratified garbage collection strategy, a source-level debugger and a built-in
 220 interface to the Tk widget system.")
 221       (license license:lgpl2.0+))))
 222
 223 (define-public ecl
 224   (package
 225     (name "ecl")
 226     (version "20.4.24")
 227     (source
 228      (origin
 229        (method url-fetch)
 230        (uri (string-append
 231              "https://common-lisp.net/project/ecl/static/files/release/"
 232              name "-" version ".tgz"))
 233        (sha256
 234         (base32 "01qgdmr54wkj854f69qdm9sybrvd6gd21dpx4askdaaqybnkh237"))))
 235     (build-system gnu-build-system)
 236     ;; src/configure uses 'which' to confirm the existence of 'gzip'.
 237     (native-inputs
 238      `(("cl-asdf" ,cl-asdf)
 239        ("which" ,which)
 240        ("texinfo" ,texinfo)))
 241     (inputs
 242      `(("gmp" ,gmp)
 243        ("libatomic-ops" ,libatomic-ops)
 244        ("libgc" ,libgc)
 245        ("libffi" ,libffi)))
 246     (arguments
 247      `(#:configure-flags '("--without-rt")
 248        ;; FIXME: As of version 20.4.24, we pass 17995 tests and fail 7.
 249        ;; 2-3 tests may be due to FHS assumptions.
 250        #:tests? #t
 251        #:parallel-tests? #f
 252        #:phases
 253        (modify-phases %standard-phases
 254          (delete 'check)
 255          (add-after 'unpack 'replace-asdf
 256            ;; Use system ASDF instead of bundled one.
 257            (lambda* (#:key inputs outputs #:allow-other-keys)
 258              (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
 259                     (guix-asdf (string-append
 260                                 cl-asdf
 261                                 "/share/common-lisp/source/asdf/asdf.lisp"))
 262                     (out (string-append (assoc-ref outputs "out")))
 263                     (contrib-asdf "contrib/asdf/asdf.lisp"))
 264                (copy-file guix-asdf contrib-asdf)
 265                ;; Add ecl-bundle-systems to 'default-system-source-registry'.
 266                (substitute* contrib-asdf
 267                  ,@(asdf-substitutions name)))
 268              #t))
 269          (add-after 'install 'wrap
 270            (lambda* (#:key inputs outputs #:allow-other-keys)
 271              (let* ((ecl (assoc-ref outputs "out"))
 272                     (input-path (lambda (lib path)
 273                                   (string-append
 274                                    (assoc-ref inputs lib) path)))
 275                     (libraries '("gmp" "libatomic-ops" "libgc" "libffi" "libc"))
 276                     (binaries  '("gcc" "ld-wrapper" "binutils"))
 277                     (library-directories
 278                      (map (lambda (lib) (input-path lib "/lib"))
 279                           libraries)))
 280
 281                (wrap-program (string-append ecl "/bin/ecl")
 282                  `("PATH" prefix
 283                    ,(map (lambda (binary)
 284                            (input-path binary "/bin"))
 285                          binaries))
 286                  `("CPATH" suffix
 287                    ,(map (lambda (lib)
 288                            (input-path lib "/include"))
 289                          `("kernel-headers" ,@libraries)))
 290                  `("LIBRARY_PATH" suffix ,library-directories)
 291                  `("LD_LIBRARY_PATH" suffix ,library-directories)))))
 292          (add-after 'wrap 'check (assoc-ref %standard-phases 'check))
 293          (add-before 'check 'fix-path-to-ecl
 294            (lambda _
 295              (substitute* "build/tests/Makefile"
 296                (("\\$\\{exec_prefix\\}/") ""))
 297              #t)))))
 298     (native-search-paths
 299      (list (search-path-specification
 300             (variable "XDG_DATA_DIRS")
 301             (files '("share")))))
 302     (home-page "http://ecls.sourceforge.net/")
 303     (synopsis "Embeddable Common Lisp")
 304     (description "ECL is an implementation of the Common Lisp language as
 305 defined by the ANSI X3J13 specification.  Its most relevant features are: a
 306 bytecode compiler and interpreter, being able to compile Common Lisp with any
 307 C/C++ compiler, being able to build standalone executables and libraries, and
 308 supporting ASDF, Sockets, Gray streams, MOP, and other useful components.")
 309     ;; Note that the file "Copyright" points to some files and directories
 310     ;; which aren't under the lgpl2.1+ and instead contain many different,
 311     ;; non-copyleft licenses.
 312     ;; See https://common-lisp.net/project/ecl/posts/ECL-license.html.
 313     (license license:lgpl2.1+)))
 314
 315 (define-public clisp
 316   (package
 317     (name "clisp")
 318     (version "2.49-92")
 319     (source
 320      (origin
 321        (method git-fetch)
 322        (uri (git-reference
 323              (url "https://gitlab.com/gnu-clisp/clisp")
 324              (commit "clisp-2.49.92-2018-02-18")))
 325        (file-name (git-file-name name version))
 326        (sha256
 327         (base32 "0k2dmgl0miz3767iks4p0mvp6xw0ysyxhjpklyh11j010rmh6hqb"))
 328        (patches (search-patches "clisp-remove-failing-test.patch"))))
 329     (build-system gnu-build-system)
 330     (inputs `(("libffcall" ,libffcall)
 331               ("ncurses" ,ncurses)
 332               ("readline" ,readline)
 333               ("libsigsegv" ,libsigsegv)))
 334     (arguments
 335      `(#:configure-flags '(,@(if (string-prefix? "armhf-linux"
 336                                                  (or (%current-system)
 337                                                      (%current-target-system)))
 338                                  '("CFLAGS=-falign-functions=4")
 339                                  '())
 340                             "--with-dynamic-ffi"
 341                             "--with-dynamic-modules"
 342                             "--with-module=rawsock")
 343        #:build #f
 344        #:phases
 345        (modify-phases %standard-phases
 346          (add-after 'unpack 'patch-sh-and-pwd
 347            (lambda _
 348              ;; The package is very messy with its references to "/bin/sh" and
 349              ;; some other absolute paths to traditional tools.  These appear in
 350              ;; many places where our automatic patching misses them.  Therefore
 351              ;; we do the following, in this early (post-unpack) phase, to solve
 352              ;; the problem from its root.
 353              (substitute* '("src/clisp-link.in"
 354                             "src/unix.d"
 355                             "src/makemake.in")
 356                (("/bin/sh") (which "sh")))
 357              (substitute* (find-files "." "configure|Makefile")
 358                (("/bin/sh") "sh"))
 359              (substitute* '("src/clisp-link.in")
 360                (("/bin/pwd") "pwd"))
 361              #t)))
 362        ;; Makefiles seem to have race conditions.
 363        #:parallel-build? #f))
 364     (home-page "https://clisp.sourceforge.io/")
 365     (synopsis "A Common Lisp implementation")
 366     (description
 367      "GNU CLISP is an implementation of ANSI Common Lisp.  Common Lisp is a
 368 high-level, object-oriented functional programming language.  CLISP includes
 369 an interpreter, a compiler, a debugger, and much more.")
 370     (license license:gpl2+)))
 371
 372 (define-public sbcl
 373   (package
 374     (name "sbcl")
 375     (version "2.0.4")
 376     (source
 377      (origin
 378        (method url-fetch)
 379        (uri (string-append "mirror://sourceforge/sbcl/sbcl/" version "/sbcl-"
 380                            version "-source.tar.bz2"))
 381        (sha256
 382         (base32 "1lc2i4qq1kfdybmxnj2zq2hn3hfx0vvlqim4gvlgvs3bfr0lcaqj"))))
 383     (build-system gnu-build-system)
 384     (outputs '("out" "doc"))
 385     (native-inputs
 386      ;; From INSTALL:
 387      ;;     Supported build hosts are:
 388      ;;       SBCL
 389      ;;       CMUCL
 390      ;;       CCL (formerly known as OpenMCL)
 391      ;;       ABCL (recent versions only)
 392      ;;       CLISP (only some versions: 2.44.1 is OK, 2.47 is not)
 393      ;;       XCL
 394      ;;
 395      ;; From NEWS:
 396      ;;     * build enhancement: new host quirks mechanism, support for building under
 397      ;;     ABCL and ECL (as well as CCL, CMUCL, CLISP and SBCL itself)
 398      ;;
 399      ;; CCL is not bootstrappable so it won't do.  CLISP 2.49 seems to work.
 400      ;; ECL too.  ECL builds SBCL about 20% slower than CLISP.  As of
 401      ;; 2019-09-05, ECL was last updated in 2020 while CLISP was last updated
 402      ;; in 2010.
 403      ;;
 404      ;; For now we stick to CLISP for all systems.  We keep the `match' here to
 405      ;; make it easier to change the host compiler for various architectures.
 406      `(,@(match (%current-system)
 407            ((or "x86_64-linux" "i686-linux")
 408             `(("clisp" ,clisp)))
 409            (_
 410             `(("clisp" ,clisp))))
 411        ("cl-asdf" ,cl-asdf)
 412        ("ed" ,ed)
 413        ("inetutils" ,inetutils)         ;for hostname(1)
 414        ("texinfo" ,texinfo)
 415        ("texlive" ,(texlive-union (list texlive-tex-texinfo)))
 416        ("which" ,which)
 417        ("zlib" ,zlib)))
 418     (arguments
 419      `(#:modules ((guix build gnu-build-system)
 420                   (guix build utils)
 421                   (srfi srfi-1))
 422        #:phases
 423        (modify-phases %standard-phases
 424          (delete 'configure)
 425          (add-after 'unpack 'replace-asdf
 426            ;; SBCL developers have not committed to keeping ASDF up to date
 427            ;; due to breaking changes [1]. Guix can handle this situation
 428            ;; easily, and it behooves us to have more control over what version
 429            ;; of ASDF we use to build software; therefore, replace the contrib
 430            ;; ASDF with the version packaged into Guix.
 431            ;; [1] - https://bugs.launchpad.net/sbcl/+bug/1823442
 432            (lambda* (#:key inputs outputs #:allow-other-keys)
 433              (let* ((cl-asdf (assoc-ref inputs "cl-asdf"))
 434                     (guix-asdf (string-append
 435                                 cl-asdf
 436                                 "/share/common-lisp/source/asdf/asdf.lisp"))
 437                     (out (string-append (assoc-ref outputs "out")))
 438                     (contrib-asdf "contrib/asdf/asdf.lisp"))
 439                (copy-file guix-asdf contrib-asdf)
 440                (substitute* contrib-asdf
 441                  ,@(asdf-substitutions name)))
 442              #t))
 443          (add-before 'build 'patch-unix-tool-paths
 444            (lambda* (#:key outputs inputs #:allow-other-keys)
 445              (let ((out (assoc-ref outputs "out"))
 446                    (bash (assoc-ref inputs "bash"))
 447                    (coreutils (assoc-ref inputs "coreutils"))
 448                    (ed (assoc-ref inputs "ed")))
 449                (define (quoted-path input path)
 450                  (string-append "\"" input path "\""))
 451                ;; Patch absolute paths in string literals.  Note that this
 452                ;; occurs in some .sh files too (which contain Lisp code).  Use
 453                ;; ISO-8859-1 because some of the files are ISO-8859-1 encoded.
 454                (with-fluids ((%default-port-encoding #f))
 455                  ;; The removed file is utf-16-be encoded, which gives substitute*
 456                  ;; trouble. It does not contain references to the listed programs.
 457                  (substitute* (delete
 458                                "./tests/data/compile-file-pos-utf16be.lisp"
 459                                (find-files "." "\\.(lisp|sh)$"))
 460                    (("\"/bin/sh\"") (quoted-path bash "/bin/sh"))
 461                    (("\"/usr/bin/env\"") (quoted-path coreutils "/usr/bin/env"))
 462                    (("\"/bin/cat\"") (quoted-path coreutils "/bin/cat"))
 463                    (("\"/bin/ed\"") (quoted-path ed "/bin/ed"))
 464                    (("\"/bin/echo\"") (quoted-path coreutils "/bin/echo"))
 465                    (("\"/bin/uname\"") (quoted-path coreutils "/bin/uname"))))
 466                ;; This one script has a non-string occurrence of /bin/sh.
 467                (substitute* '("tests/foreign.test.sh")
 468                  ;; Leave whitespace so we don't match the shebang.
 469                  ((" /bin/sh ") " sh "))
 470                ;; This file contains a module that can create executable files
 471                ;; which depend on the presence of SBCL.  It generates shell
 472                ;; scripts doing "exec sbcl ..." to achieve this.  We patch both
 473                ;; the shebang and the reference to "sbcl", tying the generated
 474                ;; executables to the exact SBCL package that generated them.
 475                (substitute* '("contrib/sb-executable/sb-executable.lisp")
 476                  (("/bin/sh") (string-append bash "/bin/sh"))
 477                  (("exec sbcl") (string-append "exec " out "/bin/sbcl")))
 478                ;; Disable some tests that fail in our build environment.
 479                (substitute* '("contrib/sb-bsd-sockets/tests.lisp")
 480                  ;; This requires /etc/protocols.
 481                  (("\\(deftest get-protocol-by-name/error" all)
 482                   (string-append "#+nil ;disabled by Guix\n" all)))
 483                (substitute* '("contrib/sb-posix/posix-tests.lisp")
 484                  ;; These assume some users/groups which we don't have.
 485                  (("\\(deftest pwent\\.[12]" all)
 486                   (string-append "#+nil ;disabled by Guix\n" all))
 487                  (("\\(deftest grent\\.[12]" all)
 488                   (string-append "#+nil ;disabled by Guix\n" all))))
 489              #t))
 490          ;; FIXME: the texlive-union insists on regenerating fonts.  It stores
 491          ;; them in HOME, so it needs to be writeable.
 492          (add-before 'build 'set-HOME
 493            (lambda _ (setenv "HOME" "/tmp") #t))
 494          (replace 'build
 495            (lambda* (#:key outputs #:allow-other-keys)
 496              (setenv "CC" "gcc")
 497              (invoke "sh" "make.sh" ,@(match (%current-system)
 498                                         ((or "x86_64-linux" "i686-linux")
 499                                          `("clisp"))
 500                                         (_
 501                                          `("clisp")))
 502                      (string-append "--prefix="
 503                                     (assoc-ref outputs "out"))
 504                      "--dynamic-space-size=2Gb"
 505                      "--with-sb-core-compression"
 506                      "--with-sb-xref-for-internals")))
 507          (replace 'install
 508            (lambda _
 509              (invoke "sh" "install.sh")))
 510          (add-after 'build 'build-doc
 511            (lambda _
 512              ;; TODO: Doc is not deterministic, maybe there is a timespamp?
 513              (with-directory-excursion "doc/manual"
 514                (and  (invoke "make" "info")
 515                      (invoke "make" "dist")))))
 516          (add-after 'build 'build-source
 517            (lambda* (#:key outputs #:allow-other-keys)
 518              (let* ((out (assoc-ref outputs "out"))
 519                     (rc (string-append out "/lib/sbcl/sbclrc"))
 520                     (source-dir (string-append out "/share/sbcl")))
 521                (for-each (lambda (p)
 522                            (copy-recursively p (string-append source-dir "/" p)))
 523                          '("src" "contrib"))
 524                (mkdir-p (dirname rc))
 525                (with-output-to-file rc
 526                  (lambda ()
 527                    (display
 528                     (string-append "(sb-ext:set-sbcl-source-location \""
 529                                    source-dir "\")") )))
 530                #t)))
 531          (add-after 'install 'install-doc
 532            (lambda* (#:key outputs #:allow-other-keys)
 533              (let* ((out (assoc-ref outputs "out"))
 534                     (doc (assoc-ref outputs "doc"))
 535                     (old-doc-dir (string-append out "/share/doc"))
 536                     (new-doc/sbcl-dir (string-append doc "/share/doc/sbcl")))
 537                (rmdir (string-append old-doc-dir "/sbcl/html"))
 538                (mkdir-p new-doc/sbcl-dir)
 539                (copy-recursively (string-append old-doc-dir "/sbcl")
 540                                  new-doc/sbcl-dir)
 541                (delete-file-recursively old-doc-dir)
 542                #t))))
 543        ;; No 'check' target, though "make.sh" (build phase) runs tests.
 544        #:tests? #f))
 545     (native-search-paths
 546      (list (search-path-specification
 547             (variable "XDG_DATA_DIRS")
 548             (files '("share")))))
 549     (home-page "http://www.sbcl.org/")
 550     (synopsis "Common Lisp implementation")
 551     (description "Steel Bank Common Lisp (SBCL) is a high performance Common
 552 Lisp compiler.  In addition to the compiler and runtime system for ANSI Common
 553 Lisp, it provides an interactive environment including a debugger, a
 554 statistical profiler, a code coverage tool, and many other extensions.")
 555     ;; Public domain in jurisdictions that allow it, bsd-2 otherwise.  MIT
 556     ;; loop macro has its own license.  See COPYING file for further notes.
 557     (license (list license:public-domain license:bsd-2
 558                    (license:x11-style "file://src/code/loop.lisp")))))
 559
 560 (define-public ccl
 561   ;; Warning: according to upstream, CCL is not bootstrappable.
 562   ;; See https://github.com/Clozure/ccl/issues/222 from 2019-09-02:
 563   ;;
 564   ;;     "As far as I know, there is no way to build CCL without an existing
 565   ;;     running CCL image. It was bootstrapped back in 1986 or so as
 566   ;;     Macintosh Common Lisp, by Gary Byers, I believe, who is no longer on
 567   ;;     the planet to tell us the story. It SHOULD be possible to port the
 568   ;;     CCL compiler to portable Common Lisp, so that ANY lisp could build
 569   ;;     it, as is the case for SBCL, but I know of no attempt to do so."
 570   (package
 571     (name "ccl")
 572     (version "1.11.5")
 573     (source #f)
 574     (build-system gnu-build-system)
 575     ;; CCL consists of a "lisp kernel" and "heap image", both of which are
 576     ;; shipped in precompiled form in source tarballs.  The former is a C
 577     ;; program which we can rebuild from scratch, but the latter cannot be
 578     ;; generated without an already working copy of CCL, and is platform
 579     ;; dependent, so we need to fetch the correct tarball for the platform.
 580     (inputs
 581      `(("ccl"
 582         ,(origin
 583            (method url-fetch)
 584            (uri (string-append
 585                  "https://github.com/Clozure/ccl/releases/download/v" version
 586                  "/ccl-" version "-"
 587                  (match (%current-system)
 588                    ((or "i686-linux" "x86_64-linux") "linuxx86")
 589                    ("armhf-linux" "linuxarm")
 590                    ;; Prevent errors when querying this package on unsupported
 591                    ;; platforms, e.g. when running "guix package --search="
 592                    (_ "UNSUPPORTED"))
 593                  ".tar.gz"))
 594            (sha256
 595             (base32
 596              (match (%current-system)
 597                ((or "i686-linux" "x86_64-linux")
 598                 "0hs1f3z7crgzvinpj990kv9gvbsipxvcvwbmk54n51nasvc5025q")
 599                ("armhf-linux"
 600                 "0p0l1dzsygb6i1xxgbipjpxkn46xhq3jm41a34ga1qqp4x8lkr62")
 601                (_ ""))))))))
 602     (native-inputs
 603      `(("m4" ,m4)
 604        ("subversion" ,subversion)))
 605     (arguments
 606      `(#:tests? #f                      ;no 'check' target
 607        #:modules ((srfi srfi-26)
 608                   (guix build utils)
 609                   (guix build gnu-build-system))
 610        #:phases
 611        (modify-phases %standard-phases
 612          (replace 'unpack
 613            (lambda* (#:key inputs #:allow-other-keys)
 614              (invoke "tar" "xzvf" (assoc-ref inputs "ccl"))
 615              (chdir "ccl")
 616              #t))
 617          (delete 'configure)
 618          (add-before 'build 'pre-build
 619            ;; Enter the source directory for the current platform's lisp
 620            ;; kernel, and run 'make clean' to remove the precompiled one.
 621            (lambda _
 622              (substitute* "lisp-kernel/m4macros.m4"
 623                (("/bin/pwd") (which "pwd")))
 624              (chdir (string-append
 625                      "lisp-kernel/"
 626                      ,(match (or (%current-target-system) (%current-system))
 627                         ("i686-linux"   "linuxx8632")
 628                         ("x86_64-linux" "linuxx8664")
 629                         ("armhf-linux"  "linuxarm")
 630                         ;; Prevent errors when querying this package
 631                         ;; on unsupported platforms, e.g. when running
 632                         ;; "guix package --search="
 633                         (_              "UNSUPPORTED"))))
 634              (substitute* '("Makefile")
 635                (("/bin/rm") "rm"))
 636              (setenv "CC" "gcc")
 637              (invoke "make" "clean")))
 638          ;; XXX Do we need to recompile the heap image as well for Guix?
 639          ;; For now just use the one we already got in the tarball.
 640          (replace 'install
 641            (lambda* (#:key outputs inputs #:allow-other-keys)
 642              ;; The lisp kernel built by running 'make' in lisp-kernel/$system
 643              ;; is put back into the original directory, so go back.  The heap
 644              ;; image is there as well.
 645              (chdir "../..")
 646              (let* ((out (assoc-ref outputs "out"))
 647                     (libdir (string-append out "/lib/"))
 648                     (bindir (string-append out "/bin/"))
 649                     (wrapper (string-append bindir "ccl"))
 650                     (bash (assoc-ref inputs "bash"))
 651                     (kernel
 652                      ,(match (or (%current-target-system) (%current-system))
 653                         ("i686-linux"   "lx86cl")
 654                         ("x86_64-linux" "lx86cl64")
 655                         ("armhf-linux"  "armcl")
 656                         ;; Prevent errors when querying this package
 657                         ;; on unsupported platforms, e.g. when running
 658                         ;; "guix package --search="
 659                         (_              "UNSUPPORTED")))
 660                     (heap (string-append kernel ".image")))
 661                (install-file kernel libdir)
 662                (install-file heap libdir)
 663
 664                (let ((dirs '("lib" "library" "examples" "tools" "objc-bridge"
 665                              ,@(match (%current-system)
 666                                 ("x86_64-linux"
 667                                  '("x86-headers64"))
 668                                 ("i686-linux"
 669                                  '("x86-headers"))
 670                                 (_ '())))))
 671                  (for-each copy-recursively
 672                            dirs
 673                            (map (cut string-append libdir <>) dirs)))
 674
 675                (mkdir-p bindir)
 676                (with-output-to-file wrapper
 677                  (lambda ()
 678                    (display
 679                     (string-append
 680                      "#!" bash "/bin/sh\n"
 681                      "export CCL_DEFAULT_DIRECTORY=" libdir "\n"
 682                      "exec -a \"$0\" " libdir kernel " \"$@\"\n"))))
 683                (chmod wrapper #o755))
 684              #t)))))
 685     (supported-systems '("i686-linux" "x86_64-linux" "armhf-linux"))
 686     (home-page "https://ccl.clozure.com/")
 687     (synopsis "Common Lisp implementation")
 688     (description "Clozure CL (often called CCL for short) is a Common Lisp
 689 implementation featuring fast compilation speed, native threads, a precise,
 690 generational, compacting garbage collector, and a convenient foreign-function
 691 interface.")
 692     ;; See file doc/LICENSE for clarifications it makes regarding how the LGPL
 693     ;; applies to Lisp code according to them.
 694     (license (list license:lgpl2.1
 695                    license:clarified-artistic)))) ;TRIVIAL-LDAP package
 696
 697 (define-public ccl-1.12
 698   ;; This is a development snapshot.  The last stable version is from November
 699   ;; 2017 and does not support package-local-nicknames, which prevents CCL
 700   ;; from compiling some third-party packages.
 701   ;; The main drawback of 1.12 is that ARM is not supported for now.
 702   (package
 703     (inherit ccl)
 704     (version "1.12-dev.5")
 705     (source (origin
 706               (method git-fetch)
 707               (uri (git-reference
 708                     (url "https://github.com/Clozure/ccl/")
 709                     (commit (string-append "v" version))))
 710               (file-name (git-file-name "ccl" version))
 711               (sha256
 712                (base32
 713                 "1za5j4ll4hk1vi1i7v1bmqhaqbsgc16izn46qmry7dnbig0rdqm0"))))
 714     ;; CCL consists of a "lisp kernel" and "heap image".
 715     ;; See comment in `ccl' package.
 716     (inputs
 717      `(("ccl-bootstrap"
 718         ,(origin
 719            (method url-fetch)
 720            (uri (string-append
 721                  "https://github.com/Clozure/ccl/releases/download/v" version "/"
 722                  (match (%current-system)
 723                    ((or "i686-linux" "x86_64-linux") "linuxx86")
 724                    ;; Prevent errors when querying this package on unsupported
 725                    ;; platforms, e.g. when running "guix package --search="
 726                    (_ "UNSUPPORTED"))
 727                  ".tar.gz"))
 728            (sha256
 729             (base32
 730              (match (%current-system)
 731                ((or "i686-linux" "x86_64-linux")
 732                 "1pqiybxxv4wx5zlp1i60nim3njaczwl5321bdwq6frjsl3s95xmb")
 733                (_ ""))))))))
 734     (arguments
 735      (substitute-keyword-arguments (package-arguments ccl)
 736        ((#:phases phases)
 737         `(modify-phases ,phases
 738            (replace 'unpack (assoc-ref %standard-phases 'unpack))
 739            (add-after 'unpack 'unpack-image
 740              (lambda* (#:key inputs #:allow-other-keys)
 741                (invoke "tar" "xzvf" (assoc-ref inputs "ccl-bootstrap"))))))))
 742     (supported-systems '("i686-linux" "x86_64-linux"))))
 743
 744 (define-public lush2
 745   (package
 746     (name "lush2")
 747     (version "2.0.1")
 748     (source
 749      (origin
 750        (method url-fetch)
 751        (uri (string-append "mirror://sourceforge/lush/lush2/lush-"
 752                            version ".tar.gz"))
 753        (modules '((guix build utils)))
 754        (snippet
 755         '(begin
 756            (substitute* "src/unix.c"
 757              (("\\{ \"LUSH_DATE\", __DATE__ \\},") "")
 758              (("\\{ \"LUSH_TIME\", __TIME__ \\},") ""))
 759            (substitute* "src/main.c"
 760              (("\" \\(built \" __DATE__ \"\\)\"") ""))
 761            #t))
 762        (sha256
 763         (base32
 764          "02pkfn3nqdkm9fm44911dbcz0v3r0l53vygj8xigl6id5g3iwi4k"))))
 765     (build-system gnu-build-system)
 766     (arguments
 767      `(;; We have to add these LIBS so that they are found.
 768        #:configure-flags (list "LIBS=-lz"
 769                                "X_EXTRA_LIBS=-lfontconfig"
 770                                "--with-x")
 771        #:tests? #f)) ; No make check.
 772     (native-inputs `(("intltool" ,intltool)))
 773     (inputs
 774      `(("alsa-lib" ,alsa-lib)
 775        ("sdl" ,sdl)
 776        ("sdl-image" ,sdl-image)
 777        ("sdl-mixer" ,sdl-mixer)
 778        ("sdl-net" ,sdl-net)
 779        ("sdl-ttf" ,sdl-ttf)
 780        ("lapack" ,lapack)
 781        ("libxft" ,libxft)
 782        ("fontconfig" ,fontconfig)
 783        ("gsl" ,gsl)
 784        ("openblas" ,openblas)
 785        ("glu" ,glu)
 786        ("mesa" ,mesa)
 787        ("mesa-utils" ,mesa-utils)
 788        ("binutils" ,binutils)
 789        ("libiberty" ,libiberty)
 790        ("readline" ,readline)
 791        ("zlib" ,zlib)
 792        ("gettext-minimal" ,gettext-minimal)))
 793     (synopsis "Lisp Universal Shell")
 794     (description
 795      "Lush is an object-oriented Lisp interpreter/compiler with features
 796 designed to please people who want to prototype large numerical
 797 applications.  Lush includes an extensive library of
 798 vector/matrix/tensor manipulation, numerous numerical libraries
 799 (including GSL, LAPACK, and BLAS), a set of graphic functions, a
 800 simple GUI toolkit, and interfaces to various graphic and multimedia
 801 libraries such as OpenGL, SDL, Video4Linux, and ALSA (video/audio
 802 grabbing), and others.  Lush is an ideal frontend script language for
 803 programming projects written in C or other languages.  Lush also has
 804 libraries for Machine Learning, Neural Nets and statistical estimation.")
 805     (home-page "http://lush.sourceforge.net/")
 806     (license license:lgpl2.1+)))
 807
 808 (define-public confusion-mdl
 809   (let* ((commit "12a055581fc262225272df43287dae48281900f5"))
 810     (package
 811       (name "confusion-mdl")
 812       (version "0.2")
 813       (source (origin
 814                 (method git-fetch)
 815                 (uri (git-reference
 816                       (url (string-append "https://gitlab.com/emacsomancer/" name))
 817                       (commit commit)))
 818                 (sha256
 819                  (base32
 820                   "1zi8kflzvwqg97ha1sa5xjisbjs5z1mvbpa772vfxiv5ksnpxp0d"))
 821                 (file-name (git-file-name name version))))
 822       (build-system gnu-build-system)
 823       (arguments
 824        `(#:tests? #f                    ; there are no tests
 825          #:phases
 826          (modify-phases %standard-phases
 827            (delete 'configure)
 828            (replace 'build
 829              (lambda* (#:key (make-flags '()) #:allow-other-keys)
 830                (apply invoke "make" "CC=gcc" make-flags)))
 831            (replace 'install
 832              (lambda* (#:key outputs #:allow-other-keys)
 833                (let* ((out (assoc-ref outputs "out"))
 834                       (bin (string-append out "/bin")))
 835                  (install-file "mdli" bin)
 836                  #t))))))
 837       (native-inputs
 838        `(("perl" ,perl)))
 839       (inputs
 840        `(("libgc" ,libgc)))
 841       (synopsis "Interpreter for the MIT Design Language (MDL)")
 842       (description "MDL (the MIT Design Language) is a descendant of Lisp.  It
 843 was originally developed in 1971 on the PDP-10 computer under the Incompatible
 844 Timesharing System (ITS) to provide high level language support for the
 845 Dynamic Modeling Group at MIT's Project MAC.  Infocom built the original
 846 PDP-10 Zork in MDL and their later ZIL (Zork Implementation Language) was
 847 based on a subset of MDL.  Confusion is a MDL interpreter that works just well
 848 enough to play the original mainframe Zork all the way through.")
 849       (home-page "http://www.russotto.net/git/mrussotto/confusion/src/master/src/README")
 850       (license license:gpl3+))))
 851
 852 (define-public txr
 853   (package
 854     (name "txr")
 855     (version "235")
 856     (source
 857      (origin
 858        (method git-fetch)
 859        (uri (git-reference
 860              (url "http://www.kylheku.com/git/txr/")
 861              (commit (string-append "txr-" version))))
 862        (file-name (git-file-name name version))
 863        (sha256
 864         (base32 "0kpqk2x0sz7sqxsrhasq0xnljjlnxwhh4xjx2nii0zy2jkv4vsbn"))))
 865     (build-system gnu-build-system)
 866     (arguments
 867      '(#:configure-flags
 868        (list "cc=gcc"
 869              (string-append "--prefix=" (assoc-ref %outputs "out")))
 870        #:test-target "tests"
 871        #:phases
 872        (modify-phases %standard-phases
 873          (replace 'configure
 874            ;; ./configure is a hand-written script that can't handle standard
 875            ;; autotools arguments like CONFIG_SHELL.
 876            (lambda* (#:key configure-flags #:allow-other-keys)
 877              (setenv "txr_shell" (which "bash"))
 878              (apply invoke "./configure" configure-flags)
 879              #t))
 880          (add-after 'configure 'fix-tests
 881            (lambda _
 882              (substitute* (list "tests/017/realpath.tl"
 883                                 "tests/017/realpath.expected")
 884                (("/usr/bin") "/"))
 885              #t)))))
 886     (native-inputs
 887      `(("bison" ,bison)
 888        ("flex" ,flex)))
 889     (inputs
 890      `(("libffi" ,libffi)))
 891     (synopsis "General-purpose, multi-paradigm programming language")
 892     (description
 893      "TXR is a general-purpose, multi-paradigm programming language.  It
 894 comprises two languages integrated into a single tool: a text scanning and
 895 extraction language referred to as the TXR Pattern Language (sometimes just
 896 \"TXR\"), and a general-purpose dialect of Lisp called TXR Lisp.  TXR can be
 897 used for everything from \"one liner\" data transformation tasks at the
 898 command line, to data scanning and extracting scripts, to full application
 899 development in a wide-range of areas.")
 900     (home-page "https://nongnu.org/txr/")
 901     (license license:bsd-2)))
 902
 903 (define picolisp32
 904   (package
 905     (name "picolisp32")
 906     (version "19.12")
 907     (source
 908      (origin
 909        (method url-fetch)
 910        (uri (string-append "https://software-lab.de/picoLisp-" version ".tgz"))
 911        (sha256
 912         (base32 "10np0mhihr47r3201617zccrvzpkhdl1jwvz7zimk8kxpriydq2j"))
 913        (modules '((guix build utils)))
 914        (snippet '(begin
 915                    ;; Delete the pre-compiled jar file.
 916                    (delete-file "ersatz/picolisp.jar")
 917                    #t))))
 918     (build-system gnu-build-system)
 919     (inputs
 920      `(("openssl" ,openssl)))
 921     (arguments
 922      `(#:system ,(match (%current-system)
 923                    ((or "armhf-linux" "aarch64-linux")
 924                     "armhf-linux")
 925                    (_
 926                     "i686-linux"))
 927        #:phases
 928        (modify-phases %standard-phases
 929          (delete 'configure)
 930          (add-after 'unpack 'fix-paths
 931            (lambda* (#:key outputs #:allow-other-keys)
 932              (let* ((out (assoc-ref outputs "out"))
 933                     (shebang-line (string-append
 934                                    "#!" out "/bin/picolisp "
 935                                    out "/lib/picolisp/lib.l")))
 936                (substitute* '("bin/pil"
 937                               "bin/pilIndent"
 938                               "bin/pilPretty"
 939                               "bin/psh"
 940                               "bin/replica"
 941                               "bin/vip"
 942                               "bin/watchdog"
 943                               "games/xchess"
 944                               "misc/bigtest"
 945                               "misc/calc"
 946                               "misc/chat"
 947                               "misc/mailing"
 948                               "src/mkVers")
 949                  (("#\\!bin/picolisp lib.l")
 950                   shebang-line)
 951                  (("#\\!\\.\\./bin/picolisp \\.\\./lib.l")
 952                   shebang-line)
 953                  (("#\\!/usr/bin/picolisp /usr/lib/picolisp/lib.l")
 954                   shebang-line)))
 955              #t))
 956          (add-after 'fix-paths 'make-build-reproducible
 957            (lambda _
 958              (substitute* "src64/lib/asm.l"
 959                (("\\(prinl \"/\\* \" \\(datSym \\(date\\)\\) \" \\*/\\)")
 960                 ""))
 961              #t))
 962          (add-after 'make-build-reproducible 'fix-permissions
 963            (lambda _
 964              (for-each make-file-writable
 965                        '("doc/family.tgz"
 966                          "doc/family64.tgz"
 967                          "lib/map"
 968                          "src64/tags"))
 969              #t))
 970          (replace 'build
 971            (lambda _
 972              (invoke "make" "-C" "src" "picolisp" "tools" "gate")))
 973          (add-before 'check 'set-home-for-tests
 974            (lambda _
 975              (setenv "HOME" "/tmp")
 976              #t))
 977          (replace 'check
 978            (lambda _
 979              (invoke "./pil" "test/lib.l" "-bye" "+")))
 980          (replace 'install
 981            (lambda* (#:key outputs #:allow-other-keys)
 982              (let* ((out (assoc-ref outputs "out"))
 983                     (bin (string-append out "/bin"))
 984                     (man (string-append out "/share/man"))
 985                     (picolisp (string-append out "/lib/picolisp")))
 986                (copy-recursively "man" man)
 987                (copy-recursively "." picolisp)
 988                (for-each (lambda (name)
 989                            (let ((path (string-append picolisp "/" name)))
 990                              (delete-file-recursively path)))
 991                          '("CHANGES" "COPYING" "CREDITS" "cygwin"
 992                            "INSTALL" "man" "pil" "README" "src" "src64"
 993                            "test"))
 994                (mkdir-p bin)
 995                (symlink (string-append picolisp "/bin/picolisp")
 996                         (string-append bin "/picolisp"))
 997                (symlink (string-append picolisp "/bin/pil")
 998                         (string-append bin "/pil")))
 999              #t)))))
1000     (synopsis "Interpreter for the PicoLisp programming language")
1001     (description
1002      "PicoLisp is a programming language, or really a programming system,
1003 including a built-in database engine and a GUI system.")
1004     (home-page "https://picolisp.com/wiki/?home")
1005     (license license:expat)))
1006
1007 (define-public picolisp
1008   (match (%current-system)
1009     ((or "aarch64-linux" "x86_64-linux")
1010      (package
1011        ;; Use the 32-bit picolisp to generate the assembly files required by
1012        ;; the 64-bit picolisp.
1013        (inherit picolisp32)
1014        (name "picolisp")
1015        (native-inputs
1016         `(("picolisp32" ,picolisp32)
1017           ("which" ,which)))
1018        (arguments
1019         (substitute-keyword-arguments (package-arguments picolisp32)
1020           ((#:system _ "") (%current-system))
1021           ((#:phases phases)
1022            `(modify-phases ,phases
1023               (delete 'fix-paths)
1024               (add-before 'build 'fix-paths
1025                 ;; This must run after the other shebang-patching phases,
1026                 ;; or they will override our changes.
1027                 (lambda* (#:key inputs outputs #:allow-other-keys)
1028                   (let* ((picolisp32 (assoc-ref inputs "picolisp32"))
1029                          (out (assoc-ref outputs "out"))
1030                          (shebang-line (string-append
1031                                         "#!" out "/bin/picolisp "
1032                                         out "/lib/picolisp/lib.l")))
1033                     (substitute* '("bin/pil"
1034                                    "bin/pilIndent"
1035                                    "bin/pilPretty"
1036                                    "bin/psh"
1037                                    "bin/replica"
1038                                    "bin/vip"
1039                                    "bin/watchdog"
1040                                    "games/xchess"
1041                                    "misc/bigtest"
1042                                    "misc/calc"
1043                                    "misc/chat"
1044                                    "misc/mailing"
1045                                    "src/mkVers")
1046                       (("#\\!.*picolisp32.*/bin/picolisp .*lib\\.l")
1047                        shebang-line))
1048                     (substitute* "src64/mkAsm"
1049                       (("/usr/bin/")
1050                        (string-append picolisp32 "/bin/"))))
1051                   #t))
1052               (replace 'build
1053                 (lambda _
1054                   (invoke "make" "-C" "src" "tools" "gate")
1055                   (invoke "make" "-C" "src64" "CC=gcc" "picolisp")))))))))
1056     (_
1057      (package
1058        (inherit picolisp32)
1059        (name "picolisp")))))