;;; Copyright © 2020 Dimakis Dimakakos <me@bendersteed.tech>
;;; Copyright © 2020 Oleg Pykhalov <go.wigust@gmail.com>
;;; Copyright © 2020 Adam Kandur <rndd@tuta.io>
+;;; Copyright © 2020 Sharlatan Hellseher <sharlatanus@gmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
(define-public ecl-alexandria
(sbcl-package->ecl-package sbcl-alexandria))
+(define-public sbcl-asdf-finalizers
+ (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0")
+ (revision "1"))
+ (package
+ (name "sbcl-asdf-finalizers")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fare-utils" ,sbcl-fare-utils)
+ ("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (arguments
+ `(#:asd-files '("asdf-finalizers.asd"
+ "list-of.asd"
+ "asdf-finalizers-test.asd")
+ #:asd-systems '("asdf-finalizers"
+ "list-of")))
+ (home-page "https://gitlab.common-lisp.net/asdf/asdf-finalizers")
+ (synopsis "Enforced calling of finalizers for Lisp code")
+ (description "This library allows you to implement and enforce proper
+finalization of compile-time constructs while building Lisp source files.
+
+It produces two systems: asdf-finalizers and list-of.")
+ (license license:expat))))
+
+(define-public ecl-asdf-finalizers
+ (sbcl-package->ecl-package sbcl-asdf-finalizers))
+
+(define-public cl-asdf-finalizers
+ (sbcl-package->cl-source-package sbcl-asdf-finalizers))
+
(define-public sbcl-net.didierverna.asdf-flv
(package
(name "sbcl-net.didierverna.asdf-flv")
(define-public ecl-net.didierverna.asdf-flv
(sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
+(define-public sbcl-command-line-arguments
+ (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe")
+ (revision "1"))
+ (package
+ (name "sbcl-command-line-arguments")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fare/command-line-arguments")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/fare/command-line-arguments")
+ (synopsis "Trivial command-line argument parsing library for Common Lisp")
+ (description "This is a library to abstract away the parsing of
+Unix-style command-line arguments. Use it in conjunction with asdf:program-op
+or cl-launch for portable processing of command-line arguments.")
+ (license license:expat))))
+
+(define-public ecl-command-line-arguments
+ (sbcl-package->ecl-package sbcl-command-line-arguments))
+
+(define-public cl-command-line-arguments
+ (sbcl-package->cl-source-package sbcl-command-line-arguments))
+
(define-public sbcl-fiveam
(package
(name "sbcl-fiveam")
(define-public ecl-flexi-streams
(sbcl-package->ecl-package sbcl-flexi-streams))
+(define-public sbcl-cl-abnf
+ ;; There are no releases
+ (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-abnf")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dimitri/cl-abnf")
+ (commit commit)))
+ (file-name (git-file-name "cl-abnf" version))
+ (sha256
+ (base32 "0f09nsndxa90acm71zd4qdnp40v705a4sqm04mnv9x76h6dlggmz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("esrap" ,sbcl-esrap)))
+ (arguments
+ `(#:asd-systems '("abnf")))
+ (home-page "https://github.com/dimitri/cl-abnf")
+ (synopsis "ABNF parser generator for Common Lisp")
+ (description "This Common Lisp library implements a parser generator for
+the ABNF grammar format as described in RFC2234. The generated parser is a
+regular expression scanner provided by the cl-ppcre lib, which means that we
+can't parse recursive grammar definition. One such definition is the ABNF
+definition as given by the RFC. Fortunately, as you have this lib, you most
+probably don't need to generate another parser to handle that particular ABNF
+grammar.")
+ (license license:expat))))
+
+(define-public cl-abnf
+ (sbcl-package->cl-source-package sbcl-cl-abnf))
+
+(define-public ecl-cl-abnf
+ (sbcl-package->ecl-package sbcl-cl-abnf))
+
(define-public sbcl-cl-ppcre
(package
(name "sbcl-cl-ppcre")
(define-public ecl-cl-ppcre
(sbcl-package->ecl-package sbcl-cl-ppcre))
+(define-public sbcl-uax-15
+ (let ((commit "e7439a91b72f533fcf736643e3ff0677b56c2e7d")
+ (revision "1"))
+ (package
+ (name "sbcl-uax-15")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sabracrolleton/uax-15")
+ (commit commit)))
+ (file-name (git-file-name "uax-15" version))
+ (sha256
+ (base32 "1vf8a2aikgx0l5bsq0z9s0dw3sgx1887xhagdlf66fwffa5jskg6"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ `(#:asd-systems '("uax-15")))
+ (home-page "https://github.com/sabracrolleton/uax-15")
+ (synopsis "Common Lisp implementation of unicode normalization functions")
+ (description "This package provides supports for unicode normalization,
+RFC8264 and RFC7564.")
+ (license license:expat))))
+
+(define-public cl-uax-15
+ (sbcl-package->cl-source-package sbcl-uax-15))
+
+(define-public ecl-uax-15
+ (sbcl-package->ecl-package sbcl-uax-15))
+
(define-public sbcl-cl-unicode
(package
(name "sbcl-cl-unicode")
(sbcl-package->ecl-package sbcl-clx-truetype))
(define-public sbcl-slynk
- (let ((revision "4")
- ;; Update together with emacs-sly.
- (commit "68561f1b7b66fa0240766ece836bb04da31ea17d"))
- (package
- (name "sbcl-slynk")
- (version (git-version "1.0.0-beta" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/joaotavora/sly")
- (commit commit)))
- (sha256
- (base32 "1xwx537dhgclngi6b0faf320i8pnac9309wvmk6z2g6dm3v652ds"))
- (file-name (git-file-name "slynk" version))
- (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"))
- (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"))
- #t))))
- (build-system asdf-build-system/sbcl)
- (outputs '("out" "image"))
- (arguments
- `(#:tests? #f ; No test suite
- #:asd-systems '("slynk"
- "slynk/arglists"
- "slynk/fancy-inspector"
- "slynk/package-fu"
- "slynk/mrepl"
- "slynk/trace-dialog"
- "slynk/profiler"
- "slynk/stickers"
- "slynk/indentation"
- "slynk/retro")
- #:phases
- (modify-phases %standard-phases
- (add-after 'create-asdf-configuration 'build-image
- (lambda* (#:key outputs #:allow-other-keys)
- (build-image (string-append
- (assoc-ref %outputs "image")
- "/bin/slynk")
- %outputs
- #:dependencies '("slynk"
- "slynk/arglists"
- "slynk/fancy-inspector"
- "slynk/package-fu"
- "slynk/mrepl"
- "slynk/trace-dialog"
- "slynk/profiler"
- "slynk/stickers"
- "slynk/indentation"
- "slynk/retro"))
- #t)))))
- (synopsis "Common Lisp IDE for Emacs")
- (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
+ (package
+ (name "sbcl-slynk")
+ (version "1.0.42")
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/joaotavora/sly")
+ (commit version)))
+ (sha256
+ (base32 "10l867c4hgcpiajcfkz9g9vabp7y4bcgy51la6n9pqxrlg1fs455"))
+ (file-name (git-file-name "slynk" version))
+ (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"))
+ (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"))
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (outputs '("out" "image"))
+ (arguments
+ `(#:tests? #f ; No test suite
+ #:asd-systems '("slynk"
+ "slynk/arglists"
+ "slynk/fancy-inspector"
+ "slynk/package-fu"
+ "slynk/mrepl"
+ "slynk/trace-dialog"
+ "slynk/profiler"
+ "slynk/stickers"
+ "slynk/indentation"
+ "slynk/retro")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'create-asdf-configuration 'build-image
+ (lambda* (#:key outputs #:allow-other-keys)
+ (build-image (string-append
+ (assoc-ref %outputs "image")
+ "/bin/slynk")
+ %outputs
+ #:dependencies '("slynk"
+ "slynk/arglists"
+ "slynk/fancy-inspector"
+ "slynk/package-fu"
+ "slynk/mrepl"
+ "slynk/trace-dialog"
+ "slynk/profiler"
+ "slynk/stickers"
+ "slynk/indentation"
+ "slynk/retro"))
+ #t)))))
+ (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 @code{comint-mode}, 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)))))))
+ (home-page "https://github.com/joaotavora/sly")
+ (license license:public-domain)
+ (properties `((cl-source-variant . ,(delay cl-slynk))))))
(define-public cl-slynk
(sbcl-package->cl-source-package sbcl-slynk))
(sbcl-package->ecl-package sbcl-rt))
(define-public sbcl-nibbles
- (package
- (name "sbcl-nibbles")
- (version "0.14")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/nibbles/")
- (commit (string-append "v" version))))
- (sha256
- (base32
- "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
- (file-name (git-file-name "nibbles" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- ;; Tests only.
- `(("rt" ,sbcl-rt)))
- (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
- (description
- "When dealing with network protocols and file formats, it's common to
+ ;; No tagged release since 2018.
+ (let ((commit "8e6b9b42d9f69000f55e5c45ad974d9e376ffdbd")
+ (revision "1"))
+ (package
+ (name "sbcl-nibbles")
+ (version (git-version "0.14" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/nibbles/")
+ (commit commit)))
+ (sha256
+ (base32 "15qlsm82h36pjgvfnbzdg60l21qxbaii4d049jc5y0dn56y93amb"))
+ (file-name (git-file-name "nibbles" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ ;; Tests only.
+ `(("rt" ,sbcl-rt)))
+ (synopsis
+ "Common Lisp library for accessing octet-addressed blocks of data")
+ (description
+ "When dealing with network protocols and file formats, it's common to
have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
flavors. Common Lisp sort of supports this by specifying :element-type for
streams, but that facility is underspecified and there's nothing similar for
functions for doing so are also provided. On some implementations,
reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
also be supported.")
- (home-page "https://github.com/sharplispers/nibbles")
- (license license:bsd-3)))
+ (home-page "https://github.com/sharplispers/nibbles")
+ (license license:bsd-3))))
(define-public cl-nibbles
(sbcl-package->cl-source-package sbcl-nibbles))
(define-public sbcl-ironclad
(package
(name "sbcl-ironclad")
- (version "0.52")
+ (version "0.53")
(source
(origin
(method git-fetch)
(url "https://github.com/sharplispers/ironclad/")
(commit (string-append "v" version))))
(sha256
- (base32 "0cyghppxwg7jr56af6098drbl6byknqlqcnj9sqlab5pxlywzkxx"))
+ (base32 "01qdfa0jggqbwlsb3aw1iigvs5xhnddk6kn3abhan59956dsbp02"))
(file-name (git-file-name name version))))
(build-system asdf-build-system/sbcl)
(native-inputs
(define-public ecl-puri
(sbcl-package->ecl-package sbcl-puri))
+(define-public sbcl-qmynd
+ (let ((commit "7e56daf73f0ed5f49a931c01af75fb874bcf3445")
+ (revision "1"))
+ (package
+ (name "sbcl-qmynd")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/qitab/qmynd")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "06gw5wxcpdclb6a5i5k9lbmdlyqsp182czrm9bm1cpklzbj0ihrl"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("asdf-finalizers" ,sbcl-asdf-finalizers)
+ ("babel" ,sbcl-babel)
+ ("chipz" ,sbcl-chipz)
+ ("cl+ssl" ,sbcl-cl+ssl)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("ironclad" ,sbcl-ironclad)
+ ("salza2" ,sbcl-salza2)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("usocket" ,sbcl-usocket)))
+ (home-page "https://github.com/qitab/qmynd")
+ (synopsis "QITAB MySQL Native Driver for Common Lisp")
+ (description "QMyND, the QITAB MySQL Native Driver, is a MySQL client
+library that directly talks to a MySQL server in its native network protocol.
+
+It's a part of QITAB umbrella project.")
+ (license license:expat))))
+
+(define-public ecl-qmynd
+ (sbcl-package->ecl-package sbcl-qmynd))
+
+(define-public cl-qmynd
+ (sbcl-package->cl-source-package sbcl-qmynd))
+
(define-public sbcl-queues
(let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
(package
(sbcl-package->ecl-package sbcl-cl-cffi-gtk))
(define-public sbcl-cl-webkit
- (let ((commit "aecd76a2bcc7bfee049c91d94cc75f893800bf37"))
+ (let ((commit "5ce3ea1fbf2b21e7ccb98402a818508ca9b79395"))
(package
(name "sbcl-cl-webkit")
- (version (git-version "2.4" "9" commit))
+ (version (git-version "2.4" "10" commit))
(source
(origin
(method git-fetch)
(file-name (git-file-name "cl-webkit" version))
(sha256
(base32
- "1j2wvn19kz0bcg17qr9pc4xp6fgjy8zngdnnp5rpfxd25sli62yc"))))
+ "0zgd8hp2nalh0v4xgjvqxd6rf95f7mci181xbg3gmqxxwxd4mkpk"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("cffi" ,sbcl-cffi)
(sbcl-package->cl-source-package sbcl-lparallel))
(define-public ecl-lparallel
- (sbcl-package->ecl-package sbcl-lparallel))
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-lparallel))
+ (arguments
+ ;; TODO: Find why the tests get stuck forever; disable them for now.
+ `(#:tests? #f))))
(define-public sbcl-cl-markup
(let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
(define-public ecl-cl-markup
(sbcl-package->ecl-package sbcl-cl-markup))
+(define-public sbcl-cl-mustache
+ (package
+ (name "sbcl-cl-mustache")
+ (version "0.12.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/kanru/cl-mustache")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-mustache" version))
+ (sha256
+ (base32 "149xbb6wxq1napliwm9cv729hwcgfnjli6y8hingfixz7f10lhks"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/kanru/cl-mustache")
+ (synopsis "Common Lisp Mustache template renderer")
+ (description "This is a Common Lisp implementation for the Mustache
+template system. More details on the standard are available at
+@url{https://mustache.github.io}.")
+ (license license:expat)))
+
+(define-public cl-mustache
+ (sbcl-package->cl-source-package sbcl-cl-mustache))
+
+(define-public ecl-cl-mustache
+ (sbcl-package->ecl-package sbcl-cl-mustache))
+
(define-public sbcl-cl-css
(let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
(package
(sbcl-package->ecl-package sbcl-ningle))
(define-public sbcl-cl-fastcgi
- (let ((commit "d576d20eeb12f225201074b28934ba395b15781a")
- (revision "1"))
+ (let ((commit "de8b49b26de9863996ec18db28af8ab7e8ac4e20")
+ (revision "2"))
(package
(name "sbcl-cl-fastcgi")
(version (git-version "0.2" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "02mvzzyn0k960s38rbxaqqmdkwcfmyhf8dx6ynz8xyxflmp0s5zv"))))
+ (base32 "0xgmhx766q4nmrvn5z7ag3ikpr9phlh8ypi8b14azshq9lqbq0m7"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("usocket" ,sbcl-usocket)
(description
"CL-FastCGI is a generic version of SB-FastCGI, targeting to run on
mostly Common Lisp implementation.")
- ;; TODO: Upstream on specifies "BSD license":
- ;; https://github.com/KDr2/cl-fastcgi/issues/4
(license license:bsd-2))))
(define-public cl-fastcgi
(define-public ecl-clack
(sbcl-package->ecl-package sbcl-clack))
+(define-public sbcl-cl-log
+ (let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-log")
+ (version "1.0.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/nicklevine/cl-log")
+ (commit commit)))
+ (sha256
+ (base32 "1r3z9swy1b59swvaa5b97is9ysrfmjvjjhhw56p7p5hqg93b92ak"))
+ (file-name (git-file-name "cl-log" version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp general purpose logging utility")
+ (description "CL-LOG is a general purpose logging utility, loosely modelled
+in some respects after Gary King's Log5. Its features include: logging to
+several destinations at once, via \"messengers\", each messenger is tailored to
+accept some log messages and reject others, and this tailoring can be changed
+on-the-fly, very rapid processing of messages which are rejected by all
+messengers, fully independent use of the utility by several different
+sub-systems in an application, support for messengers which cl:format text to a
+stream, support for messengers which do not invoke cl:format, timestamps in
+theory accurate to internal-time-units-per-second.")
+ (home-page "https://github.com/nicklevine/cl-log")
+ (license license:expat))))
+
+(define-public cl-log
+ (sbcl-package->cl-source-package sbcl-cl-log))
+
+(define-public ecl-cl-log
+ (sbcl-package->ecl-package sbcl-cl-log))
+
(define-public sbcl-log4cl
(let ((commit "611e094458504b938d49de904eab141285328c7c")
(revision "1"))
(define-public ecl-cl-hooks
(sbcl-package->ecl-package sbcl-cl-hooks))
+(define-public sbcl-cl-autowrap
+ (let ((revision "1")
+ (commit "ae846d6968fc0d000de0c541638929a157f3009e"))
+ ;; no taged branches
+ (package
+ (name "sbcl-cl-autowrap")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/cl-autowrap")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1gisldp2zns92kdcaikghm7c38ldy2d884n8bfg0wcjvbz78p3ar"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-json" ,sbcl-cl-json)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("defpackage-plus" ,sbcl-defpackage-plus)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://github.com/rpav/cl-autowrap")
+ (synopsis "FFI wrapper generator for Common Lisp")
+ (description "This is a c2ffi-based wrapper generator for Common Lisp.")
+ (license license:bsd-2))))
+
+(define-public cl-autowrap
+ (sbcl-package->cl-source-package sbcl-cl-autowrap))
+
+(define-public ecl-cl-autowrap
+ (sbcl-package->ecl-package sbcl-cl-autowrap))
+
(define-public sbcl-s-sysdeps
;; No release since 2013.
(let ((commit "9aa23bbdceb24bcdbe0e7c39fa1901858f823106")
(define-public sbcl-cl-octet-streams
(package
(name "sbcl-cl-octet-streams")
- (version "1.0")
+ (version "1.2")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
- (base32
- "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
+ (base32 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(sbcl-package->ecl-package sbcl-cl-octet-streams))
(define-public sbcl-lzlib
- (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
- (revision "1"))
+ (let ((commit "cad10f5becbcfebb44b9d311a257563778803452")
+ (revision "2"))
(package
(name "sbcl-lzlib")
- (version (git-version "1.0" revision commit))
+ (version (git-version "1.1" revision commit))
(source
(origin
(method git-fetch)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
+ (base32 "09lp7li35h4jkls0448fj1sh6pjslr1w7ranbc4szjr8g0c2bdry"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(inputs
`(("cffi" ,sbcl-cffi)
("cl-octet-streams" ,sbcl-cl-octet-streams)
+ ("lparallel" ,sbcl-lparallel)
("lzlib" ,lzlib)))
(arguments
'(#:phases
(define-public ecl-documentation-utils
(sbcl-package->ecl-package sbcl-documentation-utils))
+(define-public sbcl-documentation-utils-extensions
+ (let ((commit "f67f8a05d583174662a594b79356b201c1d9d750"))
+ (package
+ (name "sbcl-documentation-utils-extensions")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/sirherrbatka/documentation-utils-extensions/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("documentation-utils" ,sbcl-documentation-utils)))
+ (home-page "https://github.com/sirherrbatka/documentation-utils-extensions")
+ (synopsis "Set of extensions for documentation-utils")
+ (description
+ "Use @code{rich-formatter} to format documentation with sections @code{:syntax},
+@code{:arguments}, @code{:examples}, @code{:description}, @code{:returns},
+@code{:side-effects}, @code{:thread-safety}, @code{:affected-by},
+@code{:see-also} and @code{:notes}. Gather unformatted input by using
+@code{rich-aggregating-formatter} and @code{*DOCUMENTATION*} variable. Find
+gathered documentation with find-documentation function. Execute code stored
+in documentation with @code{execute-documentation}. See the examples in the
+@code{src/documentation.lisp} file. See the @code{documentation-utils} system
+for more information.")
+ (license license:expat))))
+
+(define-public cl-documentation-utils-extensions
+ (sbcl-package->cl-source-package sbcl-documentation-utils-extensions))
+
+(define-public ecl-documentation-utils-extensions
+ (sbcl-package->ecl-package sbcl-documentation-utils-extensions))
+
(define-public sbcl-form-fiddle
(let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
(revision "0"))
(sbcl-package->ecl-package sbcl-opticl))
(define-public sbcl-mcclim
- (let ((commit "27b4d7a667c9b3faa74cabcb57706b888314fff7")
- (revision "0"))
+ (let ((commit "04cc542dd4b461b9d56406e40681d1a8f080730f")
+ (revision "1"))
(package
(name "sbcl-mcclim")
(version (git-version "0.9.7" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0jijfgkwas6xnpp5wiii6slcx9pgsalngacb8zm29x6pamx2193h"))))
+ (base32 "1xjly8i62z72hfhlnz5kjd9i8xhrwckc7avyizxvhih67pkjmsx0"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("fiveam" ,sbcl-fiveam)
(define-public ecl-cl-inflector
(sbcl-package->ecl-package sbcl-cl-inflector))
+(define-public sbcl-ixf
+ (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183")
+ (revision "1"))
+ (package
+ (name "sbcl-ixf")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dimitri/cl-ixf")
+ (commit commit)))
+ (file-name (git-file-name "cl-ixf" version))
+ (sha256
+ (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("local-time" ,sbcl-local-time)
+ ("md5" ,sbcl-md5)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (home-page "https://github.com/dimitri/cl-ixf")
+ (synopsis "Parse IBM IXF file format")
+ (description
+ "This is a Common Lisp library to handle the IBM PC version of the IXF
+(Integration Exchange Format) file format.")
+ (license license:public-domain))))
+
+(define-public ecl-ixf
+ (sbcl-package->ecl-package sbcl-ixf))
+
+(define-public cl-ixf
+ (sbcl-package->cl-source-package sbcl-ixf))
+
(define-public sbcl-qbase64
(package
(name "sbcl-qbase64")
(define-public sbcl-geco
(package
(name "sbcl-geco")
- (version "2.01a")
+ (version "2.1.1")
(source
(origin
- (method url-fetch)
- (uri (string-append "https://common-lisp.net/project/geco/download/"
- "geco-" version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gpwwjr/GECO")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "geco" version))
(sha256
- (base32 "0kk0bzr1019cfmf2b1jl1rk9shv3gx5z1znifxllg9mb98yqsgw0"))
- (patches (search-patches "sbcl-geco-fix-organism-class.patch"))))
+ (base32 "1rc8a4mk40hjx5qy980hjylv6xxqdbq38hg8c4w30y93abfd519s"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://common-lisp.net/project/geco/")
+ (home-page "http://hiwaay.net/~gpw/geco/geco.html")
(synopsis "Genetic algorithm toolkit for Common Lisp")
(description
"GECO (Genetic Evolution through Combination of Objects) is an extensible,
(define-public ecl-check-it
(sbcl-package->ecl-package sbcl-check-it))
+
+(define-public sbcl-clamp
+ (let ((commit "02b8f3953e5753cc61a719807c82f3795cd28fe1"))
+ (package
+ (name "sbcl-clamp")
+ (version (git-version "0.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/arclanguage/Clamp")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0fdr9nqfmmpxm6hvjdxi1jkclya9xlnrw1yc3cn1m4ww3f50p31m"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)
+ ("cl-syntax" ,sbcl-cl-syntax)))
+ (native-inputs
+ `(("cl-unit" ,sbcl-clunit)
+ ("check-it" ,sbcl-check-it)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "clamp.asd"
+ (("\\(:file \"read\" :depends-on \\(\"aliases\"\\)\\)")
+ "(:file \"read\" :depends-on (\"aliases\" \"base\"))"))
+ #t)))))
+ (home-page "https://github.com/arclanguage/Clamp")
+ (synopsis "Common Lisp with Arc macros and procedures")
+ (description
+ "Clamp is an attempt to bring the powerful, but verbose, language of
+Common Lisp up to the terseness of Arc.
+
+There are two parts to Clamp. There is the core of Clamp, which implements
+the utilities of Arc that are easily converted from Arc to Common Lisp. The
+other part is the \"experimental\" part. It contains features of Arc that are
+not so easy to copy (ssyntax, argument destructuring, etc.).")
+ (license license:artistic2.0))))
+
+(define-public cl-clamp
+ (sbcl-package->cl-source-package sbcl-clamp))
+
+(define-public ecl-clamp
+ (sbcl-package->ecl-package sbcl-clamp))
+
+(define-public sbcl-trivial-shell
+ (let ((commit "e02ec191b34b52deca5d1c4ee99d4fa13b8772e0"))
+ (package
+ (name "sbcl-trivial-shell")
+ (version (git-version "0.2.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/trivial-shell")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "08mpkl5ij5sjfsyn8pq2kvsvpvyvr7ha1r8g1224fa667b8k2q85"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (home-page "http://common-lisp.net/project/trivial-shell/")
+ (synopsis "Common Lisp access to the shell")
+ (description
+ "A simple Common-Lisp interface to the underlying operating system.
+It's independent of the implementation and operating system.")
+ (license license:expat))))
+
+(define-public cl-trivial-shell
+ (sbcl-package->cl-source-package sbcl-trivial-shell))
+
+(define-public ecl-trivial-shell
+ (sbcl-package->ecl-package sbcl-trivial-shell))
+
+(define-public sbcl-clesh
+ (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11"))
+ (package
+ (name "sbcl-clesh")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Neronus/Clesh")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("trivial-shell" ,sbcl-trivial-shell)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://github.com/Neronus/Clesh")
+ (synopsis "Embed shell code in Common Lisp")
+ (description
+ "This is a very short and simple program, written in Common Lisp, that
+extends Common Lisp to embed shell code in a manner similar to Perl's
+backtick. It has been forked from SHELISP.")
+ (license license:bsd-2))))
+
+(define-public cl-clesh
+ (sbcl-package->cl-source-package sbcl-clesh))
+
+(define-public ecl-clesh
+ (sbcl-package->ecl-package sbcl-clesh))
+
+(define-public sbcl-trivial-download
+ (let ((commit "d2472061d86b1cf3d32f388daacd4e32a13af699"))
+ (package
+ (name "sbcl-trivial-download")
+ (version (git-version "0.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/eudoxia0/trivial-download/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "06f46zr3gp3wlm2kgxna24qd2gpr1v89x9fynh1x5vrw6c6hqjcv"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("drakma" ,sbcl-drakma)))
+ (home-page "https://github.com/eudoxia0/trivial-download/")
+ (synopsis "Download files from Common Lisp")
+ (description
+ "@code{trivial-download} allows you to download files from the Internet
+from Common Lisp. It provides a progress bar.")
+ (license license:bsd-2))))
+
+(define-public cl-trivial-download
+ (sbcl-package->cl-source-package sbcl-trivial-download))
+
+(define-public ecl-trivial-download
+ (sbcl-package->ecl-package sbcl-trivial-download))
+
+(define-public sbcl-gtwiwtg
+ (package
+ (name "sbcl-gtwiwtg")
+ (version "0.1.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cbeo/gtwiwtg/")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0lkraw0dwh4is4x5sp5rjrw6f93m0gr9849abrbi12s25ws7jbw4"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("osicat" ,sbcl-osicat)
+ ("prove" ,sbcl-prove)))
+ (home-page "https://github.com/cbeo/gtwiwtg/")
+ (synopsis "Naive generators for Common Lisp")
+ (description
+ "The GTWIWTG library (Generators The Way I Want Them Generated --
+technically not generators, but iterators) is meant to be small, explorable,
+and understandable.")
+ (license license:gpl3)))
+
+(define-public cl-gtwiwtg
+ (sbcl-package->cl-source-package sbcl-gtwiwtg))
+
+(define-public ecl-gtwiwtg
+ (sbcl-package->ecl-package sbcl-gtwiwtg))
+
+(define-public sbcl-cl-progress-bar
+ (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae"))
+ (package
+ (name "sbcl-cl-progress-bar")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sirherrbatka/cl-progress-bar/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ldb4qhmx431n3lsq71ynwb9ybazbfqd55icjbhi06mj52ngndir"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("documentation-utils-extensions" ,sbcl-documentation-utils-extensions)))
+ (home-page "https://github.com/sirherrbatka/cl-progress-bar/")
+ (synopsis "Progress bars in Common Lisp")
+ (description
+ "This library provides almost the same code as used inside Quicklisp
+for drawning progress bars")
+ (license license:expat))))
+
+(define-public cl-progress-bar
+ (sbcl-package->cl-source-package sbcl-cl-progress-bar))
+
+(define-public ecl-cl-progress-bar
+ (sbcl-package->ecl-package sbcl-cl-progress-bar))
+
+(define-public sbcl-repl-utilities
+ (let ((commit "e0de9c92e774f77cab1a4cd92e2ac922ac3a807e"))
+ (package
+ (name "sbcl-repl-utilities")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m-n/repl-utilities/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1r5icmw3ha5y77kvzqni3a9bcd66d9pz5mjsbw04xg3jk0d15cgz"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/m-n/repl-utilities")
+ (synopsis "Ease common tasks at the Common Lisp REPL")
+ (description
+ "@code{repl-utilities} is a set of utilities which ease life at the
+REPL. It includes three sorts of features: introspective procedures,
+miscellaneous utility functions, and, pulling them together, methods to
+conveniently keep these symbols and optionally additional symbols available in
+whichever package you switch to.")
+ (license license:bsd-2))))
+
+(define-public cl-repl-utilities
+ (sbcl-package->cl-source-package sbcl-repl-utilities))
+
+(define-public ecl-repl-utilities
+ (sbcl-package->ecl-package sbcl-repl-utilities))
+
+(define-public sbcl-supertrace
+ (let ((commit "66d22c3ff131ecd1c8048dfced1d62ed6024ecb0"))
+ (package
+ (name "sbcl-supertrace")
+ (version (git-version "0.1.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/supertrace")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0n369n6b7y1m49biccnnr7svymjdsk8sksrkqrn3mj21vgv7s7bg"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("cffi-grovel" ,sbcl-cffi)
+ ("rove" ,sbcl-rove)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)))
+ (home-page "https://github.com/fukamachi/supertrace")
+ (synopsis "Improved Common Lisp tracing for debugging and profiling")
+ (description
+ "Supertrace provides a superior Common Lisp @code{trace} functionality
+for debugging and profiling real world applications.")
+ (license license:bsd-2))))
+
+(define-public cl-supertrace
+ (sbcl-package->cl-source-package sbcl-supertrace))
+
+(define-public ecl-supertrace
+ (sbcl-package->ecl-package sbcl-supertrace))
+
+(define-public sbcl-trivial-benchmark
+ (let ((commit "42d76733dd2e873471c6f1e27d39113293f7dd5c"))
+ (package
+ (name "sbcl-trivial-benchmark")
+ (version (git-version "2.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/trivial-benchmark/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0fbzqbpm2ixz85555krl36kbbbjyn699vdj6k383khi3g9y629fa"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "http://shinmera.github.io/trivial-benchmark/")
+ (synopsis "Easy to use benchmarking system for Common Lisp")
+ (description
+ "Trivial-Benchmark runs a block of code many times and outputs some
+statistical data for it. On SBCL this includes the data from @code{time}, for
+all other implementations just the @code{real-time} and @code{run-time} data.
+However, you can extend the system by adding your own @code{metrics} to it, or
+even by adding additional statistical @code{compute}ations. ")
+ (license license:zlib))))
+
+(define-public cl-trivial-benchmark
+ (sbcl-package->cl-source-package sbcl-trivial-benchmark))
+
+(define-public ecl-trivial-benchmark
+ (sbcl-package->ecl-package sbcl-trivial-benchmark))
+
+(define-public sbcl-glyphs
+ (let ((commit "1ff5714e8c1dca327bc604dfe3e3d1f4b7755373"))
+ (package
+ (name "sbcl-glyphs")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ahungry/glyphs/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "17kai1anbkk5dj5sbrsin2fc019cmcbglb900db60v38myj0y0wf"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("parenscript" ,sbcl-parenscript)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://github.com/ahungry/glyphs/")
+ (synopsis "Reduce Common Lisp verbosity")
+ (description
+ "This library is a little experiment in reducing verbosity in Common
+Lisp, inspired by BODOL (@url{https://github.com/bodil/BODOL}).")
+ (license license:gpl3))))
+
+(define-public cl-glyphs
+ (sbcl-package->cl-source-package sbcl-glyphs))
+
+(define-public ecl-glyphs
+ (sbcl-package->ecl-package sbcl-glyphs))
+
+(define-public sbcl-zs3
+ (package
+ (name "sbcl-zs3")
+ (version "1.3.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/xach/zs3")
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name "zs3" version))
+ (sha256
+ (base32 "186v95wgsj2hkxdw2jl9x1w4fddjclp7arp0rrd9vf5ly8h8sbf3"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("drakma" ,sbcl-drakma)
+ ("alexandria" ,sbcl-alexandria)
+ ("cxml" ,sbcl-cxml)
+ ("ironclad" ,sbcl-ironclad)
+ ("puri" ,sbcl-puri)
+ ("cl-base64" ,sbcl-cl-base64)))
+ (synopsis "Work with Amazon S3 and Amazon CloudFront from Common Lisp")
+ (description "This is ZS3, a library for working with Amazon's Simple Storage
+Service (S3) and CloudFront service from Common Lisp.")
+ (home-page "https://github.com/xach/zs3")
+ (license license:bsd-2)))
+
+(define-public cl-zs3
+ (sbcl-package->cl-source-package sbcl-zs3))
+
+(define-public ecl-zs3
+ (sbcl-package->ecl-package sbcl-zs3))
+
+(define-public sbcl-simple-neural-network
+ (package
+ (name "sbcl-simple-neural-network")
+ (version "3.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/simple-neural-network")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "simple-neural-network" version))
+ (sha256
+ (base32 "1jj1c90fr5clwka0jv32hv6xp1bkdlpa6x5jh19an13rhx8ll4zr"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("chipz" ,sbcl-chipz)
+ ("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("cl-store" ,sbcl-cl-store)
+ ("lparallel" ,sbcl-lparallel)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'check 'remove-test-data
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((out (assoc-ref outputs "out")))
+ (for-each delete-file (find-files out "\\.gz$"))))))))
+ (synopsis "Simple neural network in Common Lisp")
+ (description
+ "@code{simple-neural-network} is a Common Lisp library for creating,
+training and using basic neural networks. The networks created by this
+library are feedforward neural networks trained using backpropagation.")
+ (home-page "https://github.com/glv2/simple-neural-network")
+ (license license:gpl3+)))
+
+(define-public cl-simple-neural-network
+ (sbcl-package->cl-source-package sbcl-simple-neural-network))
+
+(define-public ecl-simple-neural-network
+ (sbcl-package->ecl-package sbcl-simple-neural-network))
+
+(define-public sbcl-zstd
+ (let ((commit "d144582c581aaa52bac24d6686af27fa3e781e06")
+ (revision "1"))
+ (package
+ (name "sbcl-zstd")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/cl-zstd")
+ (commit commit)))
+ (file-name (git-file-name "cl-zstd" version))
+ (sha256
+ (base32 "1774jy8hzbi6nih3sq6vchk66f7g8w86dwgpbvljyfzcnkcaz6ql"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-octet-streams" ,sbcl-cl-octet-streams)
+ ("zstd-lib" ,zstd "lib")))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/libzstd.lisp"
+ (("libzstd\\.so")
+ (string-append (assoc-ref inputs "zstd-lib")
+ "/lib/libzstd.so")))
+ #t)))))
+ (synopsis "Common Lisp library for Zstandard (de)compression")
+ (description
+ "This Common Lisp library provides functions for Zstandard
+compression/decompression using bindings to the libzstd C library.")
+ (home-page "https://github.com/glv2/cl-zstd")
+ (license license:gpl3+))))
+
+(define-public cl-zstd
+ (sbcl-package->cl-source-package sbcl-zstd))
+
+(define-public ecl-zstd
+ (sbcl-package->ecl-package sbcl-zstd))
HCoop / jackhill / guix / guix.git / blobdiff