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 <contact.ng0@cryptolab.net>
   7 ;;; Copyright © 2016 Andy Patterson <ajpatter@uwaterloo.ca>
   8 ;;; Copyright © 2017 Ricardo Wurmus <rekado@elephly.net>
   9 ;;;
  10 ;;; This file is part of GNU Guix.
  11 ;;;
  12 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  13 ;;; under the terms of the GNU General Public License as published by
  14 ;;; the Free Software Foundation; either version 3 of the License, or (at
  15 ;;; your option) any later version.
  16 ;;;
  17 ;;; GNU Guix is distributed in the hope that it will be useful, but
  18 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;;; GNU General Public License for more details.
  21 ;;;
  22 ;;; You should have received a copy of the GNU General Public License
  23 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 (define-module (gnu packages lisp)
  26   #:use-module (gnu packages)
  27   #:use-module ((guix licenses) #:prefix license:)
  28   #:use-module (guix packages)
  29   #:use-module (gnu packages readline)
  30   #:use-module (gnu packages texinfo)
  31   #:use-module (gnu packages tex)
  32   #:use-module (gnu packages m4)
  33   #:use-module (guix download)
  34   #:use-module (guix git-download)
  35   #:use-module (guix utils)
  36   #:use-module (guix build-system gnu)
  37   #:use-module (guix build-system asdf)
  38   #:use-module (guix build-system trivial)
  39   #:use-module (gnu packages base)
  40   #:use-module (gnu packages compression)
  41   #:use-module (gnu packages fontutils)
  42   #:use-module (gnu packages maths)
  43   #:use-module (gnu packages multiprecision)
  44   #:use-module (gnu packages bdw-gc)
  45   #:use-module (gnu packages libffi)
  46   #:use-module (gnu packages libffcall)
  47   #:use-module (gnu packages readline)
  48   #:use-module (gnu packages sdl)
  49   #:use-module (gnu packages libsigsegv)
  50   #:use-module (gnu packages linux)
  51   #:use-module (gnu packages admin)
  52   #:use-module (gnu packages ed)
  53   #:use-module (gnu packages gl)
  54   #:use-module (gnu packages gcc)
  55   #:use-module (gnu packages glib)
  56   #:use-module (gnu packages gettext)
  57   #:use-module (gnu packages m4)
  58   #:use-module (gnu packages pkg-config)
  59   #:use-module (gnu packages version-control)
  60   #:use-module (gnu packages xorg)
  61   #:use-module (ice-9 match)
  62   #:use-module (srfi srfi-1))
  63
  64 (define (asdf-substitutions lisp)
  65   ;; Prepend XDG_DATA_DIRS/LISP-bundle-systems to ASDF's
  66   ;; 'default-system-source-registry'.
  67   `((("\\(,dir \"systems/\"\\)\\)")
  68      (format #f
  69              "(,dir \"~a-bundle-systems\")))
  70
  71       ,@(loop :for dir :in (xdg-data-dirs \"common-lisp/\")
  72               :collect `(:directory (,dir \"systems\"))"
  73              ,lisp))))
  74
  75 (define-public gcl
  76   (package
  77     (name "gcl")
  78     (version "2.6.12")
  79     (source
  80      (origin
  81       (method url-fetch)
  82       (uri (string-append "mirror://gnu/" name "/" name "-" version ".tar.gz"))
  83       (sha256
  84        (base32 "1s4hs2qbjqmn9h88l4xvsifq5c3dlc5s74lyb61rdi5grhdlkf4f"))))
  85     (build-system gnu-build-system)
  86     (arguments
  87      `(#:parallel-build? #f  ; The build system seems not to be thread safe.
  88        #:tests? #f  ; There does not seem to be make check or anything similar.
  89        #:configure-flags '("--enable-ansi") ; required for use by the maxima package
  90        #:phases (alist-cons-before
  91                 'configure 'pre-conf
  92                 (lambda _
  93                   ;; Patch bug when building readline support.  This bug was
  94                   ;; also observed by Debian
  95                   ;; https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=741819
  96                   (substitute* "o/gcl_readline.d"
  97                     (("rl_attempted_completion_function = \
  98 \\(CPPFunction \\*\\)rl_completion;")
  99                       "rl_attempted_completion_function = rl_completion;"))
 100                   (substitute*
 101                       (append
 102                        '("pcl/impl/kcl/makefile.akcl"
 103                          "add-defs"
 104                          "unixport/makefile.dos"
 105                          "add-defs.bat"
 106                          "gcl-tk/makefile.prev"
 107                          "add-defs1")
 108                        (find-files "h" "\\.defs"))
 109                     (("SHELL=/bin/(ba)?sh")
 110                      (string-append "SHELL=" (which "bash")))))
 111                 ;; drop strip phase to make maxima build, see
 112                 ;; https://www.ma.utexas.edu/pipermail/maxima/2008/009769.html
 113                 (alist-delete 'strip
 114                  %standard-phases))))
 115     (native-inputs
 116      `(("m4" ,m4)
 117        ("readline" ,readline)
 118        ("texinfo" ,texinfo)
 119        ("texlive" ,texlive)))
 120     (home-page "https://www.gnu.org/software/gcl/")
 121     (synopsis "A Common Lisp implementation")
 122     (description "GCL is an implementation of the Common Lisp language.  It
 123 features the ability to compile to native object code and to load native
 124 object code modules directly into its lisp core.  It also features a
 125 stratified garbage collection strategy, a source-level debugger and a built-in
 126 interface to the Tk widget system.")
 127     (license license:lgpl2.0+)))
 128
 129 (define-public ecl
 130   (package
 131     (name "ecl")
 132     (version "16.1.3")
 133     (source
 134      (origin
 135        (method url-fetch)
 136        (uri (string-append
 137              "https://common-lisp.net/project/ecl/static/files/release/"
 138              name "-" version ".tgz"))
 139        (sha256
 140         (base32 "0m0j24w5d5a9dwwqyrg0d35c0nys16ijb4r0nyk87yp82v38b9bn"))
 141        (modules '((guix build utils)))
 142        (snippet
 143         ;; Add ecl-bundle-systems to 'default-system-source-registry'.
 144         `(substitute* "contrib/asdf/asdf.lisp"
 145            ,@(asdf-substitutions name)))))
 146     (build-system gnu-build-system)
 147     ;; src/configure uses 'which' to confirm the existence of 'gzip'.
 148     (native-inputs `(("which" ,which)))
 149     (inputs `(("gmp" ,gmp)
 150               ("libatomic-ops" ,libatomic-ops)
 151               ("libgc" ,libgc)
 152               ("libffi" ,libffi)))
 153     (arguments
 154      '(#:tests? #t
 155        #:parallel-tests? #f
 156        #:phases
 157        (modify-phases %standard-phases
 158          (delete 'check)
 159          (add-after 'install 'wrap
 160            (lambda* (#:key inputs outputs #:allow-other-keys)
 161              (let* ((ecl (assoc-ref outputs "out"))
 162                     (input-path (lambda (lib path)
 163                                   (string-append
 164                                    (assoc-ref inputs lib) path)))
 165                     (libraries '("gmp" "libatomic-ops" "libgc" "libffi" "libc"))
 166                     (binaries  '("gcc" "ld-wrapper" "binutils"))
 167                     (library-directories
 168                      (map (lambda (lib) (input-path lib "/lib"))
 169                           libraries)))
 170
 171                (wrap-program (string-append ecl "/bin/ecl")
 172                  `("PATH" prefix
 173                    ,(map (lambda (binary)
 174                            (input-path binary "/bin"))
 175                          binaries))
 176                  `("CPATH" suffix
 177                    ,(map (lambda (lib)
 178                            (input-path lib "/include"))
 179                          `("kernel-headers" ,@libraries)))
 180                  `("LIBRARY_PATH" suffix ,library-directories)
 181                  `("LD_LIBRARY_PATH" suffix ,library-directories)))))
 182          (add-after 'wrap 'check (assoc-ref %standard-phases 'check))
 183          (add-before 'check 'fix-path-to-ecl
 184            (lambda _
 185              (substitute* "build/tests/Makefile"
 186                (("\\$\\{exec_prefix\\}/") ""))
 187              #t)))))
 188     (native-search-paths
 189      (list (search-path-specification
 190             (variable "XDG_DATA_DIRS")
 191             (files '("share")))))
 192     (home-page "http://ecls.sourceforge.net/")
 193     (synopsis "Embeddable Common Lisp")
 194     (description "ECL is an implementation of the Common Lisp language as
 195 defined by the ANSI X3J13 specification.  Its most relevant features are: a
 196 bytecode compiler and interpreter, being able to compile Common Lisp with any
 197 C/C++ compiler, being able to build standalone executables and libraries, and
 198 supporting ASDF, Sockets, Gray streams, MOP, and other useful components.")
 199     ;; Note that the file "Copyright" points to some files and directories
 200     ;; which aren't under the lgpl2.0+ and instead contain many different,
 201     ;; non-copyleft licenses.
 202     (license license:lgpl2.0+)))
 203
 204 (define-public clisp
 205   (package
 206     (name "clisp")
 207     (version "2.49")
 208     (source
 209      (origin
 210        (method url-fetch)
 211        (uri (string-append "mirror://gnu/clisp/release/" version
 212                            "/clisp-" version ".tar.gz"))
 213        (sha256
 214         (base32 "0rp82nqp5362isl9i34rwgg04cidz7izljd9d85pqcw1qr964bxx"))))
 215     (build-system gnu-build-system)
 216     (inputs `(("libffcall" ,libffcall)
 217               ("readline" ,readline-6.2)
 218               ("libsigsegv" ,libsigsegv)))
 219     (arguments
 220      '(;; XXX The custom configure script does not cope well when passed
 221        ;; --build=<triplet>.
 222        #:build #f
 223        #:phases
 224        (modify-phases %standard-phases
 225          (add-after 'unpack 'patch-sh-and-pwd
 226            (lambda _
 227              ;; The package is very messy with its references to "/bin/sh" and
 228              ;; some other absolute paths to traditional tools.  These appear in
 229              ;; many places where our automatic patching misses them.  Therefore
 230              ;; we do the following, in this early (post-unpack) phase, to solve
 231              ;; the problem from its root.
 232              (substitute* (find-files "." "configure|Makefile")
 233                (("/bin/sh") "sh"))
 234              (substitute* '("src/clisp-link.in")
 235                (("/bin/pwd") "pwd"))
 236              #t))
 237          (add-after 'unpack 'remove-timestamps
 238            (lambda _
 239              (substitute* "src/constobj.d"
 240                (("__DATE__ __TIME__") "\"1\""))
 241              #t))
 242          (add-before 'build 'chdir-to-source
 243            (lambda _
 244              ;; We are supposed to call make under the src sub-directory.
 245              (chdir "src")
 246              #t)))
 247        ;; Makefiles seem to have race conditions.
 248        #:parallel-build? #f))
 249     (home-page "http://www.clisp.org/")
 250     (synopsis "A Common Lisp implementation")
 251     (description
 252      "GNU CLISP is an implementation of ANSI Common Lisp.  Common Lisp is a
 253 high-level, object-oriented functional programming language.  CLISP includes
 254 an interpreter, a compiler, a debugger, and much more.")
 255     ;; Website says gpl2+, COPYRIGHT file says gpl2; actual source files have
 256     ;; a lot of gpl3+.  (Also some parts are under non-copyleft licenses, such
 257     ;; as CLX by Texas Instruments.)  In that case gpl3+ wins out.
 258     (license license:gpl3+)))
 259
 260 (define-public sbcl
 261   (package
 262     (name "sbcl")
 263     (version "1.3.7")
 264     (source
 265      (origin
 266        (method url-fetch)
 267        (uri (string-append "mirror://sourceforge/sbcl/sbcl/" version "/sbcl-"
 268                            version "-source.tar.bz2"))
 269        (sha256
 270         (base32 "0fjdqnb2rsm2vi9794ywp27jr239ddvzc4xfr0dk49jd4v7p2kc5"))
 271        (modules '((guix build utils)))
 272        (snippet
 273         ;; Add sbcl-bundle-systems to 'default-system-source-registry'.
 274         `(substitute* "contrib/asdf/asdf.lisp"
 275            ,@(asdf-substitutions name)))))
 276     (build-system gnu-build-system)
 277     (outputs '("out" "doc"))
 278     ;; Bootstrap with CLISP.
 279     (native-inputs
 280      `(("clisp" ,clisp)
 281        ("which" ,which)
 282        ("inetutils" ,inetutils)         ;for hostname(1)
 283        ("ed" ,ed)
 284        ("texlive" ,texlive)
 285        ("texinfo" ,texinfo)))
 286     (arguments
 287      '(#:phases
 288        (modify-phases %standard-phases
 289          (delete 'configure)
 290          (add-before 'build 'patch-unix-tool-paths
 291            (lambda* (#:key outputs inputs #:allow-other-keys)
 292              (let ((out (assoc-ref outputs "out"))
 293                    (bash (assoc-ref inputs "bash"))
 294                    (coreutils (assoc-ref inputs "coreutils"))
 295                    (ed (assoc-ref inputs "ed")))
 296                (define (quoted-path input path)
 297                  (string-append "\"" input path "\""))
 298                ;; Patch absolute paths in string literals.  Note that this
 299                ;; occurs in some .sh files too (which contain Lisp code).  Use
 300                ;; ISO-8859-1 because some of the files are ISO-8859-1 encoded.
 301                (with-fluids ((%default-port-encoding #f))
 302                  ;; The removed file is utf-16-be encoded, which gives substitute*
 303                  ;; trouble. It does not contain references to the listed programs.
 304                  (substitute* (delete
 305                                "./tests/data/compile-file-pos-utf16be.lisp"
 306                                (find-files "." "\\.(lisp|sh)$"))
 307                    (("\"/bin/sh\"") (quoted-path bash "/bin/sh"))
 308                    (("\"/usr/bin/env\"") (quoted-path coreutils "/usr/bin/env"))
 309                    (("\"/bin/cat\"") (quoted-path coreutils "/bin/cat"))
 310                    (("\"/bin/ed\"") (quoted-path ed "/bin/ed"))
 311                    (("\"/bin/echo\"") (quoted-path coreutils "/bin/echo"))
 312                    (("\"/bin/uname\"") (quoted-path coreutils "/bin/uname"))))
 313                ;; This one script has a non-string occurrence of /bin/sh.
 314                (substitute* '("tests/foreign.test.sh")
 315                  ;; Leave whitespace so we don't match the shebang.
 316                  ((" /bin/sh ") " sh "))
 317                ;; This file contains a module that can create executable files
 318                ;; which depend on the presence of SBCL.  It generates shell
 319                ;; scripts doing "exec sbcl ..." to achieve this.  We patch both
 320                ;; the shebang and the reference to "sbcl", tying the generated
 321                ;; executables to the exact SBCL package that generated them.
 322                (substitute* '("contrib/sb-executable/sb-executable.lisp")
 323                  (("/bin/sh") (string-append bash "/bin/sh"))
 324                  (("exec sbcl") (string-append "exec " out "/bin/sbcl")))
 325                ;; Disable some tests that fail in our build environment.
 326                (substitute* '("contrib/sb-bsd-sockets/tests.lisp")
 327                  ;; This requires /etc/protocols.
 328                  (("\\(deftest get-protocol-by-name/error" all)
 329                   (string-append "#+nil ;disabled by Guix\n" all)))
 330                (substitute* '("contrib/sb-posix/posix-tests.lisp")
 331                  ;; These assume some users/groups which we don't have.
 332                  (("\\(deftest pwent\\.[12]" all)
 333                   (string-append "#+nil ;disabled by Guix\n" all))
 334                  (("\\(deftest grent\\.[12]" all)
 335                   (string-append "#+nil ;disabled by Guix\n" all))))))
 336          (replace 'build
 337            (lambda* (#:key outputs #:allow-other-keys)
 338              (setenv "CC" "gcc")
 339              (zero? (system* "sh" "make.sh" "clisp"
 340                              (string-append "--prefix="
 341                                             (assoc-ref outputs "out"))))))
 342          (replace 'install
 343            (lambda _
 344              (zero? (system* "sh" "install.sh"))))
 345          (add-after 'build 'build-doc
 346            (lambda _
 347              (with-directory-excursion "doc/manual"
 348                (and  (zero? (system* "make" "info"))
 349                      (zero? (system* "make" "dist"))))))
 350          (add-after 'install 'install-doc
 351            (lambda* (#:key outputs #:allow-other-keys)
 352              (let* ((out (assoc-ref outputs "out"))
 353                     (doc (assoc-ref outputs "doc"))
 354                     (old-doc-dir (string-append out "/share/doc"))
 355                     (new-doc/sbcl-dir (string-append doc "/share/doc/sbcl")))
 356                (rmdir (string-append old-doc-dir "/sbcl/html"))
 357                (mkdir-p new-doc/sbcl-dir)
 358                (copy-recursively (string-append old-doc-dir "/sbcl")
 359                                  new-doc/sbcl-dir)
 360                (delete-file-recursively old-doc-dir)
 361                #t))))
 362          ;; No 'check' target, though "make.sh" (build phase) runs tests.
 363          #:tests? #f))
 364     (native-search-paths
 365      (list (search-path-specification
 366             (variable "XDG_DATA_DIRS")
 367             (files '("share")))))
 368     (home-page "http://www.sbcl.org/")
 369     (synopsis "Common Lisp implementation")
 370     (description "Steel Bank Common Lisp (SBCL) is a high performance Common
 371 Lisp compiler.  In addition to the compiler and runtime system for ANSI Common
 372 Lisp, it provides an interactive environment including a debugger, a
 373 statistical profiler, a code coverage tool, and many other extensions.")
 374     ;; Public domain in jurisdictions that allow it, bsd-2 otherwise.  MIT
 375     ;; loop macro has its own license.  See COPYING file for further notes.
 376     (license (list license:public-domain license:bsd-2
 377                    (license:x11-style "file://src/code/loop.lisp")))))
 378
 379 (define-public ccl
 380   (package
 381     (name "ccl")
 382     (version "1.11")
 383     (source #f)
 384     (build-system gnu-build-system)
 385     ;; CCL consists of a "lisp kernel" and "heap image", both of which are
 386     ;; shipped in precompiled form in source tarballs.  The former is a C
 387     ;; program which we can rebuild from scratch, but the latter cannot be
 388     ;; generated without an already working copy of CCL, and is platform
 389     ;; dependent, so we need to fetch the correct tarball for the platform.
 390     (inputs
 391      `(("ccl"
 392         ,(origin
 393            (method url-fetch)
 394            (uri (string-append
 395                  "ftp://ftp.clozure.com/pub/release/" version
 396                  "/ccl-" version "-"
 397                  (match (%current-system)
 398                    ((or "i686-linux" "x86_64-linux") "linuxx86")
 399                    ("armhf-linux" "linuxarm")
 400                    ;; Prevent errors when querying this package on unsupported
 401                    ;; platforms, e.g. when running "guix package --search="
 402                    (_ "UNSUPPORTED"))
 403                  ".tar.gz"))
 404            (sha256
 405             (base32
 406              (match (%current-system)
 407                ((or "i686-linux" "x86_64-linux")
 408                 "0w3dmj7q9kqyra3yrf1lxclnjz151yvf5s5q8ayllvmvqbl8bs08")
 409                ("armhf-linux"
 410                 "1x487aaz2rqcb6k301sy2p39a1m4qdhg6z9p9fb76ssipqgr38b4")
 411                (_ ""))))))))
 412     (native-inputs
 413      `(("m4" ,m4)
 414        ("subversion" ,subversion)))
 415     (arguments
 416      `(#:tests? #f                      ;no 'check' target
 417        #:phases
 418        (alist-replace
 419         'unpack
 420         (lambda* (#:key inputs #:allow-other-keys)
 421           (and (zero? (system* "tar" "xzvf" (assoc-ref inputs "ccl")))
 422                (begin (chdir "ccl") #t)))
 423         (alist-delete
 424          'configure
 425          (alist-cons-before
 426           'build 'pre-build
 427           ;; Enter the source directory for the current platform's lisp
 428           ;; kernel, and run 'make clean' to remove the precompiled one.
 429           (lambda _
 430             (chdir (string-append
 431                     "lisp-kernel/"
 432                     ,(match (or (%current-target-system) (%current-system))
 433                        ("i686-linux"   "linuxx8632")
 434                        ("x86_64-linux" "linuxx8664")
 435                        ("armhf-linux"  "linuxarm")
 436                        ;; Prevent errors when querying this package
 437                        ;; on unsupported platforms, e.g. when running
 438                        ;; "guix package --search="
 439                        (_              "UNSUPPORTED"))))
 440             (substitute* '("Makefile")
 441               (("/bin/rm") "rm"))
 442             (setenv "CC" "gcc")
 443             (zero? (system* "make" "clean")))
 444           ;; XXX Do we need to recompile the heap image as well for Guix?
 445           ;; For now just use the one we already got in the tarball.
 446           (alist-replace
 447            'install
 448            (lambda* (#:key outputs inputs #:allow-other-keys)
 449              ;; The lisp kernel built by running 'make' in lisp-kernel/$system
 450              ;; is put back into the original directory, so go back.  The heap
 451              ;; image is there as well.
 452              (chdir "../..")
 453              (let* ((out (assoc-ref outputs "out"))
 454                     (libdir (string-append out "/lib/"))
 455                     (bindir (string-append out "/bin/"))
 456                     (wrapper (string-append bindir "ccl"))
 457                     (bash (assoc-ref inputs "bash"))
 458                     (kernel
 459                      ,(match (or (%current-target-system) (%current-system))
 460                         ("i686-linux"   "lx86cl")
 461                         ("x86_64-linux" "lx86cl64")
 462                         ("armhf-linux"  "armcl")
 463                         ;; Prevent errors when querying this package
 464                         ;; on unsupported platforms, e.g. when running
 465                         ;; "guix package --search="
 466                         (_              "UNSUPPORTED")))
 467                     (heap (string-append kernel ".image")))
 468                (mkdir-p libdir)
 469                (mkdir-p bindir)
 470                (copy-file kernel (string-append libdir kernel))
 471                (copy-file heap (string-append libdir heap))
 472                (with-output-to-file wrapper
 473                  (lambda ()
 474                    (display
 475                     (string-append
 476                      "#!" bash "/bin/sh\n"
 477                      "if [ -z \"$CCL_DEFAULT_DIRECTORY\" ]; then\n"
 478                      "    CCL_DEFAULT_DIRECTORY=" libdir "\n"
 479                      "fi\n"
 480                      "export CCL_DEFAULT_DIRECTORY\n"
 481                      "exec " libdir kernel "\n"))))
 482                (chmod wrapper #o755)))
 483            %standard-phases))))))
 484     (supported-systems '("i686-linux" "x86_64-linux" "armhf-linux"))
 485     (home-page "http://ccl.clozure.com/")
 486     (synopsis "Common Lisp implementation")
 487     (description "Clozure CL (often called CCL for short) is a Common Lisp
 488 implementation featuring fast compilation speed, native threads, a precise,
 489 generational, compacting garbage collector, and a convenient foreign-function
 490 interface.")
 491     ;; See file doc/LICENSE for clarifications it makes regarding how the LGPL
 492     ;; applies to Lisp code according to them.
 493     (license (list license:lgpl2.1
 494                    license:clarified-artistic)))) ;TRIVIAL-LDAP package
 495
 496 (define-public femtolisp
 497   (let ((commit "68c5b1225572ecf2c52baf62f928063e5a30511b")
 498         (revision "1"))
 499     (package
 500       (name "femtolisp")
 501       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 502       (source (origin
 503                 (method git-fetch)
 504                 (uri (git-reference
 505                       (url "https://github.com/JeffBezanson/femtolisp.git")
 506                       (commit commit)))
 507                 (file-name (string-append name "-" version "-checkout"))
 508                 (sha256
 509                  (base32
 510                   "04rnwllxnl86zw8c6pwxznn49bvkvh0f1lfliy085vjzvlq3rgja"))))
 511       ;; See "utils.h" for supported systems. Upstream bug:
 512       ;; https://github.com/JeffBezanson/femtolisp/issues/25
 513       (supported-systems
 514        (fold delete %supported-systems
 515              '("armhf-linux" "mips64el-linux")))
 516       (build-system gnu-build-system)
 517       (arguments
 518        `(#:make-flags '("CC=gcc" "release")
 519          #:test-target "test"
 520          #:phases
 521          (modify-phases %standard-phases
 522            (delete 'configure) ; No configure script
 523            (replace 'install ; Makefile has no 'install phase
 524             (lambda* (#:key outputs #:allow-other-keys)
 525               (let* ((out (assoc-ref outputs "out"))
 526                      (bin (string-append out "/bin")))
 527                 (install-file "flisp" bin)
 528                 #t)))
 529            ;; The flisp binary is now available, run bootstrap to
 530            ;; generate flisp.boot and afterwards runs make test.
 531            (add-after 'install 'bootstrap-gen-and-test
 532              (lambda* (#:key outputs #:allow-other-keys)
 533               (let* ((out (assoc-ref outputs "out"))
 534                      (bin (string-append out "/bin")))
 535                 (and
 536                  (zero? (system* "./bootstrap.sh"))
 537                  (install-file "flisp.boot" bin))))))))
 538       (synopsis "Scheme-like lisp implementation")
 539       (description
 540        "@code{femtolisp} is a scheme-like lisp implementation with a
 541 simple, elegant Scheme dialect.  It is a lisp-1 with lexical scope.
 542 The core is 12 builtin special forms and 33 builtin functions.")
 543       (home-page "https://github.com/JeffBezanson/femtolisp")
 544       (license license:bsd-3))))
 545
 546 (define-public lush2
 547   (package
 548     (name "lush2")
 549     (version "2.0.1")
 550     (source
 551      (origin
 552        (method url-fetch)
 553        (uri (string-append "mirror://sourceforge/lush/lush2/lush-"
 554                            version ".tar.gz"))
 555        (modules '((guix build utils)))
 556        (snippet
 557         '(begin
 558            (substitute* "src/unix.c"
 559                (("\\{ \"LUSH_DATE\", __DATE__ \\},") "")
 560                (("\\{ \"LUSH_TIME\", __TIME__ \\},") ""))
 561              (substitute* "src/main.c"
 562                (("\" \\(built \" __DATE__ \"\\)\"") ""))))
 563        (sha256
 564         (base32
 565          "02pkfn3nqdkm9fm44911dbcz0v3r0l53vygj8xigl6id5g3iwi4k"))))
 566     (build-system gnu-build-system)
 567     (arguments
 568      `(;; We have to add these LIBS so that they are found.
 569        #:configure-flags (list "LIBS=-lz"
 570                                "X_EXTRA_LIBS=-lfontconfig"
 571                                "--with-x")
 572        #:tests? #f)) ; No make check.
 573     (native-inputs `(("intltool" ,intltool)))
 574     (inputs
 575      `(("alsa-lib" ,alsa-lib)
 576        ("sdl" ,sdl)
 577        ("sdl-image" ,sdl-image)
 578        ("sdl-mixer" ,sdl-mixer)
 579        ("sdl-net" ,sdl-net)
 580        ("sdl-ttf" ,sdl-ttf)
 581        ("lapack" ,lapack)
 582        ("libxft" ,libxft)
 583        ("fontconfig" ,fontconfig)
 584        ("gsl" ,gsl)
 585        ("openblas" ,openblas)
 586        ("glu" ,glu)
 587        ("mesa" ,mesa)
 588        ("mesa-utils" ,mesa-utils)
 589        ("binutils" ,binutils)
 590        ("libiberty" ,libiberty)
 591        ("readline" ,readline)
 592        ("zlib" ,zlib)
 593        ("gettext-minimal" ,gettext-minimal)))
 594     (synopsis "Lisp Universal Shell")
 595     (description
 596      "Lush is an object-oriented Lisp interpreter/compiler with features
 597 designed to please people who want to prototype large numerical
 598 applications.  Lush includes an extensive library of
 599 vector/matrix/tensor manipulation, numerous numerical libraries
 600 (including GSL, LAPACK, and BLAS), a set of graphic functions, a
 601 simple GUI toolkit, and interfaces to various graphic and multimedia
 602 libraries such as OpenGL, SDL, Video4Linux, and ALSA (video/audio
 603 grabbing), and others.  Lush is an ideal frontend script language for
 604 programming projects written in C or other languages.  Lush also has
 605 libraries for Machine Learning, Neural Nets and statistical estimation.")
 606     (home-page "http://lush.sourceforge.net/")
 607     (license license:lgpl2.1+)))
 608
 609 (define-public sbcl-alexandria
 610   (let ((revision "1")
 611         (commit "926a066611b7b11cb71e26c827a271e500888c30"))
 612     (package
 613       (name "sbcl-alexandria")
 614       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 615       (source
 616        (origin
 617          (method git-fetch)
 618          (uri (git-reference
 619                (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
 620                (commit commit)))
 621          (sha256
 622           (base32
 623            "18yncicdkh294j05rhgm23gzi36y9qy6vrfba8vg69jrxjp1hx8l"))
 624          (file-name (string-append "alexandria-" version "-checkout"))))
 625       (build-system asdf-build-system/sbcl)
 626       (synopsis "Collection of portable utilities for Common Lisp")
 627       (description
 628        "Alexandria is a collection of portable utilities.  It does not contain
 629 conceptual extensions to Common Lisp.  It is conservative in scope, and
 630 portable between implementations.")
 631       (home-page "https://common-lisp.net/project/alexandria/")
 632       (license license:public-domain))))
 633
 634 (define-public cl-alexandria
 635   (sbcl-package->cl-source-package sbcl-alexandria))
 636
 637 (define-public ecl-alexandria
 638   (sbcl-package->ecl-package sbcl-alexandria))
 639
 640 (define-public sbcl-fiveam
 641   (package
 642     (name "sbcl-fiveam")
 643     (version "1.2")
 644     (source
 645      (origin
 646        (method url-fetch)
 647        (uri (string-append
 648              "https://github.com/sionescu/fiveam/archive/v"
 649              version ".tar.gz"))
 650        (sha256
 651         (base32 "0f48pcbhqs3wwwzjl5nk57d4hcbib4l9xblxc66b8c2fhvhmhxnv"))
 652        (file-name (string-append "fiveam-" version ".tar.gz"))))
 653     (inputs `(("sbcl-alexandria" ,sbcl-alexandria)))
 654     (build-system asdf-build-system/sbcl)
 655     (synopsis "Common Lisp testing framework")
 656     (description "FiveAM is a simple (as far as writing and running tests
 657 goes) regression testing framework.  It has been designed with Common Lisp's
 658 interactive development model in mind.")
 659     (home-page "https://common-lisp.net/project/fiveam/")
 660     (license license:bsd-3)))
 661
 662 (define-public cl-fiveam
 663   (sbcl-package->cl-source-package sbcl-fiveam))
 664
 665 (define-public ecl-fiveam
 666   (sbcl-package->ecl-package sbcl-fiveam))
 667
 668 (define-public sbcl-bordeaux-threads
 669   (package
 670     (name "sbcl-bordeaux-threads")
 671     (version "0.8.5")
 672     (source (origin
 673               (method url-fetch)
 674               (uri (string-append
 675                     "https://github.com/sionescu/bordeaux-threads/archive/v"
 676                     version ".tar.gz"))
 677               (sha256
 678                (base32 "10ryrcx832fwqdawb6jmknymi7wpdzhi30qzx7cbrk0cpnka71w2"))
 679               (file-name
 680                (string-append "bordeaux-threads-" version ".tar.gz"))))
 681     (inputs `(("sbcl-alexandria" ,sbcl-alexandria)))
 682     (native-inputs `(("tests:cl-fiveam" ,sbcl-fiveam)))
 683     (build-system asdf-build-system/sbcl)
 684     (synopsis "Portable shared-state concurrency library for Common Lisp")
 685     (description "BORDEAUX-THREADS is a proposed standard for a minimal
 686 MP/Threading interface.  It is similar to the CLIM-SYS threading and lock
 687 support.")
 688     (home-page "https://common-lisp.net/project/bordeaux-threads/")
 689     (license license:x11)))
 690
 691 (define-public cl-bordeaux-threads
 692   (sbcl-package->cl-source-package sbcl-bordeaux-threads))
 693
 694 (define-public ecl-bordeaux-threads
 695   (sbcl-package->ecl-package sbcl-bordeaux-threads))
 696
 697 (define-public sbcl-trivial-gray-streams
 698   (let ((revision "1")
 699         (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
 700     (package
 701       (name "sbcl-trivial-gray-streams")
 702       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 703       (source
 704        (origin
 705          (method git-fetch)
 706          (uri
 707           (git-reference
 708            (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
 709            (commit commit)))
 710          (sha256
 711           (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
 712          (file-name
 713           (string-append "trivial-gray-streams-" version "-checkout"))))
 714       (build-system asdf-build-system/sbcl)
 715       (synopsis "Compatibility layer for Gray streams implementations")
 716       (description "Gray streams is an interface proposed for inclusion with
 717 ANSI CL by David N. Gray.  The proposal did not make it into ANSI CL, but most
 718 popular CL implementations implement it.  This package provides an extremely
 719 thin compatibility layer for gray streams.")
 720       (home-page "http://www.cliki.net/trivial-gray-streams")
 721       (license license:x11))))
 722
 723 (define-public cl-trivial-gray-streams
 724   (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
 725
 726 (define-public ecl-trivial-gray-streams
 727   (sbcl-package->ecl-package sbcl-trivial-gray-streams))
 728
 729 (define-public sbcl-flexi-streams
 730   (package
 731     (name "sbcl-flexi-streams")
 732     (version "1.0.12")
 733     (source
 734      (origin
 735        (method url-fetch)
 736        (uri (string-append
 737              "https://github.com/edicl/flexi-streams/archive/v"
 738              version ".tar.gz"))
 739        (sha256
 740         (base32 "16grnxvs7vqm5s6myf8a5s7vwblzq1kgwj8i7ahz8vwvihm9gzfi"))
 741        (file-name (string-append "flexi-streams-" version ".tar.gz"))))
 742     (build-system asdf-build-system/sbcl)
 743     (inputs `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
 744     (synopsis "Implementation of virtual bivalent streams for Common Lisp")
 745     (description "Flexi-streams is an implementation of \"virtual\" bivalent
 746 streams that can be layered atop real binary or bivalent streams and that can
 747 be used to read and write character data in various single- or multi-octet
 748 encodings which can be changed on the fly.  It also supplies in-memory binary
 749 streams which are similar to string streams.")
 750     (home-page "http://weitz.de/flexi-streams/")
 751     (license license:bsd-3)))
 752
 753 (define-public cl-flexi-streams
 754   (sbcl-package->cl-source-package sbcl-flexi-streams))
 755
 756 (define-public ecl-flexi-streams
 757   (sbcl-package->ecl-package sbcl-flexi-streams))
 758
 759 (define-public sbcl-cl-ppcre
 760   (package
 761     (name "sbcl-cl-ppcre")
 762     (version "2.0.11")
 763     (source
 764      (origin
 765        (method url-fetch)
 766        (uri (string-append
 767              "https://github.com/edicl/cl-ppcre/archive/v"
 768              version ".tar.gz"))
 769        (sha256
 770         (base32 "1i7daxf0wnydb0pgwiym7qh2wy70n14lxd6dyv28sy0naa8p31gd"))
 771        (file-name (string-append "cl-ppcre-" version ".tar.gz"))))
 772     (build-system asdf-build-system/sbcl)
 773     (native-inputs `(("tests:cl-flexi-streams" ,sbcl-flexi-streams)))
 774     (synopsis "Portable regular expression library for Common Lisp")
 775     (description "CL-PPCRE is a portable regular expression library for Common
 776 Lisp, which is compatible with perl.  It is pretty fast, thread-safe, and
 777 compatible with ANSI-compliant Common Lisp implementations.")
 778     (home-page "http://weitz.de/cl-ppcre/")
 779     (license license:bsd-2)))
 780
 781 (define-public cl-ppcre
 782   (sbcl-package->cl-source-package sbcl-cl-ppcre))
 783
 784 (define-public ecl-cl-ppcre
 785   (sbcl-package->ecl-package sbcl-cl-ppcre))
 786
 787 (define-public sbcl-clx
 788   (let ((revision "1")
 789         (commit "1c62774b03c1cf3fe6e5cb532df8b14b44c96b95"))
 790     (package
 791       (name "sbcl-clx")
 792       (version (string-append "0.0.0-" revision "." (string-take commit 7)))
 793       (source
 794        (origin
 795          (method git-fetch)
 796          (uri
 797           (git-reference
 798            (url "https://github.com/sharplispers/clx.git")
 799            (commit commit)))
 800          (sha256
 801           (base32 "0qffag03ns52kwq9xjns2qg1yr0bf3ba507iwq5cmx5xz0b0rmjm"))
 802          (file-name (string-append "clx-" version "-checkout"))
 803          (patches
 804           (list
 805            (search-patch "clx-remove-demo.patch")))
 806          (modules '((guix build utils)))
 807          (snippet
 808           '(begin
 809              ;; These removed files cause the compiled system to crash when
 810              ;; loading.
 811              (delete-file-recursively "demo")
 812              (delete-file "test/trapezoid.lisp")
 813              (substitute* "clx.asd"
 814                (("\\(:file \"trapezoid\"\\)") ""))))))
 815       (build-system asdf-build-system/sbcl)
 816       (arguments
 817        '(#:special-dependencies '("sb-bsd-sockets")))
 818       (home-page "http://www.cliki.net/portable-clx")
 819       (synopsis "X11 client library for Common Lisp")
 820       (description "CLX is an X11 client library for Common Lisp.  The code was
 821 originally taken from a CMUCL distribution, was modified somewhat in order to
 822 make it compile and run under SBCL, then a selection of patches were added
 823 from other CLXes around the net.")
 824       (license license:x11))))
 825
 826 (define-public cl-clx
 827   (sbcl-package->cl-source-package sbcl-clx))
 828
 829 (define-public ecl-clx
 830   (sbcl-package->ecl-package sbcl-clx))
 831
 832 (define-public sbcl-stumpwm
 833   (package
 834     (name "sbcl-stumpwm")
 835     (version "1.0.0")
 836     (source (origin
 837               (method url-fetch)
 838               (uri (string-append
 839                     "https://github.com/stumpwm/stumpwm/archive/"
 840                     version ".tar.gz"))
 841               (sha256
 842                (base32 "1maxp98gh64az3d9vz9br6zdd6rc9fmj2imvax4by85g6kxvdz1i"))
 843               (file-name (string-append "stumpwm-" version ".tar.gz"))))
 844     (build-system asdf-build-system/sbcl)
 845     (inputs `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
 846               ("sbcl-clx" ,sbcl-clx)))
 847     (outputs '("out" "bin"))
 848     (arguments
 849      '(#:special-dependencies '("sb-posix")
 850        #:phases
 851        (modify-phases %standard-phases
 852          (add-after 'create-symlinks 'build-program
 853            (lambda* (#:key lisp outputs inputs #:allow-other-keys)
 854              (build-program
 855               lisp
 856               (string-append (assoc-ref outputs "bin") "/bin/stumpwm")
 857               #:inputs inputs
 858               #:entry-program '((stumpwm:stumpwm) 0))))
 859          (add-after 'build-program 'create-desktop-file
 860            (lambda* (#:key outputs lisp binary? #:allow-other-keys)
 861              (let ((output (or (assoc-ref outputs "bin")
 862                                (assoc-ref outputs "out")))
 863                    (xsessions "/share/xsessions"))
 864                (mkdir-p (string-append output xsessions))
 865                (with-output-to-file
 866                    (string-append output xsessions
 867                                   "/stumpwm.desktop")
 868                  (lambda _
 869                    (format #t
 870                     "[Desktop Entry]~@
 871                      Name=stumpwm~@
 872                      Comment=The Stump Window Manager~@
 873                      Exec=~a/bin/stumpwm~@
 874                      TryExec=~@*~a/bin/stumpwm~@
 875                      Icon=~@
 876                      Type=Application~%"
 877                     output)))
 878                #t))))))
 879     (synopsis "Window manager written in Common Lisp")
 880     (description "Stumpwm is a window manager written entirely in Common Lisp.
 881 It attempts to be highly customizable while relying entirely on the keyboard
 882 for input.  These design decisions reflect the growing popularity of
 883 productive, customizable lisp based systems.")
 884     (home-page "http://github.com/stumpwm/stumpwm")
 885     (license license:gpl2+)
 886     (properties `((ecl-variant . ,(delay ecl-stumpwm))))))
 887
 888 (define-public cl-stumpwm
 889   (sbcl-package->cl-source-package sbcl-stumpwm))
 890
 891 (define-public ecl-stumpwm
 892   (let ((base (sbcl-package->ecl-package sbcl-stumpwm)))
 893     (package
 894       (inherit base)
 895       (outputs '("out"))
 896       (arguments '()))))
 897
 898 (define sbcl-slynk-boot0
 899   (let ((revision "1")
 900         (commit "5706cd45d484a4f25795abe8e643509d31968aa2"))
 901     (package
 902       (name "sbcl-slynk")
 903       (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
 904       (source
 905        (origin
 906          (method git-fetch)
 907          (uri
 908           (git-reference
 909            (url "https://github.com/joaotavora/sly.git")
 910            (commit commit)))
 911          (sha256
 912           (base32 "0h4gg3sndl2bf6jdnx9nrf14p9hhi43hagrl0f4v4l11hczl8w81"))
 913          (file-name (string-append "slynk-" version "-checkout"))
 914          (modules '((guix build utils)
 915                     (ice-9 ftw)))
 916          (snippet
 917           '(begin
 918              ;; Move the contribs into the main source directory for easier
 919              ;; access
 920              (substitute* "slynk/slynk.asd"
 921                (("\\.\\./contrib")
 922                 "contrib")
 923                (("\\(defsystem :slynk-util")
 924                 "(defsystem :slynk-util :depends-on (:slynk)"))
 925              (substitute* "contrib/slynk-trace-dialog.lisp"
 926                (("\\(slynk::reset-inspector\\)") ; Causes problems on load
 927                 "nil"))
 928              (substitute* "contrib/slynk-profiler.lisp"
 929                (("slynk:to-line")
 930                 "slynk-pprint-to-line"))
 931              (rename-file "contrib" "slynk/contrib")
 932              ;; Move slynk's contents into the base directory for easier
 933              ;; access
 934              (for-each
 935               (lambda (file)
 936                 (unless (string-prefix? "." file)
 937                   (rename-file (string-append "slynk/" file)
 938                                (string-append "./" (basename file)))))
 939               (scandir "slynk"))))))
 940       (build-system asdf-build-system/sbcl)
 941       (arguments
 942        `(#:tests? #f)) ; No test suite
 943       (synopsis "Common Lisp IDE for Emacs")
 944       (description "SLY is a fork of SLIME.  It also features a completely
 945 redesigned REPL based on Emacs's own full-featured comint.el, live code
 946 annotations, and a consistent interactive button interface.  Everything can be
 947 copied to the REPL.  One can create multiple inspectors with independent
 948 history.")
 949       (home-page "https://github.com/joaotavora/sly")
 950       (license license:public-domain)
 951       (properties `((cl-source-variant . ,(delay cl-slynk)))))))
 952
 953 (define-public cl-slynk
 954   (sbcl-package->cl-source-package sbcl-slynk-boot0))
 955
 956 (define ecl-slynk-boot0
 957   (sbcl-package->ecl-package sbcl-slynk-boot0))
 958
 959 (define sbcl-slynk-arglists
 960   (package
 961     (inherit sbcl-slynk-boot0)
 962     (name "sbcl-slynk-arglists")
 963     (inputs `(("sbcl-slynk" ,sbcl-slynk-boot0)))
 964     (arguments
 965      `(#:asd-file "slynk.asd"
 966        ,@(package-arguments sbcl-slynk-boot0)))))
 967
 968 (define ecl-slynk-arglists
 969   (sbcl-package->ecl-package sbcl-slynk-arglists))
 970
 971 (define sbcl-slynk-util
 972   (package
 973     (inherit sbcl-slynk-arglists)
 974     (name "sbcl-slynk-util")))
 975
 976 (define ecl-slynk-util
 977   (sbcl-package->ecl-package sbcl-slynk-util))
 978
 979 (define sbcl-slynk-fancy-inspector
 980   (package
 981     (inherit sbcl-slynk-arglists)
 982     (name "sbcl-slynk-fancy-inspector")
 983     (inputs `(("sbcl-slynk-util" ,sbcl-slynk-util)
 984               ,@(package-inputs sbcl-slynk-arglists)))))
 985
 986 (define ecl-slynk-fancy-inspector
 987   (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
 988
 989 (define sbcl-slynk-package-fu
 990   (package
 991     (inherit sbcl-slynk-arglists)
 992     (name "sbcl-slynk-package-fu")))
 993
 994 (define ecl-slynk-package-fu
 995   (sbcl-package->ecl-package sbcl-slynk-package-fu))
 996
 997 (define sbcl-slynk-mrepl
 998   (package
 999     (inherit sbcl-slynk-arglists)
1000     (name "sbcl-slynk-mrepl")))
1001
1002 (define ecl-slynk-mrepl
1003   (sbcl-package->ecl-package sbcl-slynk-mrepl))
1004
1005 (define sbcl-slynk-trace-dialog
1006   (package
1007     (inherit sbcl-slynk-arglists)
1008     (name "sbcl-slynk-trace-dialog")))
1009
1010 (define ecl-slynk-trace-dialog
1011   (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
1012
1013 (define sbcl-slynk-profiler
1014   (package
1015     (inherit sbcl-slynk-arglists)
1016     (name "sbcl-slynk-profiler")))
1017
1018 (define ecl-slynk-profiler
1019   (sbcl-package->ecl-package sbcl-slynk-profiler))
1020
1021 (define sbcl-slynk-stickers
1022   (package
1023     (inherit sbcl-slynk-arglists)
1024     (name "sbcl-slynk-stickers")))
1025
1026 (define ecl-slynk-stickers
1027   (sbcl-package->ecl-package sbcl-slynk-stickers))
1028
1029 (define sbcl-slynk-indentation
1030   (package
1031     (inherit sbcl-slynk-arglists)
1032     (name "sbcl-slynk-indentation")))
1033
1034 (define ecl-slynk-indentation
1035   (sbcl-package->ecl-package sbcl-slynk-indentation))
1036
1037 (define sbcl-slynk-retro
1038   (package
1039     (inherit sbcl-slynk-arglists)
1040     (name "sbcl-slynk-retro")))
1041
1042 (define ecl-slynk-retro
1043   (sbcl-package->ecl-package sbcl-slynk-retro))
1044
1045 (define slynk-systems
1046   '("slynk"
1047     "slynk-util"
1048     "slynk-arglists"
1049     "slynk-fancy-inspector"
1050     "slynk-package-fu"
1051     "slynk-mrepl"
1052     "slynk-profiler"
1053     "slynk-trace-dialog"
1054     "slynk-stickers"
1055     "slynk-indentation"
1056     "slynk-retro"))
1057
1058 (define-public sbcl-slynk
1059   (package
1060     (inherit sbcl-slynk-boot0)
1061     (inputs
1062      `(("slynk" ,sbcl-slynk-boot0)
1063        ("slynk-util" ,sbcl-slynk-util)
1064        ("slynk-arglists" ,sbcl-slynk-arglists)
1065        ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
1066        ("slynk-package-fu" ,sbcl-slynk-package-fu)
1067        ("slynk-mrepl" ,sbcl-slynk-mrepl)
1068        ("slynk-profiler" ,sbcl-slynk-profiler)
1069        ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
1070        ("slynk-stickers" ,sbcl-slynk-stickers)
1071        ("slynk-indentation" ,sbcl-slynk-indentation)
1072        ("slynk-retro" ,sbcl-slynk-retro)))
1073     (native-inputs `(("sbcl" ,sbcl)))
1074     (build-system trivial-build-system)
1075     (source #f)
1076     (outputs '("out" "image"))
1077     (arguments
1078      `(#:modules ((guix build union)
1079                   (guix build utils)
1080                   (guix build lisp-utils))
1081        #:builder
1082        (begin
1083          (use-modules (ice-9 match)
1084                       (srfi srfi-1)
1085                       (guix build union)
1086                       (guix build lisp-utils))
1087
1088          (union-build
1089           (assoc-ref %outputs "out")
1090           (filter-map
1091            (match-lambda
1092              ((name . path)
1093               (if (string-prefix? "slynk" name) path #f)))
1094            %build-inputs))
1095
1096          (prepend-to-source-registry
1097           (string-append (assoc-ref %outputs "out") "//"))
1098          (build-image "sbcl"
1099                       (string-append
1100                        (assoc-ref %outputs "image")
1101                        "/bin/slynk")
1102                       #:inputs %build-inputs
1103                       #:dependencies ',slynk-systems))))))
1104
1105 (define-public ecl-slynk
1106   (package
1107     (inherit sbcl-slynk)
1108     (name "ecl-slynk")
1109     (inputs
1110      (map (match-lambda
1111             ((name pkg . _)
1112              (list name (sbcl-package->ecl-package pkg))))
1113           (package-inputs sbcl-slynk)))
1114     (native-inputs '())
1115     (outputs '("out"))
1116     (arguments
1117      '(#:modules ((guix build union))
1118        #:builder
1119        (begin
1120          (use-modules (ice-9 match)
1121                       (guix build union))
1122          (match %build-inputs
1123            (((names . paths) ...)
1124             (union-build (assoc-ref %outputs "out")
1125                          paths))))))))
1126
1127 (define-public sbcl-stumpwm+slynk
1128   (package
1129     (inherit sbcl-stumpwm)
1130     (name "sbcl-stumpwm-with-slynk")
1131     (outputs '("out"))
1132     (native-inputs
1133      `(("stumpwm" ,sbcl-stumpwm)
1134        ("slynk" ,sbcl-slynk)))
1135     (arguments
1136      (substitute-keyword-arguments (package-arguments sbcl-stumpwm)
1137        ((#:phases phases)
1138         `(modify-phases ,phases
1139            (replace 'build-program
1140              (lambda* (#:key lisp inputs outputs #:allow-other-keys)
1141                (let* ((out (assoc-ref outputs "out"))
1142                       (program (string-append out "/bin/stumpwm")))
1143                  (build-program lisp program
1144                                 #:inputs inputs
1145                                 #:entry-program '((stumpwm:stumpwm) 0)
1146                                 #:dependencies '("stumpwm"
1147                                                  ,@slynk-systems))
1148                  ;; Remove unneeded file.
1149                  (delete-file (string-append out "/bin/stumpwm-exec.fasl"))
1150                  #t)))
1151            (delete 'copy-source)
1152            (delete 'build)
1153            (delete 'check)
1154            (delete 'link-dependencies)
1155            (delete 'cleanup)
1156            (delete 'create-symlinks)))))))