;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
-;;; Copyright © 2016 ng0 <ng0@we.make.ritual.n0.is>
+;;; Copyright © 2016, 2017 ng0 <contact.ng0@cryptolab.net>
+;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
+;;; Copyright © 2017 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2017 Efraim Flashner <efraim@flashner.co.il>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages m4)
#:use-module (guix download)
#:use-module (guix git-download)
+ #:use-module (guix hg-download)
#:use-module (guix utils)
#:use-module (guix build-system gnu)
+ #:use-module (guix build-system asdf)
+ #:use-module (guix build-system trivial)
#:use-module (gnu packages base)
+ #:use-module (gnu packages compression)
+ #:use-module (gnu packages fontutils)
+ #:use-module (gnu packages maths)
#:use-module (gnu packages multiprecision)
+ #:use-module (gnu packages ncurses)
#:use-module (gnu packages bdw-gc)
#:use-module (gnu packages libffi)
#:use-module (gnu packages libffcall)
#:use-module (gnu packages readline)
+ #:use-module (gnu packages sdl)
#:use-module (gnu packages libsigsegv)
+ #:use-module (gnu packages linux)
#:use-module (gnu packages admin)
#:use-module (gnu packages ed)
+ #:use-module (gnu packages gl)
+ #:use-module (gnu packages gcc)
+ #:use-module (gnu packages glib)
+ #:use-module (gnu packages gettext)
#:use-module (gnu packages m4)
+ #:use-module (gnu packages pkg-config)
#:use-module (gnu packages version-control)
- #:use-module (ice-9 match))
+ #:use-module (gnu packages xorg)
+ #:use-module (ice-9 match)
+ #:use-module (srfi srfi-1))
+
+(define (asdf-substitutions lisp)
+ ;; Prepend XDG_DATA_DIRS/LISP-bundle-systems to ASDF's
+ ;; 'default-system-source-registry'.
+ `((("\\(,dir \"systems/\"\\)\\)")
+ (format #f
+ "(,dir \"~a-bundle-systems\")))
+
+ ,@(loop :for dir :in (xdg-data-dirs \"common-lisp/\")
+ :collect `(:directory (,dir \"systems\"))"
+ ,lisp))))
(define-public gcl
(package
`(#:parallel-build? #f ; The build system seems not to be thread safe.
#:tests? #f ; There does not seem to be make check or anything similar.
#:configure-flags '("--enable-ansi") ; required for use by the maxima package
- #:phases (alist-cons-before
- 'configure 'pre-conf
- (lambda _
- ;; Patch bug when building readline support. This bug was
- ;; also observed by Debian
- ;; https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=741819
- (substitute* "o/gcl_readline.d"
- (("rl_attempted_completion_function = \
-\\(CPPFunction \\*\\)rl_completion;")
- "rl_attempted_completion_function = rl_completion;"))
- (substitute*
- (append
- '("pcl/impl/kcl/makefile.akcl"
- "add-defs"
- "unixport/makefile.dos"
- "add-defs.bat"
- "gcl-tk/makefile.prev"
- "add-defs1")
- (find-files "h" "\\.defs"))
- (("SHELL=/bin/(ba)?sh")
- (string-append "SHELL=" (which "bash")))))
- ;; drop strip phase to make maxima build, see
- ;; https://www.ma.utexas.edu/pipermail/maxima/2008/009769.html
- (alist-delete 'strip
- %standard-phases))))
+ #:make-flags (list
+ "CFLAGS=-fgnu89-inline" ; removes inline function warnings
+ (string-append "GCC=" (assoc-ref %build-inputs "gcc")
+ "/bin/gcc"))
+ #:phases (modify-phases %standard-phases
+ (add-before 'configure 'pre-conf
+ (lambda _
+ (substitute*
+ (append
+ '("pcl/impl/kcl/makefile.akcl"
+ "add-defs"
+ "unixport/makefile.dos"
+ "add-defs.bat"
+ "gcl-tk/makefile.prev"
+ "add-defs1")
+ (find-files "h" "\\.defs"))
+ (("SHELL=/bin/bash")
+ (string-append "SHELL=" (which "bash")))
+ (("SHELL=/bin/sh")
+ (string-append "SHELL=" (which "sh"))))
+ (substitute* "h/linux.defs"
+ (("#CC") "CC")
+ (("-fwritable-strings") "")
+ (("-Werror") ""))
+ #t))
+ (add-after 'install 'wrap
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((gcl (assoc-ref outputs "out"))
+ (input-path (lambda (lib path)
+ (string-append
+ (assoc-ref inputs lib) path)))
+ (binaries '("binutils")))
+ ;; GCC and the GNU binutils are necessary for GCL to be
+ ;; able to compile Lisp functions and programs (this is
+ ;; a standard feature in Common Lisp). While the
+ ;; the location of GCC is specified in the make-flags,
+ ;; the GNU binutils must be available in GCL's $PATH.
+ (wrap-program (string-append gcl "/bin/gcl")
+ `("PATH" prefix ,(map (lambda (binary)
+ (input-path binary "/bin"))
+ binaries))))
+ #t))
+ ;; drop strip phase to make maxima build, see
+ ;; https://www.ma.utexas.edu/pipermail/maxima/2008/009769.html
+ (delete 'strip))))
+ (inputs
+ `(("gmp" ,gmp)
+ ("readline" ,readline)))
(native-inputs
- `(("m4" ,m4)
- ("readline" ,readline)
+ `(("gcc" ,gcc-4.9)
+ ("m4" ,m4)
("texinfo" ,texinfo)
("texlive" ,texlive)))
- (home-page "http://www.gnu.org/software/gcl")
+ (home-page "https://www.gnu.org/software/gcl/")
(synopsis "A Common Lisp implementation")
(description "GCL is an implementation of the Common Lisp language. It
features the ability to compile to native object code and to load native
(define-public ecl
(package
(name "ecl")
- (version "16.1.2")
+ (version "16.1.3")
(source
(origin
(method url-fetch)
"https://common-lisp.net/project/ecl/static/files/release/"
name "-" version ".tgz"))
(sha256
- (base32 "16ab8qs3awvdxy8xs8jy82v8r04x4wr70l9l2j45vgag18d2nj1d"))))
+ (base32 "0m0j24w5d5a9dwwqyrg0d35c0nys16ijb4r0nyk87yp82v38b9bn"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Add ecl-bundle-systems to 'default-system-source-registry'.
+ `(substitute* "contrib/asdf/asdf.lisp"
+ ,@(asdf-substitutions name)))))
(build-system gnu-build-system)
;; src/configure uses 'which' to confirm the existence of 'gzip'.
(native-inputs `(("which" ,which)))
("libffi" ,libffi)))
(arguments
'(#:tests? #t
- #:make-flags `(,(string-append "ECL="
- (assoc-ref %outputs "out")
- "/bin/ecl"))
#:parallel-tests? #f
#:phases
(modify-phases %standard-phases
(delete 'check)
- (add-after 'install 'check (assoc-ref %standard-phases 'check)))))
+ (add-after 'install 'wrap
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((ecl (assoc-ref outputs "out"))
+ (input-path (lambda (lib path)
+ (string-append
+ (assoc-ref inputs lib) path)))
+ (libraries '("gmp" "libatomic-ops" "libgc" "libffi" "libc"))
+ (binaries '("gcc" "ld-wrapper" "binutils"))
+ (library-directories
+ (map (lambda (lib) (input-path lib "/lib"))
+ libraries)))
+
+ (wrap-program (string-append ecl "/bin/ecl")
+ `("PATH" prefix
+ ,(map (lambda (binary)
+ (input-path binary "/bin"))
+ binaries))
+ `("CPATH" suffix
+ ,(map (lambda (lib)
+ (input-path lib "/include"))
+ `("kernel-headers" ,@libraries)))
+ `("LIBRARY_PATH" suffix ,library-directories)
+ `("LD_LIBRARY_PATH" suffix ,library-directories)))))
+ (add-after 'wrap 'check (assoc-ref %standard-phases 'check))
+ (add-before 'check 'fix-path-to-ecl
+ (lambda _
+ (substitute* "build/tests/Makefile"
+ (("\\$\\{exec_prefix\\}/") ""))
+ #t)))))
+ (native-search-paths
+ (list (search-path-specification
+ (variable "XDG_DATA_DIRS")
+ (files '("share")))))
(home-page "http://ecls.sourceforge.net/")
(synopsis "Embeddable Common Lisp")
(description "ECL is an implementation of the Common Lisp language as
(define-public clisp
(package
(name "clisp")
- (version "2.49")
+ (version "2.49-60")
(source
(origin
- (method url-fetch)
- (uri (string-append "mirror://gnu/clisp/release/" version
- "/clisp-" version ".tar.gz"))
+ (method hg-fetch)
+ (uri (hg-reference
+ (url "http://hg.code.sf.net/p/clisp/clisp")
+ (changeset "clisp_2_49_60-2017-06-25")))
+ (file-name (string-append name "-" version "-checkout"))
(sha256
- (base32 "0rp82nqp5362isl9i34rwgg04cidz7izljd9d85pqcw1qr964bxx"))))
+ (base32 "0qjv3z274rbdmb941hy03hl63f4z7bmci234f8dyz4skgfr82d3i"))
+ (patches (search-patches "clisp-remove-failing-test.patch"))))
(build-system gnu-build-system)
(inputs `(("libffcall" ,libffcall)
+ ("ncurses" ,ncurses)
("readline" ,readline)
("libsigsegv" ,libsigsegv)))
(arguments
'(;; XXX The custom configure script does not cope well when passed
;; --build=<triplet>.
+ #:configure-flags '("CFLAGS=-falign-functions=4"
+ "--enable-portability"
+ "--with-dynamic-ffi"
+ "--with-dynamic-modules"
+ "--with-module=bindings/glibc"
+ "--with-module=rawsock")
#:build #f
#:phases
- (alist-cons-after
- 'unpack 'patch-sh-and-pwd
- (lambda _
- ;; The package is very messy with its references to "/bin/sh" and
- ;; some other absolute paths to traditional tools. These appear in
- ;; many places where our automatic patching misses them. Therefore
- ;; we do the following, in this early (post-unpack) phase, to solve
- ;; the problem from its root.
- (substitute* (find-files "." "configure|Makefile")
- (("/bin/sh") "sh"))
- (substitute* '("src/clisp-link.in")
- (("/bin/pwd") "pwd")))
- (alist-cons-before
- 'build 'chdir-to-source
- (lambda _
- ;; We are supposed to call make under the src sub-directory.
- (chdir "src"))
- %standard-phases))
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-sh-and-pwd
+ (lambda _
+ ;; The package is very messy with its references to "/bin/sh" and
+ ;; some other absolute paths to traditional tools. These appear in
+ ;; many places where our automatic patching misses them. Therefore
+ ;; we do the following, in this early (post-unpack) phase, to solve
+ ;; the problem from its root.
+ (substitute* (find-files "." "configure|Makefile")
+ (("/bin/sh") "sh"))
+ (substitute* '("src/clisp-link.in")
+ (("/bin/pwd") "pwd"))
+ #t))
+ (add-after 'unpack 'remove-timestamps
+ (lambda _
+ (substitute* "src/constobj.d"
+ (("__DATE__ __TIME__") "\"1\""))
+ (substitute* "src/genclisph.d"
+ (("__DATE__") "\"1\"")
+ (("__TIME__") "\"1\""))
+ #t)))
;; Makefiles seem to have race conditions.
#:parallel-build? #f))
(home-page "http://www.clisp.org/")
(define-public sbcl
(package
(name "sbcl")
- (version "1.2.8")
+ (version "1.3.7")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://sourceforge/sbcl/sbcl/" version "/sbcl-"
version "-source.tar.bz2"))
(sha256
- (base32 "0ab9lw056yf6y0rjmx3iirn5n59pmssqxf00fbmpyl6qsnpaja1d"))))
+ (base32 "0fjdqnb2rsm2vi9794ywp27jr239ddvzc4xfr0dk49jd4v7p2kc5"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Add sbcl-bundle-systems to 'default-system-source-registry'.
+ `(substitute* "contrib/asdf/asdf.lisp"
+ ,@(asdf-substitutions name)))))
(build-system gnu-build-system)
(outputs '("out" "doc"))
;; Bootstrap with CLISP.
("texlive" ,texlive)
("texinfo" ,texinfo)))
(arguments
- '(#:phases
+ '(#:modules ((guix build gnu-build-system)
+ (guix build utils)
+ (srfi srfi-1))
+ #:phases
(modify-phases %standard-phases
(delete 'configure)
(add-before 'build 'patch-unix-tool-paths
;; occurs in some .sh files too (which contain Lisp code). Use
;; ISO-8859-1 because some of the files are ISO-8859-1 encoded.
(with-fluids ((%default-port-encoding #f))
- (substitute* (find-files "." "\\.(lisp|sh)$")
+ ;; The removed file is utf-16-be encoded, which gives substitute*
+ ;; trouble. It does not contain references to the listed programs.
+ (substitute* (delete
+ "./tests/data/compile-file-pos-utf16be.lisp"
+ (find-files "." "\\.(lisp|sh)$"))
(("\"/bin/sh\"") (quoted-path bash "/bin/sh"))
(("\"/usr/bin/env\"") (quoted-path coreutils "/usr/bin/env"))
(("\"/bin/cat\"") (quoted-path coreutils "/bin/cat"))
#t))))
;; No 'check' target, though "make.sh" (build phase) runs tests.
#:tests? #f))
+ (native-search-paths
+ (list (search-path-specification
+ (variable "XDG_DATA_DIRS")
+ (files '("share")))))
(home-page "http://www.sbcl.org/")
(synopsis "Common Lisp implementation")
(description "Steel Bank Common Lisp (SBCL) is a high performance Common
(define-public ccl
(package
(name "ccl")
- (version "1.10")
+ (version "1.11")
(source #f)
(build-system gnu-build-system)
;; CCL consists of a "lisp kernel" and "heap image", both of which are
,(origin
(method url-fetch)
(uri (string-append
- "ftp://ftp.clozure.com/pub/release/1.10/ccl-" version "-"
+ "ftp://ftp.clozure.com/pub/release/" version
+ "/ccl-" version "-"
(match (%current-system)
((or "i686-linux" "x86_64-linux") "linuxx86")
("armhf-linux" "linuxarm")
(base32
(match (%current-system)
((or "i686-linux" "x86_64-linux")
- "0mr653q5px05lr11z2mk551m5g47b4wq96vbfibpp0qlc9jp58lc")
+ "0w3dmj7q9kqyra3yrf1lxclnjz151yvf5s5q8ayllvmvqbl8bs08")
("armhf-linux"
- "1py02irpmi2qz5rq3h33wfv6impf15z8i2rign6hvhlqn7s99wwh")
+ "1x487aaz2rqcb6k301sy2p39a1m4qdhg6z9p9fb76ssipqgr38b4")
(_ ""))))))))
(native-inputs
`(("m4" ,m4)
("subversion" ,subversion)))
(arguments
`(#:tests? #f ;no 'check' target
+ #:modules ((srfi srfi-26)
+ (guix build utils)
+ (guix build gnu-build-system))
#:phases
(alist-replace
'unpack
;; "guix package --search="
(_ "UNSUPPORTED")))
(heap (string-append kernel ".image")))
- (mkdir-p libdir)
+ (install-file kernel libdir)
+ (install-file heap libdir)
+
+ (let ((dirs '("lib" "library" "examples" "contrib"
+ "tools" "objc-bridge")))
+ (for-each copy-recursively
+ dirs
+ (map (cut string-append libdir <>) dirs)))
+
(mkdir-p bindir)
- (copy-file kernel (string-append libdir kernel))
- (copy-file heap (string-append libdir heap))
(with-output-to-file wrapper
(lambda ()
(display
(string-append
"#!" bash "/bin/sh\n"
- "if [ -z \"$CCL_DEFAULT_DIRECTORY\" ]; then\n"
- " CCL_DEFAULT_DIRECTORY=" libdir "\n"
- "fi\n"
+ "CCL_DEFAULT_DIRECTORY=" libdir "\n"
"export CCL_DEFAULT_DIRECTORY\n"
"exec " libdir kernel "\n"))))
(chmod wrapper #o755)))
(license (list license:lgpl2.1
license:clarified-artistic)))) ;TRIVIAL-LDAP package
-(define-public lispf4
- (let ((commit "174d8764d2f9764e8f4794c2e3feada9f9c1f1ba"))
+(define-public femtolisp
+ (let ((commit "68c5b1225572ecf2c52baf62f928063e5a30511b")
+ (revision "1"))
(package
- (name "lispf4")
- (version (string-append "0.0.0-1" "-"
- (string-take commit 7)))
+ (name "femtolisp")
+ (version (string-append "0.0.0-" revision "." (string-take commit 7)))
(source (origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/blakemcbride/LISPF4.git")
+ (url "https://github.com/JeffBezanson/femtolisp.git")
(commit commit)))
- (file-name (string-append name "-" version))
+ (file-name (string-append name "-" version "-checkout"))
(sha256
(base32
- "18k8kfn30za637y4bfbm9x3vv4psa3q8f7bi9h4h0qlb8rz8m92c"))))
+ "04rnwllxnl86zw8c6pwxznn49bvkvh0f1lfliy085vjzvlq3rgja"))))
+ ;; See "utils.h" for supported systems. Upstream bug:
+ ;; https://github.com/JeffBezanson/femtolisp/issues/25
+ (supported-systems
+ (fold delete %supported-systems
+ '("armhf-linux" "mips64el-linux" "aarch64-linux")))
(build-system gnu-build-system)
- ;; 80 MB appended Documentation -> output:doc
- (outputs '("out" "doc"))
(arguments
- `(#:make-flags
- '("-f" "Makefile.unx" "CC=gcc")
- ;; no check phase
- #:tests? #f
+ `(#:make-flags '("CC=gcc" "release")
+ #:test-target "test"
#:phases
(modify-phases %standard-phases
- (delete 'configure)
- (replace
- 'install
- (lambda* (#:key outputs inputs #:allow-other-keys)
+ (delete 'configure) ; No configure script
+ (replace 'install ; Makefile has no 'install phase
+ (lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
- (bin (string-append out "/bin"))
- (doc (string-append (assoc-ref outputs "doc")
- "/share/doc/lispf4")))
- (install-file "lispf4" bin)
- (install-file "SYSATOMS" bin)
- (install-file "BASIC.IMG" bin)
- (copy-recursively "Documentation" doc))
- #t)))))
- (synopsis "InterLisp interpreter")
+ (bin (string-append out "/bin")))
+ (install-file "flisp" bin)
+ #t)))
+ ;; The flisp binary is now available, run bootstrap to
+ ;; generate flisp.boot and afterwards runs make test.
+ (add-after 'install 'bootstrap-gen-and-test
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (bin (string-append out "/bin")))
+ (and
+ (zero? (system* "./bootstrap.sh"))
+ (install-file "flisp.boot" bin))))))))
+ (synopsis "Scheme-like lisp implementation")
(description
- "LISPF4 is an InterLisp interpreter written in FORTRAN by Mats Nordstrom
-in the early 80's. It was converted to C by Blake McBride and supports much of
-the InterLisp Standard.")
- (home-page "https://github.com/blakemcbride/LISPF4.git")
- (license license:expat))))
+ "@code{femtolisp} is a scheme-like lisp implementation with a
+simple, elegant Scheme dialect. It is a lisp-1 with lexical scope.
+The core is 12 builtin special forms and 33 builtin functions.")
+ (home-page "https://github.com/JeffBezanson/femtolisp")
+ (license license:bsd-3))))
+
+(define-public lush2
+ (package
+ (name "lush2")
+ (version "2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "mirror://sourceforge/lush/lush2/lush-"
+ version ".tar.gz"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ (substitute* "src/unix.c"
+ (("\\{ \"LUSH_DATE\", __DATE__ \\},") "")
+ (("\\{ \"LUSH_TIME\", __TIME__ \\},") ""))
+ (substitute* "src/main.c"
+ (("\" \\(built \" __DATE__ \"\\)\"") ""))))
+ (sha256
+ (base32
+ "02pkfn3nqdkm9fm44911dbcz0v3r0l53vygj8xigl6id5g3iwi4k"))))
+ (build-system gnu-build-system)
+ (arguments
+ `(;; We have to add these LIBS so that they are found.
+ #:configure-flags (list "LIBS=-lz"
+ "X_EXTRA_LIBS=-lfontconfig"
+ "--with-x")
+ #:tests? #f)) ; No make check.
+ (native-inputs `(("intltool" ,intltool)))
+ (inputs
+ `(("alsa-lib" ,alsa-lib)
+ ("sdl" ,sdl)
+ ("sdl-image" ,sdl-image)
+ ("sdl-mixer" ,sdl-mixer)
+ ("sdl-net" ,sdl-net)
+ ("sdl-ttf" ,sdl-ttf)
+ ("lapack" ,lapack)
+ ("libxft" ,libxft)
+ ("fontconfig" ,fontconfig)
+ ("gsl" ,gsl)
+ ("openblas" ,openblas)
+ ("glu" ,glu)
+ ("mesa" ,mesa)
+ ("mesa-utils" ,mesa-utils)
+ ("binutils" ,binutils)
+ ("libiberty" ,libiberty)
+ ("readline" ,readline)
+ ("zlib" ,zlib)
+ ("gettext-minimal" ,gettext-minimal)))
+ (synopsis "Lisp Universal Shell")
+ (description
+ "Lush is an object-oriented Lisp interpreter/compiler with features
+designed to please people who want to prototype large numerical
+applications. Lush includes an extensive library of
+vector/matrix/tensor manipulation, numerous numerical libraries
+(including GSL, LAPACK, and BLAS), a set of graphic functions, a
+simple GUI toolkit, and interfaces to various graphic and multimedia
+libraries such as OpenGL, SDL, Video4Linux, and ALSA (video/audio
+grabbing), and others. Lush is an ideal frontend script language for
+programming projects written in C or other languages. Lush also has
+libraries for Machine Learning, Neural Nets and statistical estimation.")
+ (home-page "http://lush.sourceforge.net/")
+ (license license:lgpl2.1+)))
+
+(define-public sbcl-alexandria
+ (let ((revision "1")
+ (commit "926a066611b7b11cb71e26c827a271e500888c30"))
+ (package
+ (name "sbcl-alexandria")
+ (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
+ (commit commit)))
+ (sha256
+ (base32
+ "18yncicdkh294j05rhgm23gzi36y9qy6vrfba8vg69jrxjp1hx8l"))
+ (file-name (string-append "alexandria-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Collection of portable utilities for Common Lisp")
+ (description
+ "Alexandria is a collection of portable utilities. It does not contain
+conceptual extensions to Common Lisp. It is conservative in scope, and
+portable between implementations.")
+ (home-page "https://common-lisp.net/project/alexandria/")
+ (license license:public-domain))))
+
+(define-public cl-alexandria
+ (sbcl-package->cl-source-package sbcl-alexandria))
+
+(define-public ecl-alexandria
+ (sbcl-package->ecl-package sbcl-alexandria))
+
+(define-public sbcl-fiveam
+ (package
+ (name "sbcl-fiveam")
+ (version "1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://github.com/sionescu/fiveam/archive/v"
+ version ".tar.gz"))
+ (sha256
+ (base32 "0f48pcbhqs3wwwzjl5nk57d4hcbib4l9xblxc66b8c2fhvhmhxnv"))
+ (file-name (string-append "fiveam-" version ".tar.gz"))))
+ (inputs `(("alexandria" ,sbcl-alexandria)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp testing framework")
+ (description "FiveAM is a simple (as far as writing and running tests
+goes) regression testing framework. It has been designed with Common Lisp's
+interactive development model in mind.")
+ (home-page "https://common-lisp.net/project/fiveam/")
+ (license license:bsd-3)))
+
+(define-public cl-fiveam
+ (sbcl-package->cl-source-package sbcl-fiveam))
+
+(define-public ecl-fiveam
+ (sbcl-package->ecl-package sbcl-fiveam))
+
+(define-public sbcl-bordeaux-threads
+ (package
+ (name "sbcl-bordeaux-threads")
+ (version "0.8.5")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://github.com/sionescu/bordeaux-threads/archive/v"
+ version ".tar.gz"))
+ (sha256
+ (base32 "10ryrcx832fwqdawb6jmknymi7wpdzhi30qzx7cbrk0cpnka71w2"))
+ (file-name
+ (string-append "bordeaux-threads-" version ".tar.gz"))))
+ (inputs `(("alexandria" ,sbcl-alexandria)))
+ (native-inputs `(("fiveam" ,sbcl-fiveam)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Portable shared-state concurrency library for Common Lisp")
+ (description "BORDEAUX-THREADS is a proposed standard for a minimal
+MP/Threading interface. It is similar to the CLIM-SYS threading and lock
+support.")
+ (home-page "https://common-lisp.net/project/bordeaux-threads/")
+ (license license:x11)))
+
+(define-public cl-bordeaux-threads
+ (sbcl-package->cl-source-package sbcl-bordeaux-threads))
+
+(define-public ecl-bordeaux-threads
+ (sbcl-package->ecl-package sbcl-bordeaux-threads))
+
+(define-public sbcl-trivial-gray-streams
+ (let ((revision "1")
+ (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
+ (package
+ (name "sbcl-trivial-gray-streams")
+ (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
+ (commit commit)))
+ (sha256
+ (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
+ (file-name
+ (string-append "trivial-gray-streams-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Compatibility layer for Gray streams implementations")
+ (description "Gray streams is an interface proposed for inclusion with
+ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most
+popular CL implementations implement it. This package provides an extremely
+thin compatibility layer for gray streams.")
+ (home-page "http://www.cliki.net/trivial-gray-streams")
+ (license license:x11))))
+
+(define-public cl-trivial-gray-streams
+ (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
+
+(define-public ecl-trivial-gray-streams
+ (sbcl-package->ecl-package sbcl-trivial-gray-streams))
+
+(define-public sbcl-flexi-streams
+ (package
+ (name "sbcl-flexi-streams")
+ (version "1.0.12")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://github.com/edicl/flexi-streams/archive/v"
+ version ".tar.gz"))
+ (sha256
+ (base32 "16grnxvs7vqm5s6myf8a5s7vwblzq1kgwj8i7ahz8vwvihm9gzfi"))
+ (file-name (string-append "flexi-streams-" version ".tar.gz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Implementation of virtual bivalent streams for Common Lisp")
+ (description "Flexi-streams is an implementation of \"virtual\" bivalent
+streams that can be layered atop real binary or bivalent streams and that can
+be used to read and write character data in various single- or multi-octet
+encodings which can be changed on the fly. It also supplies in-memory binary
+streams which are similar to string streams.")
+ (home-page "http://weitz.de/flexi-streams/")
+ (license license:bsd-3)))
+
+(define-public cl-flexi-streams
+ (sbcl-package->cl-source-package sbcl-flexi-streams))
+
+(define-public ecl-flexi-streams
+ (sbcl-package->ecl-package sbcl-flexi-streams))
+
+(define-public sbcl-cl-ppcre
+ (package
+ (name "sbcl-cl-ppcre")
+ (version "2.0.11")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://github.com/edicl/cl-ppcre/archive/v"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1i7daxf0wnydb0pgwiym7qh2wy70n14lxd6dyv28sy0naa8p31gd"))
+ (file-name (string-append "cl-ppcre-" version ".tar.gz"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
+ (synopsis "Portable regular expression library for Common Lisp")
+ (description "CL-PPCRE is a portable regular expression library for Common
+Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
+compatible with ANSI-compliant Common Lisp implementations.")
+ (home-page "http://weitz.de/cl-ppcre/")
+ (license license:bsd-2)))
+
+(define-public cl-ppcre
+ (sbcl-package->cl-source-package sbcl-cl-ppcre))
+
+(define-public ecl-cl-ppcre
+ (sbcl-package->ecl-package sbcl-cl-ppcre))
+
+(define sbcl-cl-unicode-base
+ (let ((revision "1")
+ (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea"))
+ (package
+ (name "sbcl-cl-unicode-base")
+ (version (string-append "0.1.5-" revision "." (string-take commit 7)))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-unicode.git")
+ (commit commit)))
+ (file-name (string-append "cl-unicode-" version "-checkout"))
+ (sha256
+ (base32
+ "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-unicode.asd"
+ #:asd-system-name "cl-unicode/base"))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)))
+ (home-page "http://weitz.de/cl-unicode/")
+ (synopsis "Portable Unicode library for Common Lisp")
+ (description "CL-UNICODE is a portable Unicode library Common Lisp, which
+is compatible with perl. It is pretty fast, thread-safe, and compatible with
+ANSI-compliant Common Lisp implementations.")
+ (license license:bsd-2))))
+
+(define-public sbcl-cl-unicode
+ (package
+ (inherit sbcl-cl-unicode-base)
+ (name "sbcl-cl-unicode")
+ (inputs
+ `(("cl-unicode/base" ,sbcl-cl-unicode-base)
+ ,@(package-inputs sbcl-cl-unicode-base)))
+ (native-inputs
+ `(("flexi-streams" ,sbcl-flexi-streams)))
+ (arguments '())))
+
+(define-public ecl-cl-unicode
+ (sbcl-package->ecl-package sbcl-cl-unicode))
+
+(define-public cl-unicode
+ (sbcl-package->cl-source-package sbcl-cl-unicode))
+
+(define-public sbcl-clx
+ (let ((revision "1")
+ (commit "1c62774b03c1cf3fe6e5cb532df8b14b44c96b95"))
+ (package
+ (name "sbcl-clx")
+ (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/sharplispers/clx.git")
+ (commit commit)))
+ (sha256
+ (base32 "0qffag03ns52kwq9xjns2qg1yr0bf3ba507iwq5cmx5xz0b0rmjm"))
+ (file-name (string-append "clx-" version "-checkout"))
+ (patches
+ (list
+ (search-patch "clx-remove-demo.patch")))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; These removed files cause the compiled system to crash when
+ ;; loading.
+ (delete-file-recursively "demo")
+ (delete-file "test/trapezoid.lisp")
+ (substitute* "clx.asd"
+ (("\\(:file \"trapezoid\"\\)") ""))))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://www.cliki.net/portable-clx")
+ (synopsis "X11 client library for Common Lisp")
+ (description "CLX is an X11 client library for Common Lisp. The code was
+originally taken from a CMUCL distribution, was modified somewhat in order to
+make it compile and run under SBCL, then a selection of patches were added
+from other CLXes around the net.")
+ (license license:x11))))
+
+(define-public cl-clx
+ (sbcl-package->cl-source-package sbcl-clx))
+
+(define-public ecl-clx
+ (sbcl-package->ecl-package sbcl-clx))
+
+(define-public sbcl-cl-ppcre-unicode
+ (package (inherit sbcl-cl-ppcre)
+ (name "sbcl-cl-ppcre-unicode")
+ (arguments
+ `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
+ #:asd-file "cl-ppcre-unicode.asd"))
+ (inputs
+ `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
+
+(define-public sbcl-stumpwm
+ (package
+ (name "sbcl-stumpwm")
+ (version "1.0.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://github.com/stumpwm/stumpwm/archive/"
+ version ".tar.gz"))
+ (sha256
+ (base32 "1maxp98gh64az3d9vz9br6zdd6rc9fmj2imvax4by85g6kxvdz1i"))
+ (file-name (string-append "stumpwm-" version ".tar.gz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("clx" ,sbcl-clx)))
+ (outputs '("out" "lib"))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'create-symlinks 'build-program
+ (lambda* (#:key outputs #:allow-other-keys)
+ (build-program
+ (string-append (assoc-ref outputs "out") "/bin/stumpwm")
+ outputs
+ #:entry-program '((stumpwm:stumpwm) 0))))
+ (add-after 'build-program 'create-desktop-file
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (xsessions (string-append out "/share/xsessions")))
+ (mkdir-p xsessions)
+ (call-with-output-file
+ (string-append xsessions "/stumpwm.desktop")
+ (lambda (file)
+ (format file
+ "[Desktop Entry]~@
+ Name=stumpwm~@
+ Comment=The Stump Window Manager~@
+ Exec=~a/bin/stumpwm~@
+ TryExec=~@*~a/bin/stumpwm~@
+ Icon=~@
+ Type=Application~%"
+ out)))
+ #t))))))
+ (synopsis "Window manager written in Common Lisp")
+ (description "Stumpwm is a window manager written entirely in Common Lisp.
+It attempts to be highly customizable while relying entirely on the keyboard
+for input. These design decisions reflect the growing popularity of
+productive, customizable lisp based systems.")
+ (home-page "https://github.com/stumpwm/stumpwm")
+ (license license:gpl2+)
+ (properties `((ecl-variant . ,(delay ecl-stumpwm))))))
+
+(define-public cl-stumpwm
+ (sbcl-package->cl-source-package sbcl-stumpwm))
+
+(define-public ecl-stumpwm
+ (let ((base (sbcl-package->ecl-package sbcl-stumpwm)))
+ (package
+ (inherit base)
+ (outputs '("out"))
+ (arguments '()))))
+
+;; The slynk that users expect to install includes all of slynk's contrib
+;; modules. Therefore, we build the base module and all contribs first; then
+;; we expose the union of these as `sbcl-slynk'. The following variable
+;; describes the base module.
+(define sbcl-slynk-boot0
+ (let ((revision "1")
+ (commit "5706cd45d484a4f25795abe8e643509d31968aa2"))
+ (package
+ (name "sbcl-slynk-boot0")
+ (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/joaotavora/sly.git")
+ (commit commit)))
+ (sha256
+ (base32 "0h4gg3sndl2bf6jdnx9nrf14p9hhi43hagrl0f4v4l11hczl8w81"))
+ (file-name (string-append "slynk-" version "-checkout"))
+ (modules '((guix build utils)
+ (ice-9 ftw)))
+ (snippet
+ '(begin
+ ;; Move the contribs into the main source directory for easier
+ ;; access
+ (substitute* "slynk/slynk.asd"
+ (("\\.\\./contrib")
+ "contrib")
+ (("\\(defsystem :slynk-util")
+ "(defsystem :slynk-util :depends-on (:slynk)"))
+ (substitute* "contrib/slynk-trace-dialog.lisp"
+ (("\\(slynk::reset-inspector\\)") ; Causes problems on load
+ "nil"))
+ (substitute* "contrib/slynk-profiler.lisp"
+ (("slynk:to-line")
+ "slynk-pprint-to-line"))
+ (rename-file "contrib" "slynk/contrib")
+ ;; Move slynk's contents into the base directory for easier
+ ;; access
+ (for-each
+ (lambda (file)
+ (unless (string-prefix? "." file)
+ (rename-file (string-append "slynk/" file)
+ (string-append "./" (basename file)))))
+ (scandir "slynk"))))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f ; No test suite
+ #:asd-system-name "slynk"))
+ (synopsis "Common Lisp IDE for Emacs")
+ (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
+It also features a completely redesigned REPL based on Emacs's own
+full-featured comint.el, live code annotations, and a consistent interactive
+button interface. Everything can be copied to the REPL. One can create
+multiple inspectors with independent history.")
+ (home-page "https://github.com/joaotavora/sly")
+ (license license:public-domain)
+ (properties `((cl-source-variant . ,(delay cl-slynk)))))))
+
+(define-public cl-slynk
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
+ (name "cl-slynk")))
+
+(define ecl-slynk-boot0
+ (sbcl-package->ecl-package sbcl-slynk-boot0))
+
+(define sbcl-slynk-arglists
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk-arglists")
+ (inputs `(("slynk" ,sbcl-slynk-boot0)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
+ ((#:asd-file _ "") "slynk.asd")
+ ((#:asd-system-name _ #f) #f)))))
+
+(define ecl-slynk-arglists
+ (sbcl-package->ecl-package sbcl-slynk-arglists))
+
+(define sbcl-slynk-util
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-util")))
+
+(define ecl-slynk-util
+ (sbcl-package->ecl-package sbcl-slynk-util))
+
+(define sbcl-slynk-fancy-inspector
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-fancy-inspector")
+ (inputs `(("slynk-util" ,sbcl-slynk-util)
+ ,@(package-inputs sbcl-slynk-arglists)))))
+
+(define ecl-slynk-fancy-inspector
+ (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
+
+(define sbcl-slynk-package-fu
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-package-fu")))
+
+(define ecl-slynk-package-fu
+ (sbcl-package->ecl-package sbcl-slynk-package-fu))
+
+(define sbcl-slynk-mrepl
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-mrepl")))
+
+(define ecl-slynk-mrepl
+ (sbcl-package->ecl-package sbcl-slynk-mrepl))
+
+(define sbcl-slynk-trace-dialog
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-trace-dialog")))
+
+(define ecl-slynk-trace-dialog
+ (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
+
+(define sbcl-slynk-profiler
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-profiler")))
+
+(define ecl-slynk-profiler
+ (sbcl-package->ecl-package sbcl-slynk-profiler))
+
+(define sbcl-slynk-stickers
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-stickers")))
+
+(define ecl-slynk-stickers
+ (sbcl-package->ecl-package sbcl-slynk-stickers))
+
+(define sbcl-slynk-indentation
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-indentation")))
+
+(define ecl-slynk-indentation
+ (sbcl-package->ecl-package sbcl-slynk-indentation))
+
+(define sbcl-slynk-retro
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-retro")))
+
+(define ecl-slynk-retro
+ (sbcl-package->ecl-package sbcl-slynk-retro))
+
+(define slynk-systems
+ '("slynk"
+ "slynk-util"
+ "slynk-arglists"
+ "slynk-fancy-inspector"
+ "slynk-package-fu"
+ "slynk-mrepl"
+ "slynk-profiler"
+ "slynk-trace-dialog"
+ "slynk-stickers"
+ "slynk-indentation"
+ "slynk-retro"))
+
+(define-public sbcl-slynk
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk")
+ (inputs
+ `(("slynk" ,sbcl-slynk-boot0)
+ ("slynk-util" ,sbcl-slynk-util)
+ ("slynk-arglists" ,sbcl-slynk-arglists)
+ ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
+ ("slynk-package-fu" ,sbcl-slynk-package-fu)
+ ("slynk-mrepl" ,sbcl-slynk-mrepl)
+ ("slynk-profiler" ,sbcl-slynk-profiler)
+ ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
+ ("slynk-stickers" ,sbcl-slynk-stickers)
+ ("slynk-indentation" ,sbcl-slynk-indentation)
+ ("slynk-retro" ,sbcl-slynk-retro)))
+ (native-inputs `(("sbcl" ,sbcl)))
+ (build-system trivial-build-system)
+ (source #f)
+ (outputs '("out" "image"))
+ (arguments
+ `(#:modules ((guix build union)
+ (guix build utils)
+ (guix build lisp-utils))
+ #:builder
+ (begin
+ (use-modules (ice-9 match)
+ (srfi srfi-1)
+ (guix build union)
+ (guix build lisp-utils))
+
+ (union-build
+ (assoc-ref %outputs "out")
+ (filter-map
+ (match-lambda
+ ((name . path)
+ (if (string-prefix? "slynk" name) path #f)))
+ %build-inputs))
+
+ (prepend-to-source-registry
+ (string-append (assoc-ref %outputs "out") "//"))
+
+ (parameterize ((%lisp-type "sbcl")
+ (%lisp (string-append (assoc-ref %build-inputs "sbcl")
+ "/bin/sbcl")))
+ (build-image (string-append
+ (assoc-ref %outputs "image")
+ "/bin/slynk")
+ %outputs
+ #:dependencies ',slynk-systems)))))))
+
+(define-public ecl-slynk
+ (package
+ (inherit sbcl-slynk)
+ (name "ecl-slynk")
+ (inputs
+ (map (match-lambda
+ ((name pkg . _)
+ (list name (sbcl-package->ecl-package pkg))))
+ (package-inputs sbcl-slynk)))
+ (native-inputs '())
+ (outputs '("out"))
+ (arguments
+ '(#:modules ((guix build union))
+ #:builder
+ (begin
+ (use-modules (ice-9 match)
+ (guix build union))
+ (match %build-inputs
+ (((names . paths) ...)
+ (union-build (assoc-ref %outputs "out")
+ paths))))))))
+
+(define-public sbcl-stumpwm+slynk
+ (package
+ (inherit sbcl-stumpwm)
+ (name "sbcl-stumpwm-with-slynk")
+ (outputs '("out"))
+ (inputs
+ `(("stumpwm" ,sbcl-stumpwm "lib")
+ ("slynk" ,sbcl-slynk)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-stumpwm)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (replace 'build-program
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (program (string-append out "/bin/stumpwm")))
+ (build-program program outputs
+ #:entry-program '((stumpwm:stumpwm) 0)
+ #:dependencies '("stumpwm"
+ ,@slynk-systems)
+ #:dependency-prefixes
+ (map (lambda (input) (assoc-ref inputs input))
+ '("stumpwm" "slynk")))
+ ;; Remove unneeded file.
+ (delete-file (string-append out "/bin/stumpwm-exec.fasl"))
+ #t)))
+ (delete 'copy-source)
+ (delete 'build)
+ (delete 'check)
+ (delete 'create-asd-file)
+ (delete 'cleanup)
+ (delete 'create-symlinks)))))))
+
+(define-public sbcl-parse-js
+ (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
+ (revision "1"))
+ (package
+ (name "sbcl-parse-js")
+ (version (string-append "0.0.0-" revision "." (string-take commit 9)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://marijn.haverbeke.nl/git/parse-js")
+ (commit commit)))
+ (file-name (string-append name "-" commit "-checkout"))
+ (sha256
+ (base32
+ "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://marijnhaverbeke.nl/parse-js/")
+ (synopsis "Parse JavaScript")
+ (description "Parse-js is a Common Lisp package for parsing
+JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
+ (license license:zlib))))
+
+(define-public sbcl-parse-number
+ (package
+ (name "sbcl-parse-number")
+ (version "1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://github.com/sharplispers/parse-number/"
+ "archive/v" version ".tar.gz"))
+ (file-name (string-append name "-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1k6s4v65ksc1j5i0dprvzfvj213v6nah7i0rgd0726ngfjisj9ir"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://www.cliki.net/PARSE-NUMBER")
+ (synopsis "Parse numbers")
+ (description "@code{parse-number} is a library of functions for parsing
+strings into one of the standard Common Lisp number types without using the
+reader. @code{parse-number} accepts an arbitrary string and attempts to parse
+the string into one of the standard Common Lisp number types, if possible, or
+else @code{parse-number} signals an error of type @code{invalid-number}.")
+ (license license:bsd-3)))
+
+(define-public sbcl-iterate
+ (package
+ (name "sbcl-iterate")
+ ;; The latest official release (1.4.3) fails to build so we have to take
+ ;; the current darcs tarball from quicklisp.
+ (version "20160825")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/iterate/"
+ "2016-08-25/iterate-"
+ version "-darcs.tgz"))
+ (sha256
+ (base32
+ "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://common-lisp.net/project/iterate/")
+ (synopsis "Iteration construct for Common Lisp")
+ (description "@code{iterate} is an iteration construct for Common Lisp.
+It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
+
+@itemize
+@item it is extensible,
+@item it helps editors like Emacs indent iterate forms by having a more
+ lisp-like syntax, and
+@item it isn't part of the ANSI standard for Common Lisp.
+@end itemize\n")
+ (license license:expat)))
+
+(define-public sbcl-cl-uglify-js
+ ;; There have been many bug fixes since the 2010 release.
+ (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-uglify-js")
+ (version (string-append "0.1-" revision "." (string-take commit 9)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mishoo/cl-uglify-js.git")
+ (commit commit)))
+ (sha256
+ (base32
+ "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-parse-js" ,sbcl-parse-js)
+ ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
+ ("sbcl-parse-number" ,sbcl-parse-number)
+ ("sbcl-iterate" ,sbcl-iterate)))
+ (home-page "https://github.com/mishoo/cl-uglify-js")
+ (synopsis "JavaScript compressor library for Common Lisp")
+ (description "This is a Common Lisp version of UglifyJS, a JavaScript
+compressor. It works on data produced by @code{parse-js} to generate a
+@dfn{minified} version of the code. Currently it can:
+
+@itemize
+@item reduce variable names (usually to single letters)
+@item join consecutive @code{var} statements
+@item resolve simple binary expressions
+@item group most consecutive statements using the ``sequence'' operator (comma)
+@item remove unnecessary blocks
+@item convert @code{IF} expressions in various ways that result in smaller code
+@item remove some unreachable code
+@end itemize\n")
+ (license license:zlib))))
+
+(define-public uglify-js
+ (package
+ (inherit sbcl-cl-uglify-js)
+ (name "uglify-js")
+ (build-system trivial-build-system)
+ (arguments
+ `(#:modules ((guix build utils))
+ #:builder
+ (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
+ (script (string-append bin "uglify-js")))
+ (use-modules (guix build utils))
+ (mkdir-p bin)
+ (with-output-to-file script
+ (lambda _
+ (format #t "#!~a/bin/sbcl --script
+ (require :asdf)
+ (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
+ (assoc-ref %build-inputs "sbcl")
+ (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
+ ;; FIXME: cannot use progn here because otherwise it fails to
+ ;; find cl-uglify-js.
+ (for-each
+ write
+ '(;; Quiet, please!
+ (let ((*standard-output* (make-broadcast-stream))
+ (*error-output* (make-broadcast-stream)))
+ (asdf:load-system :cl-uglify-js))
+ (let ((file (cadr *posix-argv*)))
+ (if file
+ (format t "~a"
+ (cl-uglify-js:ast-gen-code
+ (cl-uglify-js:ast-mangle
+ (cl-uglify-js:ast-squeeze
+ (with-open-file (in file)
+ (parse-js:parse-js in))))
+ :beautify nil))
+ (progn
+ (format *error-output*
+ "Please provide a JavaScript file.~%")
+ (sb-ext:exit :code 1))))))))
+ (chmod script #o755)
+ #t)))
+ (inputs
+ `(("sbcl" ,sbcl)
+ ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
+ (synopsis "JavaScript compressor")))