;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
;;; Copyright © 2017, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
-;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
+;;; Copyright © 2017, 2018, 2019, 2020 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
#:use-module (gnu packages webkit)
#:use-module (gnu packages xdisorg)
#:use-module (ice-9 match)
+ #:use-module (srfi srfi-1)
#:use-module (srfi srfi-19))
(define-public sbcl-alexandria
(sha256
(base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
(build-system asdf-build-system/sbcl)
- (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
+ (native-inputs
+ `(("flexi-streams" ,sbcl-flexi-streams)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'disable-ppcre-unicode
+ ;; cl-ppcre and cl-ppcre-unicode are put in different packages
+ ;; to work around the circular dependency between edicl/cl-ppcre
+ ;; and edicl/cl-unicode.
+ (lambda _
+ (delete-file "cl-ppcre-unicode.asd")
+ #t)))))
(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
(define-public ecl-cl-ppcre
(sbcl-package->ecl-package sbcl-cl-ppcre))
-(define sbcl-cl-unicode-base
+(define-public sbcl-cl-unicode
(package
- (name "sbcl-cl-unicode-base")
+ (name "sbcl-cl-unicode")
(version "0.1.6")
(source (origin
(method git-fetch)
(base32
"0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-unicode.asd"
- #:asd-system-name "cl-unicode/base"))
+ (native-inputs
+ `(("flexi-streams" ,sbcl-flexi-streams)))
(inputs
`(("cl-ppcre" ,sbcl-cl-ppcre)))
(home-page "http://weitz.de/cl-unicode/")
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-cl-ppcre-unicode
+ (package (inherit sbcl-cl-ppcre)
+ (name "sbcl-cl-ppcre-unicode")
+ (inputs
+ `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-cl-unicode" ,sbcl-cl-unicode)))
+ (arguments
+ `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'disable-ppcre
+ ;; cl-ppcre and cl-ppcre-unicode are put in different packages
+ ;; to work around the circular dependency between edicl/cl-ppcre
+ ;; and edicl/cl-unicode.
+ (lambda _
+ (delete-file "cl-ppcre.asd")
+ #t)))))))
+
+(define-public cl-ppcre-unicode
+ (sbcl-package->cl-source-package sbcl-cl-ppcre-unicode))
+
+(define-public ecl-cl-ppcre-unicode
+ (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
+
(define-public sbcl-zpb-ttf
(package
(name "sbcl-zpb-ttf")
(define-public cl-zpb-ttf
(sbcl-package->cl-source-package sbcl-zpb-ttf))
-(define-public sbcl-cl-aa
+(define-public sbcl-cl-vectors
(package
- (name "sbcl-cl-aa")
+ (name "sbcl-cl-vectors")
(version "0.1.5")
(source
(origin
(base32
"04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
(build-system asdf-build-system/sbcl)
- (arguments '(#:asd-file "cl-aa.asd"))
- (home-page "http://projects.tuxee.net/cl-vectors/")
- (synopsis "Polygon rasterizer")
- (description
- "This is a Common Lisp library implementing the AA polygon rasterization
-algorithm from the @url{http://antigrain.com, Antigrain} project.")
- (license license:expat)))
-
-(define-public ecl-cl-aa
- (sbcl-package->ecl-package sbcl-cl-aa))
-
-(define-public cl-aa
- (sbcl-package->cl-source-package sbcl-cl-aa))
-
-(define-public sbcl-cl-paths
- (package
- (inherit sbcl-cl-aa)
- (name "sbcl-cl-paths")
- (arguments '(#:asd-file "cl-paths.asd"))
- (synopsis "Facilities to create and manipulate vectorial paths")
- (description
- "This package provides facilities to create and manipulate vectorial
-paths.")))
-
-(define-public ecl-cl-paths
- (sbcl-package->ecl-package sbcl-cl-paths))
-
-(define-public cl-paths
- (sbcl-package->cl-source-package sbcl-cl-paths))
-
-(define-public sbcl-cl-paths-ttf
- (package
- (inherit sbcl-cl-aa)
- (name "sbcl-cl-paths-ttf")
- (arguments '(#:asd-file "cl-paths-ttf.asd"))
- (inputs
- `(("cl-paths" ,sbcl-cl-paths)
- ("zpb-ttf" ,sbcl-zpb-ttf)))
- (synopsis "Facilities to create and manipulate vectorial paths")
- (description
- "This package provides facilities to create and manipulate vectorial
-paths.")))
-
-(define-public ecl-cl-paths-ttf
- (sbcl-package->ecl-package sbcl-cl-paths-ttf))
-
-(define-public cl-paths-ttf
- (sbcl-package->cl-source-package sbcl-cl-paths-ttf))
-
-(define-public sbcl-cl-vectors
- (package
- (inherit sbcl-cl-aa)
- (name "sbcl-cl-vectors")
- (arguments '(#:asd-file "cl-vectors.asd"))
(inputs
- `(("cl-aa" ,sbcl-cl-aa)
- ("cl-paths" ,sbcl-cl-paths)))
+ `(("zpb-ttf" ,sbcl-zpb-ttf)))
+ (arguments
+ '(#:asd-systems '("cl-vectors"
+ "cl-paths-ttf")))
+ (home-page "http://projects.tuxee.net/cl-vectors/")
(synopsis "Create, transform and render anti-aliased vectorial paths")
(description
"This is a pure Common Lisp library to create, transform and render
-anti-aliased vectorial paths.")))
+anti-aliased vectorial paths.")
+ (license license:expat)))
(define-public ecl-cl-vectors
(sbcl-package->ecl-package sbcl-cl-vectors))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f ; spatial-trees.test requires spatial-trees.nns
- #:asd-file "spatial-trees.asd"
#:test-asd-file "spatial-trees.test.asd"))
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
`(("clx" ,sbcl-clx)
("zpb-ttf" ,sbcl-zpb-ttf)
("cl-vectors" ,sbcl-cl-vectors)
- ("cl-paths-ttf" ,sbcl-cl-paths-ttf)
("cl-fad" ,sbcl-cl-fad)
("cl-store" ,sbcl-cl-store)
("trivial-features" ,sbcl-trivial-features)))
antialiased TrueType font rendering using CLX and XRender extension.")
(license license:expat))))
-(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 cl-clx-truetype
+ (sbcl-package->cl-source-package sbcl-clx-truetype))
-(define-public ecl-cl-ppcre-unicode
- (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
+(define-public ecl-clx-truetype
+ (sbcl-package->ecl-package sbcl-clx-truetype))
-;; 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
+(define-public sbcl-slynk
(let ((revision "3")
;; Update together with emacs-sly.
(commit "6a2f543cb21f14104c2253af5a1427b884a987ae"))
(package
- (name "sbcl-slynk-boot0")
- (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
+ (name "sbcl-slynk")
+ (version (git-version "1.0.0-beta" revision commit))
(source
(origin
(method git-fetch)
(commit commit)))
(sha256
(base32 "0wbpg9p9yg2hd62l15pvy50fk3hndq5zzyqlyyf04g368s895144"))
- (file-name (string-append "slynk-" version "-checkout"))
+ (file-name (git-file-name "slynk" version))
(modules '((guix build utils)
(ice-9 ftw)))
(snippet
(scandir "slynk"))
#t))))
(build-system asdf-build-system/sbcl)
+ (outputs '("out" "image"))
(arguments
`(#:tests? #f ; No test suite
- #:asd-system-name "slynk"))
+ #:asd-systems '("slynk"
+ "slynk/arglists"
+ "slynk/util"
+ "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/util"
+ "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
(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) "slynk/arglists")))))
-
-(define ecl-slynk-arglists
- (sbcl-package->ecl-package sbcl-slynk-arglists))
-
-(define sbcl-slynk-util
- (package
- (inherit sbcl-slynk-boot0)
- (name "sbcl-slynk-util")
- (inputs `(("slynk" ,sbcl-slynk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
- ((#:asd-file _ "") "slynk.asd")
- ((#:asd-system-name _ #f) "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)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
-
-(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")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/package-fu")))))
-
-(define ecl-slynk-package-fu
- (sbcl-package->ecl-package sbcl-slynk-package-fu))
-
-(define sbcl-slynk-mrepl
- (package
- (inherit sbcl-slynk-fancy-inspector)
- (name "sbcl-slynk-mrepl")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "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")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "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")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "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")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "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")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "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")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "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))
- #t)))))
+ (sbcl-package->cl-source-package sbcl-slynk))
(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)
- #t)))))))
+ (let ((pkg (sbcl-package->ecl-package sbcl-slynk)))
+ (package
+ (inherit pkg)
+ (outputs '("out"))
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (delete 'build-image))))))))
(define-public sbcl-parse-js
(let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
(define-public cl-parse-js
(sbcl-package->cl-source-package sbcl-parse-js))
+(define-public ecl-parse-js
+ (sbcl-package->ecl-package sbcl-parse-js))
+
(define-public sbcl-parse-number
(package
(name "sbcl-parse-number")
(define-public cl-parse-number
(sbcl-package->cl-source-package sbcl-parse-number))
+(define-public ecl-parse-number
+ (sbcl-package->ecl-package sbcl-parse-number))
+
(define-public sbcl-iterate
(package
(name "sbcl-iterate")
(define-public cl-uglify-js
(sbcl-package->cl-source-package sbcl-cl-uglify-js))
+(define-public ecl-cl-uglify-js
+ (sbcl-package->ecl-package sbcl-cl-uglify-js))
+
(define-public uglify-js
(package
(inherit sbcl-cl-uglify-js)
(with-output-to-file script
(lambda _
(format #t "#!~a/bin/sbcl --script
+
(require :asdf)
- (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
+ (asdf:initialize-source-registry
+ #p\"~a/etc/common-lisp/source-registry.conf.d/\")
+ (asdf:initialize-output-translations
+ #p\"~a/etc/common-lisp/asdf-output-translations.conf.d/\")"
(assoc-ref %build-inputs "sbcl")
+ (assoc-ref %build-inputs "sbcl-cl-uglify-js")
(assoc-ref %build-inputs "sbcl-cl-uglify-js"))
;; FIXME: cannot use progn here because otherwise it fails to
;; find cl-uglify-js.
(sha256
(base32 "14pcahr8r2j3idhyy216zyw8jnj1dnrx0qbkkbdqkvwzign1ah4j"))))
(build-system asdf-build-system/sbcl)
- (arguments '(#:tests? #f))
+ (arguments
+ '(#:asd-files '("trivial-features.asd")
+ #:tests? #f))
(home-page "https://cliki.net/trivial-features")
(synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
(description "Trivial-features ensures that @code{*FEATURES*} is
(file-name (string-append "cl-yacc-" version "-checkout"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-file "yacc.asd"
- #:asd-system-name "yacc"))
+ `(#:asd-systems '("yacc")))
(synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
(description
"CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
(arguments
;; FIXME: We need to specify the name because the build-system thinks
;; "3" is a version marker.
- `(#:asd-system-name "3bmd"))
+ `(#:asd-systems '("3bmd"
+ "3bmd-ext-code-blocks")))
(inputs
- `(("esrap" ,sbcl-esrap)
+ `(("colorize" ,sbcl-colorize)
+ ("esrap" ,sbcl-esrap)
("split-sequence" ,sbcl-split-sequence)))
(synopsis "Markdown processor in Command Lisp using esrap parser")
(description
(define-public ecl-3bmd
(sbcl-package->ecl-package sbcl-3bmd))
-(define-public sbcl-3bmd-ext-code-blocks
- (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
- (package
- (inherit sbcl-3bmd)
- (name "sbcl-3bmd-ext-code-blocks")
- (arguments
- `(#:asd-system-name "3bmd-ext-code-blocks"
- #:asd-file "3bmd-ext-code-blocks.asd"))
- (inputs
- `(("3bmd" ,sbcl-3bmd)
- ("colorize" ,sbcl-colorize)))
- (synopsis "3bmd extension which adds support for GitHub-style fenced
-code blocks")
- (description
- "3bmd extension which adds support for GitHub-style fenced code blocks,
-with @command{colorize} support."))))
-
-(define-public cl-3bmd-ext-code-blocks
- (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
-
-(define-public ecl-3bmd-ext-code-blocks
- (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
-
(define-public sbcl-cl-fad
(package
(name "sbcl-cl-fad")
(define-public sbcl-ironclad
(package
(name "sbcl-ironclad")
- (version "0.50")
+ (version "0.51")
(source
(origin
(method git-fetch)
(url "https://github.com/sharplispers/ironclad/")
(commit (string-append "v" version))))
(sha256
- (base32 "0k4bib9mbrzalbl9ivkw4a7g4c7bbad1l5jw4pzkifqszy2swkr5"))
+ (base32 "1zxkzbxsfb83bb87rhp4h75cc1h5f6ziyfa5lvaa30zgix9l2d7v"))
(file-name (git-file-name name version))))
(build-system asdf-build-system/sbcl)
(native-inputs
(define-public ecl-pythonic-string-reader
(sbcl-package->ecl-package sbcl-pythonic-string-reader))
-;; SLIME does not have a ASDF system definition to build all of Swank. As a
-;; result, the asdf-build-system/sbcl will produce an almost empty package.
-;; Some work was done to fix this at
-;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
-;; and is now lagging behind. Building SBCL fasls might not be worth the
-;; hassle, so let's just ship the source then.
-(define-public cl-slime-swank
+(define-public sbcl-slime-swank
(package
- (name "cl-slime-swank")
- (version "2.24")
+ (name "sbcl-slime-swank")
+ (version "2.26")
(source
(origin
- (file-name (string-append name "-" version ".tar.gz"))
+ (file-name (git-file-name "slime-swank" version))
(method git-fetch)
(uri (git-reference
(url "https://github.com/slime/slime/")
(commit (string-append "v" version))))
(sha256
(base32
- "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
- (build-system asdf-build-system/source)
+ "0mxb1wnw19v0s72w2wkz5afdlzvpy5nn7pr4vav403qybac0sw5c"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("swank")))
(home-page "https://github.com/slime/slime")
(synopsis "Common Lisp Swank server")
(description
@command{M-x slime} automatically start the server.")
(license (list license:gpl2+ license:public-domain))))
-(define-public sbcl-slime-swank
- (deprecated-package "sbcl-slime-swank" cl-slime-swank))
+(define-public cl-slime-swank
+ (sbcl-package->cl-source-package sbcl-slime-swank))
+
+(define-public ecl-slime-swank
+ (sbcl-package->ecl-package sbcl-slime-swank))
(define-public sbcl-mgl-pax
(let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
(build-system asdf-build-system/sbcl)
(inputs
`(("3bmd" ,sbcl-3bmd)
- ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
("babel" ,sbcl-babel)
("cl-fad" ,sbcl-cl-fad)
("ironclad" ,sbcl-ironclad)
("named-readtables" ,sbcl-named-readtables)
- ("pythonic-string-reader" ,sbcl-pythonic-string-reader)))
- (propagated-inputs
- ;; Packages having mgl-pax as input complain that it can't find
- ;; swank if we put it in inputs, so let's put it in propageted-inputs.
- `(("swank" ,cl-slime-swank)))
+ ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
+ ("swank" ,sbcl-slime-swank)))
(synopsis "Exploratory programming environment and documentation generator")
(description
"PAX provides an extremely poor man's Explorable Programming
(sbcl-package->cl-source-package sbcl-mgl-pax))
(define-public ecl-mgl-pax
- (sbcl-package->ecl-package sbcl-mgl-pax))
+ (let ((pkg (sbcl-package->ecl-package sbcl-mgl-pax)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; TODO: Find why the tests fail on ECL.
+ ((#:tests? _ #f) #f))))))
(define-public sbcl-lisp-unit
(let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
(define-public ecl-cl-ansi-text
(sbcl-package->ecl-package sbcl-cl-ansi-text))
-(define-public sbcl-prove-asdf
+(define-public sbcl-prove
(let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
(package
- (name "sbcl-prove-asdf")
+ (name "sbcl-prove")
(version (git-version "1.0.0" "1" commit))
(source
(origin
"07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
(file-name (git-file-name "prove" version))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-file "prove-asdf.asd"))
- (synopsis "Test requirement for the Common Lisp 'prove' library")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-ansi-text" ,sbcl-cl-ansi-text)))
+ (synopsis "Yet another unit testing framework for Common Lisp")
(description
- "Test requirement for the Common Lisp @command{prove} library.")
- (home-page "https://github.com/fukamachi/prove")
- (license license:expat))))
-
-(define-public cl-prove-asdf
- (sbcl-package->cl-source-package sbcl-prove-asdf))
-
-(define-public ecl-prove-asdf
- (sbcl-package->ecl-package sbcl-prove-asdf))
-
-(define-public sbcl-prove
- (package
- (inherit sbcl-prove-asdf)
- (name "sbcl-prove")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("cl-ansi-text" ,sbcl-cl-ansi-text)))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (arguments
- `(#:asd-file "prove.asd"))
- (synopsis "Yet another unit testing framework for Common Lisp")
- (description
- "This project was originally called @command{cl-test-more}.
+ "This project was originally called @command{cl-test-more}.
@command{prove} is yet another unit testing framework for Common Lisp. The
advantages of @command{prove} are:
@item Extensible test reporters
@item Colorizes the report if it's available (note for SLIME)
@item Reports test durations
-@end itemize\n")))
+@end itemize\n")
+ (home-page "https://github.com/fukamachi/prove")
+ (license license:expat))))
(define-public cl-prove
(sbcl-package->cl-source-package sbcl-prove))
`(("alexandria" ,sbcl-alexandria)
("babel" ,sbcl-babel)))
(native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
+ `(("prove" ,sbcl-prove)))
(arguments
;; TODO: Tests don't find "proc-parse-test", why?
`(#:tests? #f))
`(("alexandria" ,sbcl-alexandria)
("babel" ,sbcl-babel)))
(native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
+ `(("prove" ,sbcl-prove)))
(arguments
;; TODO: Tests don't find "proc-parse-test", why?
`(#:tests? #f))
(define-public ecl-parse-float
(sbcl-package->ecl-package sbcl-parse-float))
-(define-public sbcl-ascii-strings
+(define-public sbcl-cl-string-match
(let ((revision "1")
(changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
(package
- (name "sbcl-ascii-strings")
- (version (string-append "0-" revision "." (string-take changeset 7)))
+ (name "sbcl-cl-string-match")
+ (version (git-version "0" revision changeset))
(source
(origin
(method hg-fetch)
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)))
+ ("babel" ,sbcl-babel)
+ ("iterate" ,sbcl-iterate)
+ ("jpl-queues" ,sbcl-jpl-queues)
+ ("jpl-util" ,sbcl-jpl-util)
+ ("mgl-pax" ,sbcl-mgl-pax)
+ ("parse-float" ,sbcl-parse-float)
+ ("proc-parse" ,sbcl-proc-parse)
+ ("yacc" ,sbcl-cl-yacc)))
+ ;; TODO: Tests are not evaluated properly.
+ (native-inputs
+ ;; For testing:
+ `(("lisp-unit" ,sbcl-lisp-unit)))
(arguments
- `(#:asd-file "ascii-strings.asd"))
- (synopsis "Operations on ASCII strings")
+ `(#:tests? #f))
+ (synopsis "Set of utilities to manipulate strings in Common Lisp")
(description
- "Operations on ASCII strings. Essentially this can be any kind of
-single-byte encoded strings.")
+ "@command{cl-strings} is a small, portable, dependency-free set of
+utilities that make it even easier to manipulate text in Common Lisp. It has
+100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
(home-page "https://bitbucket.org/vityok/cl-string-match/")
(license license:bsd-3))))
-(define-public cl-ascii-strings
- (sbcl-package->cl-source-package sbcl-ascii-strings))
-
-(define-public ecl-ascii-strings
- (sbcl-package->ecl-package sbcl-ascii-strings))
-
-(define-public sbcl-simple-scanf
- (package
- (inherit sbcl-ascii-strings)
- (name "sbcl-simple-scanf")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)
- ("proc-parse" ,sbcl-proc-parse)
- ("parse-float" ,sbcl-parse-float)))
- (arguments
- `(#:asd-file "simple-scanf.asd"))
- (synopsis "Simple scanf-like functionality implementation")
- (description
- "A simple scanf-like functionality implementation.")))
-
-(define-public cl-simple-scanf
- (sbcl-package->cl-source-package sbcl-simple-scanf))
-
-(define-public ecl-simple-scanf
- (sbcl-package->ecl-package sbcl-simple-scanf))
-
-(define-public sbcl-cl-string-match
- (package
- (inherit sbcl-ascii-strings)
- (name "sbcl-cl-string-match")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("ascii-strings" ,sbcl-ascii-strings)
- ("yacc" ,sbcl-cl-yacc)
- ("jpl-util" ,sbcl-jpl-util)
- ("jpl-queues" ,sbcl-jpl-queues)
- ("mgl-pax" ,sbcl-mgl-pax)
- ("iterate" ,sbcl-iterate)))
- ;; TODO: Tests are not evaluated properly.
- (native-inputs
- ;; For testing:
- `(("lisp-unit" ,sbcl-lisp-unit)
- ("simple-scanf" ,sbcl-simple-scanf)))
- (arguments
- `(#:tests? #f
- #:asd-file "cl-string-match.asd"))
- (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
- (description
- "@command{cl-strings} is a small, portable, dependency-free set of
-utilities that make it even easier to manipulate text in Common Lisp. It has
-100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
-
(define-public cl-string-match
(sbcl-package->cl-source-package sbcl-cl-string-match))
(base32
"0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
(build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ '(#:asd-systems '("queues"
+ "queues.simple-queue"
+ "queues.simple-cqueue"
+ "queues.priority-queue"
+ "queues.priority-cqueue")))
(home-page "https://github.com/oconnore/queues")
(synopsis "Common Lisp queue library")
(description
(define-public ecl-queues
(sbcl-package->ecl-package sbcl-queues))
-(define-public sbcl-queues.simple-queue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.simple-queue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)))
- (arguments
- `(#:asd-file "queues.simple-queue.asd"))
- (synopsis "Simple queue implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.simple-queue
- (sbcl-package->cl-source-package sbcl-queues.simple-queue))
-
-(define-public ecl-queues.simple-queue
- (sbcl-package->ecl-package sbcl-queues.simple-queue))
-
-(define-public sbcl-queues.simple-cqueue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.simple-cqueue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)
- ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- `(#:asd-file "queues.simple-cqueue.asd"))
- (synopsis "Thread safe queue implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.simple-cqueue
- (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
-
-(define-public ecl-queues.simple-cqueue
- (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
-
-(define-public sbcl-queues.priority-queue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.priority-queue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)))
- (arguments
- `(#:asd-file "queues.priority-queue.asd"))
- (synopsis "Priority queue (Fibonacci) implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.priority-queue
- (sbcl-package->cl-source-package sbcl-queues.priority-queue))
-
-(define-public ecl-queues.priority-queue
- (sbcl-package->ecl-package sbcl-queues.priority-queue))
-
-(define-public sbcl-queues.priority-cqueue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.priority-cqueue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)
- ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- `(#:asd-file "queues.priority-cqueue.asd"))
- (synopsis "Thread safe fibonacci priority queue implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.priority-cqueue
- (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
-
-(define-public ecl-queues.priority-cqueue
- (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
-
-(define sbcl-cffi-bootstrap
+(define-public sbcl-cffi
(package
- (name "sbcl-cffi-bootstrap")
+ (name "sbcl-cffi")
(version "0.21.0")
(source
(origin
(base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("libffi" ,libffi)
- ("alexandria" ,sbcl-alexandria)
+ `(("alexandria" ,sbcl-alexandria)
("babel" ,sbcl-babel)
+ ("libffi" ,libffi)
("trivial-features" ,sbcl-trivial-features)))
(native-inputs
- `(("pkg-config" ,pkg-config)))
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("pkg-config" ,pkg-config)
+ ("rt" ,sbcl-rt)))
(arguments
'(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
+ (add-after 'unpack 'fix-arm-support
+ (lambda _
+ ;; This is apparently deprecated since libffi-3.3.
+ (substitute* "libffi/libffi-types.lisp"
+ (("\\\(\\\(:unix64.*") ")\n"))
+ #t))
+ (add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
(substitute* "libffi/libffi.lisp"
(("libffi.so.7" all) (string-append
(assoc-ref inputs "libffi")
"/lib/" all)))
(substitute* "toolchain/c-toolchain.lisp"
- (("\"cc\"") (format #f "~S" (which "gcc")))))))
- #:asd-system-name "cffi"
- #:tests? #f))
+ (("\"cc\"") (format #f "~S" (which "gcc"))))))
+ (add-after 'build 'install-headers
+ (lambda* (#:key outputs #:allow-other-keys)
+ (install-file "grovel/common.h"
+ (string-append
+ (assoc-ref outputs "out")
+ "/include/grovel")))))
+ #:asd-files '("cffi.asd"
+ "cffi-toolchain.asd"
+ "cffi-grovel.asd"
+ "cffi-libffi.asd"
+ "cffi-uffi-compat.asd")
+ #:asd-systems '("cffi"
+ "cffi-libffi"
+ "cffi-uffi-compat")))
(home-page "https://common-lisp.net/project/cffi/")
(synopsis "Common Foreign Function Interface for Common Lisp")
(description "The Common Foreign Function Interface (CFFI)
package.")
(license license:expat)))
-(define-public sbcl-cffi-toolchain
- (package
- (inherit sbcl-cffi-bootstrap)
- (name "sbcl-cffi-toolchain")
- (inputs
- `(("libffi" ,libffi)
- ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
- ((#:asd-system-name _) #f)
- ((#:tests? _) #t)))))
-
-(define-public sbcl-cffi-libffi
- (package
- (inherit sbcl-cffi-toolchain)
- (name "sbcl-cffi-libffi")
- (inputs
- `(("cffi" ,sbcl-cffi-bootstrap)
- ("cffi-grovel" ,sbcl-cffi-grovel)
- ("trivial-features" ,sbcl-trivial-features)
- ("libffi" ,libffi)))))
-
-(define-public sbcl-cffi-grovel
- (package
- (inherit sbcl-cffi-toolchain)
- (name "sbcl-cffi-grovel")
- (inputs
- `(("libffi" ,libffi)
- ("cffi" ,sbcl-cffi-bootstrap)
- ("cffi-toolchain" ,sbcl-cffi-toolchain)
- ("alexandria" ,sbcl-alexandria)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'build 'install-headers
- (lambda* (#:key outputs #:allow-other-keys)
- (install-file "grovel/common.h"
- (string-append
- (assoc-ref outputs "out")
- "/include/grovel"))))))))))
-
-(define-public sbcl-cffi
- (package
- (inherit sbcl-cffi-toolchain)
- (name "sbcl-cffi")
- (inputs (package-inputs sbcl-cffi-bootstrap))
- (native-inputs
- `(("cffi-grovel" ,sbcl-cffi-grovel)
- ("cffi-libffi" ,sbcl-cffi-libffi)
- ("rt" ,sbcl-rt)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ,@(package-native-inputs sbcl-cffi-bootstrap)))))
-
(define-public cl-cffi
(sbcl-package->cl-source-package sbcl-cffi))
-(define-public sbcl-cffi-uffi-compat
- (package
- (inherit sbcl-cffi-toolchain)
- (name "sbcl-cffi-uffi-compat")
- (native-inputs
- `(,@(package-inputs sbcl-cffi-bootstrap))) ; For fix-paths phase
- (inputs
- `(("cffi" ,sbcl-cffi)))
- (synopsis "UFFI Compatibility Layer for CFFI")))
-
-(define-public cl-cffi-uffi-compat
- (sbcl-package->cl-source-package sbcl-cffi-uffi-compat))
+(define-public ecl-cffi
+ (sbcl-package->ecl-package sbcl-cffi))
(define-public sbcl-cl-sqlite
(package
`(("fiveam" ,sbcl-fiveam)
("bordeaux-threads" ,sbcl-bordeaux-threads)))
(arguments
- `(#:asd-file "sqlite.asd"
- #:asd-system-name "sqlite"
+ `(#:asd-systems '("sqlite")
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(define-public cl-sqlite
(sbcl-package->cl-source-package sbcl-cl-sqlite))
+(define-public ecl-cl-sqlite
+ (sbcl-package->ecl-package sbcl-cl-sqlite))
+
(define-public sbcl-parenscript
;; Source archives are overwritten on every release, we use the Git repo instead.
(let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
(define-public ecl-closer-mop
(sbcl-package->ecl-package sbcl-closer-mop))
-(define sbcl-cl-cffi-gtk-boot0
- (let ((commit "412d17214e092220c65a5660f5cbbd9cb69b8fe4"))
+(define-public sbcl-cl-cffi-gtk
+ (let ((commit "e9a46df65995d9a16e6c8dbdc1e09b775eb4a966"))
(package
- (name "sbcl-cl-cffi-gtk-boot0")
- (version (git-version "0.11.2" "1" commit))
+ (name "sbcl-cl-cffi-gtk")
+ (version (git-version "0.11.2" "2" commit))
(source
(origin
(method git-fetch)
(file-name (git-file-name "cl-cffi-gtk" version))
(sha256
(base32
- "0n997yhcnzk048nalx8ys62ja2ac8iv4mbn3mb55iapl0321hghn"))))
+ "04vix0gmqsj91lm975sx7jhlnz5gq1xf9jp873mp7c8frc5dk1jj"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
(inputs
- `(("iterate" ,sbcl-iterate)
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cairo" ,cairo)
("cffi" ,sbcl-cffi)
- ("trivial-features" ,sbcl-trivial-features)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("gdk-pixbuf" ,gdk-pixbuf)
("glib" ,glib)
- ("cairo" ,cairo)
+ ("gtk" ,gtk+)
+ ("iterate" ,sbcl-iterate)
("pango" ,pango)
- ("gdk-pixbuf" ,gdk-pixbuf)
- ("gtk" ,gtk+)))
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
(arguments
- `(#:phases
+ `(#:asd-files '("gtk/cl-cffi-gtk.asd"
+ "glib/cl-cffi-gtk-glib.asd"
+ "gobject/cl-cffi-gtk-gobject.asd"
+ "gio/cl-cffi-gtk-gio.asd"
+ "cairo/cl-cffi-gtk-cairo.asd"
+ "pango/cl-cffi-gtk-pango.asd"
+ "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
+ "gdk/cl-cffi-gtk-gdk.asd")
+ #:test-asd-file "test/cl-cffi-gtk-test.asd"
+ ;; TODO: Tests fail with memory fault.
+ ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
+ #:tests? #f
+ #:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
is a library for creating graphical user interfaces.")
(license license:lgpl3))))
-(define-public sbcl-cl-cffi-gtk-glib
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-glib")
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "glib/cl-cffi-gtk-glib.asd")))))
-
-(define-public sbcl-cl-cffi-gtk-gobject
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gobject")
- (inputs
- `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("closer-mop" ,sbcl-closer-mop)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "gobject/cl-cffi-gtk-gobject.asd")
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gobject")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t)))))))))
-
-(define-public sbcl-cl-cffi-gtk-gio
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gio")
- (inputs
- `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "gio/cl-cffi-gtk-gio.asd")
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gio")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t)))))))))
-
-(define-public sbcl-cl-cffi-gtk-cairo
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-cairo")
- (inputs
- `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "cairo/cl-cffi-gtk-cairo.asd")
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-cairo")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t)))))))))
-
-(define-public sbcl-cl-cffi-gtk-pango
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-pango")
- (inputs
- `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "pango/cl-cffi-gtk-pango.asd")
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-pango")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t)))))))))
-
-(define-public sbcl-cl-cffi-gtk-gdk-pixbuf
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
- (inputs
- `(("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd")
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gdk-pixbuf")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t)))))))))
-
-(define-public sbcl-cl-cffi-gtk-gdk
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gdk")
- (inputs
- `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
- ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
- ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
- ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "gdk/cl-cffi-gtk-gdk.asd")
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gdk")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t)))))))))
-
-(define-public sbcl-cl-cffi-gtk
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk")
- (inputs
- `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
- ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
- ((#:asd-file _ "") "gtk/cl-cffi-gtk.asd")
- ((#:test-asd-file _ "") "test/cl-cffi-gtk-test.asd")
- ;; TODO: Tests fail with memory fault.
- ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
- ((#:tests? _ #f) #f)
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t)))))))))
-
(define-public cl-cffi-gtk
(sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
+(define-public ecl-cl-cffi-gtk
+ (sbcl-package->ecl-package sbcl-cl-cffi-gtk))
+
(define-public sbcl-cl-webkit
- (let ((commit "6c905a5550b58a5b7602da5a087d7dafc5337122"))
+ (let ((commit "aecd76a2bcc7bfee049c91d94cc75f893800bf37"))
(package
(name "sbcl-cl-webkit")
- (version (git-version "2.4" "4" commit))
+ (version (git-version "2.4" "9" commit))
(source
(origin
(method git-fetch)
(file-name (git-file-name "cl-webkit" version))
(sha256
(base32
- "0017ijjflqqbgbj5bf7ffkyw5idhxc0ggly2qh5igf3kz886p9rh"))))
+ "1j2wvn19kz0bcg17qr9pc4xp6fgjy8zngdnnp5rpfxd25sli62yc"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("cffi" ,sbcl-cffi)
("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
("webkitgtk" ,webkitgtk)))
(arguments
- `(#:asd-file "webkit2/cl-webkit2.asd"
- #:asd-system-name "cl-webkit2"
+ `(#:asd-systems '("cl-webkit2")
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(define-public cl-webkit
(sbcl-package->cl-source-package sbcl-cl-webkit))
+(define-public ecl-cl-webkit
+ (sbcl-package->ecl-package sbcl-cl-webkit))
+
(define-public sbcl-lparallel
(package
(name "sbcl-lparallel")
(sbcl-package->ecl-package sbcl-cl-css))
(define-public sbcl-portable-threads
- (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
+ (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df"))
(package
(name "sbcl-portable-threads")
- (version (git-version "2.3" "1" commit))
+ (version (git-version "2.3" "2" commit))
(source
(origin
(method git-fetch)
(commit commit)))
(file-name (git-file-name "portable-threads" version))
(sha256
- (base32
- "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
+ (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs"))))
(build-system asdf-build-system/sbcl)
(arguments
`(;; Tests seem broken.
#:tests? #f))
(home-page "https://github.com/binghe/portable-threads")
- (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
+ (synopsis "Portable threads API for Common Lisp")
(description
"Portable Threads (and Scheduled and Periodic Functions) API for Common
Lisp (from GBBopen project).")
(define-public cl-portable-threads
(sbcl-package->cl-source-package sbcl-portable-threads))
-(define-public ecl-portable-threada
+(define-public ecl-portable-threads
(sbcl-package->ecl-package sbcl-portable-threads))
-(define sbcl-usocket-boot0
- ;; usocket's test rely on usocket-server which depends on usocket itself.
- ;; We break this cyclic dependency with -boot0 that packages usocket.
+(define-public sbcl-usocket
(package
- (name "sbcl-usocket-boot0")
+ (name "sbcl-usocket")
(version "0.8.3")
(source
(origin
(base32
"0x746wr2324l6bn7skqzgkzcbj5kd0zp2ck0c8rldrw0rzabg826"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
(inputs
- `(("split-sequence" ,sbcl-split-sequence)))
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("split-sequence" ,sbcl-split-sequence)))
(arguments
- `(#:tests? #f
- #:asd-system-name "usocket"))
+ `(#:tests? #f ; FIXME: Tests need network access?
+ #:asd-systems '("usocket"
+ "usocket-server")))
(home-page "https://common-lisp.net/project/usocket/")
- (synopsis "Universal socket library for Common Lisp (server side)")
+ (synopsis "Universal socket library for Common Lisp")
(description
"This library strives to provide a portable TCP/IP and UDP/IP socket
interface for as many Common Lisp implementations as possible, while keeping
the abstraction and portability layer as thin as possible.")
(license license:expat)))
-(define-public sbcl-usocket-server
- (package
- (inherit sbcl-usocket-boot0)
- (name "sbcl-usocket-server")
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("usocket" ,sbcl-usocket-boot0)))
- (arguments
- '(#:asd-system-name "usocket-server"))
- (synopsis "Universal socket library for Common Lisp (server side)")))
-
-(define-public cl-usocket-server
- (sbcl-package->cl-source-package sbcl-usocket-server))
-
-(define-public ecl-socket-server
- (sbcl-package->ecl-package sbcl-usocket-server))
-
-(define-public sbcl-usocket
- (package
- (inherit sbcl-usocket-boot0)
- (name "sbcl-usocket")
- (arguments
- ;; FIXME: Tests need network access?
- `(#:tests? #f))
- (native-inputs
- ;; Testing only.
- `(("usocket-server" ,sbcl-usocket-server)
- ("rt" ,sbcl-rt)))))
-
(define-public cl-usocket
(sbcl-package->cl-source-package sbcl-usocket))
(sbcl-package->ecl-package sbcl-s-xml-rpc))
(define-public sbcl-trivial-clipboard
- (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
+ (let ((commit "afcd3743b842f5a81fc86dba60f9db59970f49c5"))
(package
(name "sbcl-trivial-clipboard")
- (version (git-version "0.0.0.0" "2" commit))
+ (version (git-version "0.0.0.0" "3" commit))
(source
(origin
(method git-fetch)
(file-name (git-file-name "trivial-clipboard" version))
(sha256
(base32
- "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
+ "1qfbvkzmvkbqpc5s3sx31c5653sy6qlcixafgzd10qpykb843prr"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("xclip" ,xclip)))
(lambda* (#:key outputs #:allow-other-keys)
(let ((test-results (string-append (assoc-ref outputs "out")
"/share/common-lisp/"
- (%lisp-type) "-source"
+ (%lisp-type)
"/trivial-backtrace"
"/test-results")))
(when (file-exists? test-results)
(define-public cl-trivial-backtrace
(sbcl-package->cl-source-package sbcl-trivial-backtrace))
+(define-public ecl-trivial-backtrace
+ (sbcl-package->ecl-package sbcl-trivial-backtrace))
+
(define-public sbcl-rfc2388
(let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
(revision "1"))
(define-public cl-rfc2388
(sbcl-package->cl-source-package sbcl-rfc2388))
+(define-public ecl-rfc2388
+ (sbcl-package->ecl-package sbcl-rfc2388))
+
(define-public sbcl-md5
(package
(name "sbcl-md5")
(define-public cl-cl+ssl
(sbcl-package->cl-source-package sbcl-cl+ssl))
+(define-public ecl-cl+ssl
+ (sbcl-package->ecl-package sbcl-cl+ssl))
+
(define-public sbcl-kmrcl
- (let ((version "1.109.0")
- (commit "5260068b2eb735af6796740c2db4955afac21636")
+ (let ((version "1.111")
+ (commit "4a27407aad9deb607ffb8847630cde3d041ea25a")
(revision "1"))
(package
(name "sbcl-kmrcl")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
+ (base32 "06gx04mah5nc8w78s0j8628divbf1s5w7af8w7pvzb2d5mgvrbd2"))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
- ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
- '(#:tests? #f))
(inputs
`(("sbcl-rt" ,sbcl-rt)))
(home-page "http://files.kpe.io/kmrcl/")
(synopsis "General utilities for Common Lisp programs")
(description
"KMRCL is a collection of utilities used by a number of Kevin
-Rosenberg's CL packages.")
+Rosenberg's Common Lisp packages.")
(license license:llgpl))))
(define-public cl-kmrcl
(sbcl-package->cl-source-package sbcl-kmrcl))
+(define-public ecl-kmrcl
+ (sbcl-package->ecl-package sbcl-kmrcl))
+
(define-public sbcl-cl-base64
- (package
- (name "sbcl-cl-base64")
- (version "3.3.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://files.kpe.io/cl-base64/cl-base64-"
- version ".tar.gz"))
- (sha256
- (base32 "0pl4zwn5bf18dm8fh1kn1yshaa6kpmfrjyb33z9mq4raqmj3xpv2"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
- ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
- ;; to toplevel
- '(#:tests? #f))
- (inputs
- `(("sbcl-ptester" ,sbcl-ptester)
- ("sbcl-kmrcl" ,sbcl-kmrcl)))
- (home-page "http://files.kpe.io/cl-base64/")
- (synopsis
- "Common Lisp package to encode and decode base64 with URI support")
- (description
- "This package provides highly optimized base64 encoding and decoding.
+ ;; 3.3.4 tests are broken, upstream fixes them.
+ (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a"))
+ (package
+ (name "sbcl-cl-base64")
+ (version (git-version "3.3.4" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/cl-base64.git/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "12jj54h0fs6n237cvnp8v6hn0imfksammq22ys6pi0gwz2w47rbj"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs ; For tests.
+ `(("sbcl-ptester" ,sbcl-ptester)
+ ("sbcl-kmrcl" ,sbcl-kmrcl)))
+ (home-page "http://files.kpe.io/cl-base64/")
+ (synopsis
+ "Common Lisp package to encode and decode base64 with URI support")
+ (description
+ "This package provides highly optimized base64 encoding and decoding.
Besides conversion to and from strings, integer conversions are supported.
Encoding with Uniform Resource Identifiers is supported by using a modified
encoding table that uses only URI-compatible characters.")
- (license license:bsd-3)))
+ (license license:bsd-3))))
(define-public cl-base64
(sbcl-package->cl-source-package sbcl-cl-base64))
+(define-public ecl-cl-base64
+ (sbcl-package->ecl-package sbcl-cl-base64))
+
(define-public sbcl-chunga
(package
(name "sbcl-chunga")
(define-public cl-chunga
(sbcl-package->cl-source-package sbcl-chunga))
+(define-public ecl-chunga
+ (sbcl-package->ecl-package sbcl-chunga))
+
(define-public sbcl-cl-who
(let ((version "1.1.4")
(commit "2c08caa4bafba720409af9171feeba3f32e86d32")
as good or bad as the next one.")
(license license:bsd-2))))
-(define-public cl-cl-who
+(define-public cl-who
(sbcl-package->cl-source-package sbcl-cl-who))
+(define-public ecl-cl-who
+ (sbcl-package->ecl-package sbcl-cl-who))
+
(define-public sbcl-chipz
(let ((version "0.8")
(commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
(define-public cl-chipz
(sbcl-package->cl-source-package sbcl-chipz))
+(define-public ecl-chipz
+ (sbcl-package->ecl-package sbcl-chipz))
+
(define-public sbcl-drakma
(package
(name "sbcl-drakma")
(define-public cl-hunchentoot
(sbcl-package->cl-source-package sbcl-hunchentoot))
+(define-public ecl-hunchentoot
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-hunchentoot))
+ (arguments
+ ;; Tests fail on ECL with 'Socket error in "socket": EINVAL'.
+ '(#:tests? #f))))
+
(define-public sbcl-trivial-types
(package
(name "sbcl-trivial-types")
(define-public cl-trivial-types
(sbcl-package->cl-source-package sbcl-trivial-types))
-(define-public sbcl-cl-syntax
- (package
- (name "sbcl-cl-syntax")
- (version "0.0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m2ym/cl-syntax")
- (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
- (file-name (git-file-name "cl-syntax" version))
- (sha256
- (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-syntax.asd"
- #:asd-system-name "cl-syntax"))
- (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
- ("sbcl-named-readtables" ,sbcl-named-readtables)))
- (home-page "https://github.com/m2ym/cl-syntax")
- (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
- (description
- "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
- (license license:llgpl)))
-
-(define-public cl-syntax
- (sbcl-package->cl-source-package sbcl-cl-syntax))
+(define-public ecl-trivial-types
+ (sbcl-package->ecl-package sbcl-trivial-types))
(define-public sbcl-cl-annot
(let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
(sha256
(base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-annot.asd"
- #:asd-system-name "cl-annot"))
(inputs
`(("sbcl-alexandria" ,sbcl-alexandria)))
(home-page "https://github.com/m2ym/cl-annot")
(define-public cl-annot
(sbcl-package->cl-source-package sbcl-cl-annot))
-(define-public sbcl-cl-syntax-annot
- (package
- (inherit sbcl-cl-syntax)
- (name "sbcl-cl-syntax-annot")
- (arguments
- '(#:asd-file "cl-syntax-annot.asd"
- #:asd-system-name "cl-syntax-annot"))
- (inputs
- `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
- ("sbcl-cl-annot" ,sbcl-cl-annot)))
- (synopsis "Common Lisp reader Syntax for cl-annot")
- (description
- "CL-SYNTAX provides reader syntax coventions for Common Lisp and
-@code{cl-annot}.")))
-
-(define-public cl-syntax-annot
- (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
+(define-public ecl-cl-annot
+ (sbcl-package->ecl-package sbcl-cl-annot))
-(define-public sbcl-cl-syntax-interpol
+(define-public sbcl-cl-syntax
(package
- (inherit sbcl-cl-syntax)
- (name "sbcl-cl-syntax-interpol")
- (arguments
- '(#:asd-file "cl-syntax-interpol.asd"
- #:asd-system-name "cl-syntax-interpol"))
+ (name "sbcl-cl-syntax")
+ (version "0.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-syntax")
+ (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+ (file-name (git-file-name "cl-syntax" version))
+ (sha256
+ (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
- ("sbcl-cl-interpol" ,sbcl-cl-interpol)))
- (synopsis "Common Lisp reader Syntax for cl-interpol")
+ `(("cl-annot" ,sbcl-cl-annot)
+ ("cl-interpol" ,sbcl-cl-interpol)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("trivial-types" ,sbcl-trivial-types)))
+ (arguments
+ '(#:asd-systems '("cl-syntax"
+ "cl-syntax-annot"
+ "cl-syntax-interpol")))
+ (home-page "https://github.com/m2ym/cl-syntax")
+ (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
(description
- "CL-SYNTAX provides reader syntax coventions for Common Lisp and
-@code{cl-interpol}.")))
+ "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
+ (license license:llgpl)))
-(define-public cl-syntax-interpol
- (sbcl-package->cl-source-package sbcl-cl-syntax-interpol))
+(define-public cl-syntax
+ (sbcl-package->cl-source-package sbcl-cl-syntax))
+
+(define-public ecl-cl-syntax
+ (sbcl-package->ecl-package sbcl-cl-syntax))
(define-public sbcl-cl-utilities
(let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
(base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:asd-file "cl-utilities.asd"
- #:asd-system-name "cl-utilities"
- #:phases
+ '(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
(define-public cl-utilities
(sbcl-package->cl-source-package sbcl-cl-utilities))
+(define-public ecl-cl-utilities
+ (sbcl-package->ecl-package sbcl-cl-utilities))
+
(define-public sbcl-map-set
(let ((commit "7b4b545b68b8")
(revision "1"))
(define-public cl-map-set
(sbcl-package->cl-source-package sbcl-map-set))
+(define-public ecl-map-set
+ (sbcl-package->ecl-package sbcl-map-set))
+
(define-public sbcl-quri
(let ((commit "b53231c5f19446dd7c24b15a249fefa45ae94f9a")
(revision "2"))
;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
;; required by #<SYSTEM "quri">. Why?
'(#:tests? #f))
- (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
+ (native-inputs `(("sbcl-prove" ,sbcl-prove)))
(inputs `(("sbcl-babel" ,sbcl-babel)
("sbcl-split-sequence" ,sbcl-split-sequence)
("sbcl-cl-utilities" ,sbcl-cl-utilities)
(define-public cl-quri
(sbcl-package->cl-source-package sbcl-quri))
+(define-public ecl-quri
+ (sbcl-package->ecl-package sbcl-quri))
+
(define-public sbcl-myway
(let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
(revision "1"))
;; by #<SYSTEM "myway">. Why?
'(#:tests? #f))
(native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
+ `(("sbcl-prove" ,sbcl-prove)))
(inputs
`(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
("sbcl-quri" ,sbcl-quri)
(define-public cl-myway
(sbcl-package->cl-source-package sbcl-myway))
+(define-public ecl-myway
+ (sbcl-package->ecl-package sbcl-myway))
+
(define-public sbcl-xsubseq
(let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
(revision "1"))
;; required by #<SYSTEM "xsubseq">. Why?
'(#:tests? #f))
(native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
+ `(("sbcl-prove" ,sbcl-prove)))
(home-page "https://github.com/fukamachi/xsubseq")
(synopsis "Efficient way to use \"subseq\"s in Common Lisp")
(description
(define-public cl-xsubseq
(sbcl-package->cl-source-package sbcl-xsubseq))
+(define-public ecl-xsubseq
+ (sbcl-package->ecl-package sbcl-xsubseq))
+
(define-public sbcl-smart-buffer
(let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
(revision "1"))
;; found, required by #<SYSTEM "smart-buffer">. Why?
`(#:tests? #f))
(native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
+ `(("sbcl-prove" ,sbcl-prove)))
(inputs
`(("sbcl-xsubseq" ,sbcl-xsubseq)
("sbcl-flexi-streams" ,sbcl-flexi-streams)))
(define-public cl-smart-buffer
(sbcl-package->cl-source-package sbcl-smart-buffer))
+(define-public ecl-smart-buffer
+ (sbcl-package->ecl-package sbcl-smart-buffer))
+
(define-public sbcl-fast-http
(let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
(revision "2"))
;; required by #<SYSTEM "fast-http">. Why?
`(#:tests? #f))
(native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)
- ("cl-syntax-interpol" ,sbcl-cl-syntax-interpol)))
+ `(("sbcl-prove" ,sbcl-prove)
+ ("cl-syntax" ,sbcl-cl-syntax)))
(inputs
`(("sbcl-alexandria" ,sbcl-alexandria)
("sbcl-proc-parse" ,sbcl-proc-parse)
(define-public cl-fast-http
(sbcl-package->cl-source-package sbcl-fast-http))
+(define-public ecl-fast-http
+ (sbcl-package->ecl-package sbcl-fast-http))
+
(define-public sbcl-static-vectors
(package
(name "sbcl-static-vectors")
(native-inputs
`(("sbcl-fiveam" ,sbcl-fiveam)))
(inputs
- `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
- ("sbcl-cffi" ,sbcl-cffi)))
+ `(("sbcl-cffi" ,sbcl-cffi)))
(build-system asdf-build-system/sbcl)
(home-page "https://github.com/sionescu/static-vectors")
(synopsis "Allocate SIMPLE-ARRAYs in static memory")
(define-public cl-marshal
(sbcl-package->cl-source-package sbcl-marshal))
+(define-public ecl-marshal
+ (sbcl-package->ecl-package sbcl-marshal))
+
(define-public sbcl-checkl
(let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
(revision "1"))
;; Error while trying to load definition for system checkl-test from
;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
;; is undefined.
- '(#:tests? #f))
+ '(#:asd-files '("checkl.asd")
+ #:tests? #f))
(native-inputs
`(("sbcl-fiveam" ,sbcl-fiveam)))
(inputs
(define-public cl-checkl
(sbcl-package->cl-source-package sbcl-checkl))
+(define-public ecl-checkl
+ (sbcl-package->ecl-package sbcl-checkl))
+
(define-public sbcl-fast-io
(let ((commit "603f4903dd74fb221859da7058ae6ca3853fe64b")
(revision "2"))
;; Error while trying to load definition for system fast-io-test from
;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
;; is undefined.
- '(#:tests? #f))
+ '(#:tests? #f
+ #:asd-files '("fast-io.asd")))
(native-inputs
`(("sbcl-fiveam" ,sbcl-fiveam)
("sbcl-checkl" ,sbcl-checkl)))
(define-public cl-fast-io
(sbcl-package->cl-source-package sbcl-fast-io))
+(define-public ecl-fast-io
+ (sbcl-package->ecl-package sbcl-fast-io))
+
(define-public sbcl-jonathan
(let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
(revision "1"))
;; required by #<SYSTEM "jonathan">. Why?
`(#:tests? #f))
(native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
+ `(("sbcl-prove" ,sbcl-prove)))
(inputs
`(("sbcl-cl-syntax" ,sbcl-cl-syntax)
- ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
("sbcl-fast-io" ,sbcl-fast-io)
("sbcl-proc-parse" ,sbcl-proc-parse)
("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
(define-public cl-jonathan
(sbcl-package->cl-source-package sbcl-jonathan))
+(define-public ecl-jonathan
+ (sbcl-package->ecl-package sbcl-jonathan))
+
(define-public sbcl-http-body
(let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
(revision "1"))
;; found, required by #<SYSTEM "http-body">. Why?
`(#:tests? #f))
(native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
+ `(("sbcl-prove" ,sbcl-prove)))
(inputs
`(("sbcl-fast-http" ,sbcl-fast-http)
("sbcl-jonathan" ,sbcl-jonathan)
(define-public cl-http-body
(sbcl-package->cl-source-package sbcl-http-body))
+(define-public ecl-http-body
+ (sbcl-package->ecl-package sbcl-http-body))
+
(define-public sbcl-circular-streams
(let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
(revision "1"))
(define-public cl-circular-streams
(sbcl-package->cl-source-package sbcl-circular-streams))
-(define-public sbcl-lack-request
+(define-public ecl-circular-streams
+ (sbcl-package->ecl-package sbcl-circular-streams))
+
+(define-public sbcl-lack
(let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
(revision "1"))
(package
- (name "sbcl-lack-request")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack")
- (commit commit)))
- (file-name (git-file-name "lack-request" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-request.asd"
- #:asd-system-name "lack-request"
- #:test-asd-file "t-lack-request.asd"
- ;; XXX: Component :CLACK-TEST not found
- #:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-quri" ,sbcl-quri)
- ("sbcl-http-body" ,sbcl-http-body)
- ("sbcl-circular-streams" ,sbcl-circular-streams)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
+ (name "sbcl-lack")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack")
+ (commit commit)))
+ (file-name (git-file-name "lack" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (inputs
+ `(("circular-streams" ,sbcl-circular-streams)
+ ("http-body" ,sbcl-http-body)
+ ("ironclad" ,sbcl-ironclad)
+ ("local-time" ,sbcl-local-time)
+ ("quri" ,sbcl-quri)
+ ("trivial-mimes" ,sbcl-trivial-mimes)))
+ (arguments
+ '(#:asd-systems '("lack"
+ "lack-request"
+ "lack-response"
+ "lack-component"
+ "lack-util"
+ "lack-middleware-backtrace"
+ "lack-middleware-static")
+ #:test-asd-file "t-lack.asd"
+ ;; XXX: Component :CLACK not found
+ #:tests? #f))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
constructed of modular components. It was originally a part of Clack, however
it's going to be rewritten as an individual project since Clack v2 with
performance and simplicity in mind.")
- (license license:llgpl))))
+ (license license:llgpl))))
+
+(define-public cl-lack
+ (sbcl-package->cl-source-package sbcl-lack))
-(define-public cl-lack-request
- (sbcl-package->cl-source-package sbcl-lack-request))
+(define-public ecl-lack
+ (sbcl-package->ecl-package sbcl-lack))
(define-public sbcl-local-time
(let ((commit "62792705245168d3fc2e04164b9a143477284142")
(define-public cl-local-time
(sbcl-package->cl-source-package sbcl-local-time))
-(define-public sbcl-lack-response
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-response")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-response.asd"
- #:asd-system-name "lack-response"
- ;; XXX: no tests for lack-response.
- #:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-quri" ,sbcl-quri)
- ("sbcl-http-body" ,sbcl-http-body)
- ("sbcl-circular-streams" ,sbcl-circular-streams)
- ("sbcl-local-time" ,sbcl-local-time)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-response
- (sbcl-package->cl-source-package sbcl-lack-response))
-
-(define-public sbcl-lack-component
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-component")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack")
- (commit commit)))
- (file-name (git-file-name "lack-component" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-component.asd"
- #:asd-system-name "lack-component"
- #:test-asd-file "t-lack-component.asd"
- ;; XXX: Component :LACK-TEST not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-component
- (sbcl-package->cl-source-package sbcl-lack-component))
-
-(define-public sbcl-lack-util
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-util")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack")
- (commit commit)))
- (file-name (git-file-name "lack-util" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-util.asd"
- #:asd-system-name "lack-util"
- #:test-asd-file "t-lack-util.asd"
- ;; XXX: Component :LACK-TEST not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (inputs
- `(("sbcl-ironclad" ,sbcl-ironclad)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-util
- (sbcl-package->cl-source-package sbcl-lack-util))
-
-(define-public sbcl-lack-middleware-backtrace
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-middleware-backtrace")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack")
- (commit commit)))
- (file-name (git-file-name "lack-middleware-backtrace" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-middleware-backtrace.asd"
- #:asd-system-name "lack-middleware-backtrace"
- #:test-asd-file "t-lack-middleware-backtrace.asd"
- ;; XXX: Component :LACK not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-middleware-backtrace
- (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
+(define-public ecl-local-time
+ (sbcl-package->ecl-package sbcl-local-time))
(define-public sbcl-trivial-mimes
(let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
(sha256
(base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after
- 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((anchor "#p\"/etc/mime.types\""))
- (substitute* "mime-types.lisp"
- ((anchor all)
- (string-append
- anchor "\n"
- "(asdf:system-relative-pathname :trivial-mimes "
- "\"../../share/common-lisp/" (%lisp-type)
- "-source/trivial-mimes/mime.types\")")))))))))
(native-inputs
`(("stefil" ,sbcl-hu.dwim.stefil)))
(inputs
(define-public ecl-trivial-mimes
(sbcl-package->ecl-package sbcl-trivial-mimes))
-(define-public sbcl-lack-middleware-static
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-middleware-static")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack")
- (commit commit)))
- (file-name (git-file-name "lack-middleware-static" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-middleware-static.asd"
- #:asd-system-name "lack-middleware-static"
- #:test-asd-file "t-lack-middleware-static.asd"
- ;; XXX: Component :LACK not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (inputs
- `(("sbcl-ironclad" ,sbcl-ironclad)
- ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
- ("sbcl-local-time" ,sbcl-local-time)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-middleware-static
- (sbcl-package->cl-source-package sbcl-lack-middleware-static))
-
-(define-public sbcl-lack
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack")
- (commit commit)))
- (file-name (git-file-name "lack" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:test-asd-file "t-lack.asd"
- ;; XXX: Component :CLACK not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (inputs
- `(("sbcl-lack-component" ,sbcl-lack-component)
- ("sbcl-lack-util" ,sbcl-lack-util)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack
- (sbcl-package->cl-source-package sbcl-lack))
-
(define-public sbcl-ningle
(let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
(revision "1"))
fasl-files)
#t)))))
(native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
+ `(("sbcl-prove" ,sbcl-prove)))
(inputs
`(("sbcl-cl-syntax" ,sbcl-cl-syntax)
- ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
("sbcl-myway" ,sbcl-myway)
- ("sbcl-lack-request" ,sbcl-lack-request)
- ("sbcl-lack-response" ,sbcl-lack-response)
- ("sbcl-lack-component" ,sbcl-lack-component)
+ ("sbcl-lack" ,sbcl-lack)
("sbcl-alexandria" ,sbcl-alexandria)
("sbcl-babel" ,sbcl-babel)))
(home-page "https://8arrow.org/ningle/")
(define-public cl-ningle
(sbcl-package->cl-source-package sbcl-ningle))
+(define-public ecl-ningle
+ (sbcl-package->ecl-package sbcl-ningle))
+
(define-public sbcl-cl-fastcgi
(let ((commit "d576d20eeb12f225201074b28934ba395b15781a")
(revision "1"))
(let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
(revision "1"))
(package
- (name "sbcl-clack")
- (version (git-version "2.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/clack")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("sbcl-lack" ,sbcl-lack)
- ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
- ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
- (home-page "https://github.com/fukamachi/clack")
- (synopsis "Web Application Environment for Common Lisp")
- (description
- "Clack is a web application environment for Common Lisp inspired by
+ (name "sbcl-clack")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/clack")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-fastcgi" ,sbcl-cl-fastcgi)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("hunchentoot" ,sbcl-hunchentoot)
+ ("lack" ,sbcl-lack)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("usocket" ,sbcl-usocket)
+ ("quri" ,sbcl-quri)))
+ (arguments
+ '(#:asd-systems '("clack"
+ "clack-handler-fcgi"
+ "clack-socket"
+ "clack-handler-hunchentoot")))
+ (home-page "https://github.com/fukamachi/clack")
+ (synopsis "Web Application Environment for Common Lisp")
+ (description
+ "Clack is a web application environment for Common Lisp inspired by
Python's WSGI and Ruby's Rack.")
- (license license:llgpl))))
+ (license license:llgpl))))
(define-public cl-clack
(sbcl-package->cl-source-package sbcl-clack))
+(define-public ecl-clack
+ (sbcl-package->ecl-package sbcl-clack))
+
(define-public sbcl-log4cl
(let ((commit "611e094458504b938d49de904eab141285328c7c")
(revision "1"))
(base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-file "parse-declarations-1.0.asd"
- #:asd-system-name "parse-declarations-1.0"))
+ `(#:asd-systems '("parse-declarations-1.0")))
(home-page "https://common-lisp.net/project/parse-declarations/")
(synopsis "Parse, filter, and build declarations")
(description
;; MIT
(license license:expat))))
-(define-public cl-cl-quickcheck
+(define-public cl-quickcheck
(sbcl-package->cl-source-package sbcl-cl-quickcheck))
(define-public ecl-cl-quickcheck
(inputs
`(("python" ,python)
("sbcl-cffi" ,sbcl-cffi)
- ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
("sbcl-alexandria" , sbcl-alexandria)
("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
(arguments
;; Guix incorrectly assumes the "8" is part of the version
;; number and lobs it off.
- `(#:asd-file "trivial-utf-8.asd"
- #:asd-system-name "trivial-utf-8"))
+ `(#:asd-systems '("trivial-utf-8")))
(build-system asdf-build-system/sbcl)
(synopsis "UTF-8 input/output library")
(description
(define-public ecl-swap-bytes
(sbcl-package->ecl-package sbcl-swap-bytes))
-(define-public sbcl-iolib.asdf
+(define-public sbcl-iolib
;; Latest release is from June 2017.
(let ((commit "7f5ea3a8457a29d224b24653c2b3657fb1898021")
(revision "2"))
(package
- (name "sbcl-iolib.asdf")
- (build-system asdf-build-system/sbcl)
+ (name "sbcl-iolib")
(version (git-version "0.8.3" revision commit))
(home-page "https://github.com/sionescu/iolib")
(source
(sha256
(base32
"1bg5w7lm61hqk4b0svmri8a590q36z76jfa0sdgzb39r98c04w12"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)))
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("idna" ,sbcl-idna)
+ ("libfixposix" ,libfixposix)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("swap-bytes" ,sbcl-swap-bytes)))
(arguments
- '(#:asd-file "iolib.asdf.asd"))
- (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
+ '(#:asd-files '("iolib.asdf.asd"
+ "iolib.conf.asd"
+ "iolib.common-lisp.asd"
+ "iolib.base.asd"
+ "iolib.asd")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/syscalls/ffi-functions-unix.lisp"
+ (("\\(:default \"libfixposix\"\\)")
+ (string-append
+ "(:default \""
+ (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
+ ;; Socket tests need Internet access, disable them.
+ (substitute* "iolib.asd"
+ (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
+ "")))))))
+ (synopsis "Common Lisp I/O library")
(description "IOlib is to be a better and more modern I/O library than
the standard Common Lisp library. It contains a socket library, a DNS
resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
and @code{kqueue(2)}), a pathname library and file-system utilities.")
(license license:expat))))
-(define-public sbcl-iolib.conf
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.conf")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)))
- (arguments
- '(#:asd-file "iolib.conf.asd"))
- (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
-
-(define-public sbcl-iolib.common-lisp
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.common-lisp")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)))
- (arguments
- '(#:asd-file "iolib.common-lisp.asd"))
- (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
-
-(define-public sbcl-iolib.base
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.base")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)
- ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
- ("split-sequence" ,sbcl-split-sequence)))
- (arguments
- '(#:asd-file "iolib.base.asd"))
- (synopsis "Base package for IOLib, a Common Lisp I/O library")))
-
-(define-public sbcl-iolib.grovel
- (deprecated-package "sbcl-iolib.grovel" sbcl-cffi-grovel))
-
-(define sbcl-iolib+syscalls
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib+syscalls")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)
- ("cffi-grovel" ,sbcl-cffi-grovel)
- ("iolib.base" ,sbcl-iolib.base)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("idna" ,sbcl-idna)
- ("swap-bytes" ,sbcl-swap-bytes)
- ("libfixposix" ,libfixposix)
- ("cffi" ,sbcl-cffi)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- '(#:asd-file "iolib.asd"
- #:asd-system-name "iolib/syscalls"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/syscalls/ffi-functions-unix.lisp"
- (("\\(:default \"libfixposix\"\\)")
- (string-append
- "(:default \""
- (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
- ;; Socket tests need Internet access, disable them.
- (substitute* "iolib.asd"
- (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
- "")))))))
- (synopsis "Common Lisp I/O library")))
-
-(define sbcl-iolib+multiplex
- (package
- (inherit sbcl-iolib+syscalls)
- (name "sbcl-iolib+multiplex")
- (inputs
- `(("iolib+syscalls" ,sbcl-iolib+syscalls)
- ,@(package-inputs sbcl-iolib+syscalls)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
- ((#:asd-system-name _) "iolib/multiplex")))))
-
-(define sbcl-iolib+streams
- (package
- (inherit sbcl-iolib+syscalls)
- (name "sbcl-iolib+streams")
- (inputs
- `(("iolib+multiplex" ,sbcl-iolib+multiplex)
- ,@(package-inputs sbcl-iolib+syscalls)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
- ((#:asd-system-name _) "iolib/streams")))))
-
-(define sbcl-iolib+sockets
- (package
- (inherit sbcl-iolib+syscalls)
- (name "sbcl-iolib+sockets")
- (inputs
- `(("iolib+syscalls" ,sbcl-iolib+syscalls)
- ("iolib+streams" ,sbcl-iolib+streams)
- ,@(package-inputs sbcl-iolib+syscalls)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
- ((#:asd-system-name _) "iolib/sockets")))))
-
-(define-public sbcl-iolib
- (package
- (inherit sbcl-iolib+syscalls)
- (name "sbcl-iolib")
- (inputs
- `(("iolib+multiplex" ,sbcl-iolib+multiplex)
- ("iolib+streams" ,sbcl-iolib+streams)
- ("iolib+sockets" ,sbcl-iolib+sockets)
- ,@(package-inputs sbcl-iolib+syscalls)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib+syscalls)
- ((#:asd-system-name _) "iolib")))))
-
(define-public cl-iolib
(let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
(package
`(("libfixposix" ,libfixposix)
,@(package-propagated-inputs parent))))))
+(define-public ecl-iolib
+ (sbcl-package->ecl-package sbcl-iolib))
+
(define-public sbcl-ieee-floats
(let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
(revision "1"))
(define-public cl-ieee-floats
(sbcl-package->cl-source-package sbcl-ieee-floats))
+(define-public ecl-ieee-floats
+ (sbcl-package->ecl-package sbcl-ieee-floats))
+
(define sbcl-closure-common
(let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
(revision "1"))
;; TODO: License?
(license #f))))
-(define-public sbcl-cxml+xml
+(define-public sbcl-cxml
(let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
(revision "1"))
(package
- (name "sbcl-cxml+xml")
- (build-system asdf-build-system/sbcl)
+ (name "sbcl-cxml")
(version (git-version "0.0.0" revision commit))
- (home-page "https://common-lisp.net/project/cxml/")
(source
(origin
(method git-fetch)
(sha256
(base32
"13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/xml"))
- (synopsis "Common Lisp XML parser")
- (description "CXML implements a namespace-aware, validating XML 1.0
-parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
-offered, one SAX-like, the other similar to StAX.")
- (license license:llgpl))))
-
-(define sbcl-cxml+dom
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml+dom")
+ (build-system asdf-build-system/sbcl)
(inputs
`(("closure-common" ,sbcl-closure-common)
("puri" ,sbcl-puri)
- ("cxml+xml" ,sbcl-cxml+xml)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/dom"))))
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Common Lisp XML parser")
+ (description "CXML implements a namespace-aware, validating XML 1.0
+parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
+offered, one SAX-like, the other similar to StAX.")
+ (home-page "https://common-lisp.net/project/cxml/")
+ (license license:llgpl))))
-(define sbcl-cxml+klacks
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml+klacks")
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("cxml+xml" ,sbcl-cxml+xml)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/klacks"))))
+(define-public cl-cxml
+ (sbcl-package->cl-source-package sbcl-cxml))
-(define sbcl-cxml+test
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml+test")
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("cxml+xml" ,sbcl-cxml+xml)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/test"))))
-
-(define-public sbcl-cxml
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml")
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("cxml+dom" ,sbcl-cxml+dom)
- ("cxml+klacks" ,sbcl-cxml+klacks)
- ("cxml+test" ,sbcl-cxml+test)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml"
- #:phases
- (modify-phases %standard-phases
- (add-after 'build 'install-dtd
- (lambda* (#:key outputs #:allow-other-keys)
- (install-file "catalog.dtd"
- (string-append
- (assoc-ref outputs "out")
- "/lib/" (%lisp-type))))))))))
-
-(define-public cl-cxml
- (sbcl-package->cl-source-package sbcl-cxml))
+(define-public ecl-cxml
+ (sbcl-package->ecl-package sbcl-cxml))
(define-public sbcl-cl-reexport
(let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
(define-public cl-reexport
(sbcl-package->cl-source-package sbcl-cl-reexport))
+(define-public ecl-cl-reexport
+ (sbcl-package->ecl-package sbcl-cl-reexport))
+
(define-public sbcl-cl-cookie
(let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
(revision "1"))
("cl-ppcre" ,sbcl-cl-ppcre)
("local-time" ,sbcl-local-time)))
(native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)
- ("prove" ,sbcl-prove)))
+ `(("prove" ,sbcl-prove)))
(arguments
;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
`(#:tests? #f))
(define-public cl-cookie
(sbcl-package->cl-source-package sbcl-cl-cookie))
+(define-public ecl-cl-cookie
+ (sbcl-package->ecl-package sbcl-cl-cookie))
+
(define-public sbcl-dexador
(let ((commit "953090f04c4d1a9ee6632b90133cdc297b68badc")
(revision "1"))
("alexandria" ,sbcl-alexandria)))
(native-inputs
`(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)
- ("lack-request" ,sbcl-lack-request)
+ ("lack" ,sbcl-lack)
("clack" ,sbcl-clack)
("babel" ,sbcl-babel)
("alexandria" ,sbcl-alexandria)
(define-public cl-lisp-namespace
(sbcl-package->cl-source-package sbcl-lisp-namespace))
+(define-public ecl-lisp-namespace
+ (sbcl-package->ecl-package sbcl-lisp-namespace))
+
(define-public sbcl-trivial-cltl2
(let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
(revision "2"))
(define-public cl-trivial-cltl2
(sbcl-package->cl-source-package sbcl-trivial-cltl2))
+(define-public ecl-trivial-cltl2
+ (sbcl-package->ecl-package sbcl-trivial-cltl2))
+
(define-public sbcl-introspect-environment
(let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
(revision "1"))
(define-public cl-introspect-environment
(sbcl-package->cl-source-package sbcl-introspect-environment))
+(define-public ecl-introspect-environment
+ (sbcl-package->ecl-package sbcl-introspect-environment))
+
(define-public sbcl-type-i
(let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
(revision "2"))
(define-public cl-type-i
(sbcl-package->cl-source-package sbcl-type-i))
+(define-public ecl-type-i
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-type-i))
+ (arguments
+ ;; The tests get stuck indefinitly
+ '(#:tests? #f))))
+
(define-public sbcl-optima
(let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
(revision "1"))
(define-public cl-optima
(sbcl-package->cl-source-package sbcl-optima))
+(define-public ecl-optima
+ (sbcl-package->ecl-package sbcl-optima))
+
(define-public sbcl-fare-quasiquote
(let ((commit "640d39a0451094071b3e093c97667b3947f43639")
(revision "1"))
(sha256
(base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
(inputs
- `(("fare-utils" ,sbcl-fare-utils)))
+ `(("fare-utils" ,sbcl-fare-utils)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("optima" ,sbcl-optima)))
(arguments
;; XXX: Circular dependencies: Tests depend on subsystems,
;; which depend on the main systems.
`(#:tests? #f
+ #:asd-systems '("fare-quasiquote"
+ "fare-quasiquote-extras")
#:phases
(modify-phases %standard-phases
;; XXX: Require 1.0.0 version of fare-utils, and we package some
(lambda _
(substitute* "fare-quasiquote.asd"
(("\\(:version \"fare-utils\" \"1.0.0\"\\)")
- "\"fare-utils\"")))))))
+ "\"fare-utils\""))
+ (substitute* "fare-quasiquote-optima.asd"
+ (("\\(:version \"optima\" \"1\\.0\"\\)")
+ "\"optima\""))
+ #t)))))
(synopsis "Pattern-matching friendly implementation of quasiquote")
(description "The main purpose of this n+2nd reimplementation of
quasiquote is enable matching of quasiquoted patterns, using Optima or
(define-public cl-fare-quasiquote
(sbcl-package->cl-source-package sbcl-fare-quasiquote))
-(define-public sbcl-fare-quasiquote-optima
- (package
- (inherit sbcl-fare-quasiquote)
- (name "sbcl-fare-quasiquote-optima")
- (inputs
- `(("optima" ,sbcl-optima)
- ("fare-quasiquote" ,sbcl-fare-quasiquote)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-requirement
- (lambda _
- (substitute* "fare-quasiquote-optima.asd"
- (("\\(:version \"optima\" \"1\\.0\"\\)")
- "\"optima\""))
- #t)))))))
-
-(define-public cl-fare-quasiquote-optima
- (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
-
-(define-public sbcl-fare-quasiquote-readtable
- (package
- (inherit sbcl-fare-quasiquote)
- (name "sbcl-fare-quasiquote-readtable")
- (inputs
- `(("fare-quasiquote" ,sbcl-fare-quasiquote)
- ("named-readtables" ,sbcl-named-readtables)))
- (description "The main purpose of this n+2nd reimplementation of
-quasiquote is enable matching of quasiquoted patterns, using Optima or
-Trivia.
-
-This package uses fare-quasiquote with named-readtable.")))
-
-(define-public cl-fare-quasiquote-readtable
- (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
-
-(define-public sbcl-fare-quasiquote-extras
- (package
- (inherit sbcl-fare-quasiquote)
- (name "sbcl-fare-quasiquote-extras")
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("fare-quasiquote-optima" ,sbcl-fare-quasiquote-optima)
- ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (replace 'build
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (lib (string-append out "/lib/" (%lisp-type))))
- (mkdir-p lib)
- (install-file "fare-quasiquote-extras.asd" lib)
- (make-file-writable
- (string-append lib "/fare-quasiquote-extras.asd"))
- #t))))))
- (description "This library combines @code{fare-quasiquote-readtable} and
-@code{fare-quasiquote-optima}.")))
-
-(define-public cl-fare-quasiquote-extras
- (package
- (inherit cl-fare-quasiquote)
- (name "cl-fare-quasiquote-extras")
- (build-system asdf-build-system/source)
- (propagated-inputs
- `(("fare-quasiquote" ,cl-fare-quasiquote)
- ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
- ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
- (description "This library combines @code{fare-quasiquote-readtable} and
-@code{fare-quasiquote-optima}.")))
+(define-public ecl-fare-quasiquote
+ (sbcl-package->ecl-package sbcl-fare-quasiquote))
-(define-public sbcl-trivia.level0
+;;; Split the trivia package in two to work around the circular dependency
+;;; between guicho271828/trivia and guicho271828/type-i.
+(define-public sbcl-trivia.trivial
(let ((commit "37698b47a14c2007630468de7a993694ef7bd475")
(revision "2"))
(package
- (name "sbcl-trivia.level0")
- (build-system asdf-build-system/sbcl)
+ (name "sbcl-trivia.trivial")
(version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/guicho271828/trivia")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/guicho271828/trivia")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "trivia" version))
(sha256
(base32
"0rsbwbw3ipxxgr6zzhci12nilq8zky475kmhz1rcxy4q8a85vn72"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)))
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("trivial-cltl2" ,sbcl-trivial-cltl2)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("trivia.balland2006.asd"
+ "trivia.ppcre.asd"
+ "trivia.quasiquote.asd"
+ "trivia.cffi.asd"
+ "trivia.asd"
+ "trivia.test.asd"))
+ #t)))))
(synopsis "Pattern matching in Common Lisp")
(description "Trivia is a pattern matching compiler that is compatible
with Optima, another pattern matching library for Common Lisp. It is meant to
be faster and more extensible than Optima.")
+ (home-page "https://github.com/guicho271828/trivia")
(license license:llgpl))))
-(define-public sbcl-trivia.level1
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.level1")
- (inputs
- `(("trivia.level0" ,sbcl-trivia.level0)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the core patterns of Trivia.")))
-
-(define-public sbcl-trivia.level2
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.level2")
- (inputs
- `(("trivia.level1" ,sbcl-trivia.level1)
- ("lisp-namespace" ,sbcl-lisp-namespace)
- ("trivial-cltl2" ,sbcl-trivial-cltl2)
- ("closer-mop" ,sbcl-closer-mop)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains a non-optimized pattern matcher compatible with Optima,
-with extensible optimizer interface.")))
-
-(define-public sbcl-trivia.trivial
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.trivial")
- (inputs
- `(("trivia.level2" ,sbcl-trivia.level2)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the base level system of Trivia with a trivial optimizer.")))
-
-(define-public sbcl-trivia.balland2006
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.balland2006")
- (inputs
- `(("trivia.trivial" ,sbcl-trivia.trivial)
- ("iterate" ,sbcl-iterate)
- ("type-i" ,sbcl-type-i)
- ("alexandria" ,sbcl-alexandria)))
- (arguments
- ;; Tests are done in trivia itself.
- `(#:tests? #f))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the base level system of Trivia with a trivial optimizer.")))
-
-(define-public sbcl-trivia.ppcre
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.ppcre")
- (inputs
- `(("trivia.trivial" ,sbcl-trivia.trivial)
- ("cl-ppcre" ,sbcl-cl-ppcre)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the PPCRE extension.")))
-
-(define-public sbcl-trivia.quasiquote
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.quasiquote")
- (inputs
- `(("trivia.trivial" ,sbcl-trivia.trivial)
- ("fare-quasiquote" ,sbcl-fare-quasiquote)
- ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the fare-quasiquote extension.")))
-
-(define-public sbcl-trivia.cffi
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.cffi")
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("trivia.trivial" ,sbcl-trivia.trivial)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
+(define-public cl-trivia.trivial
+ (sbcl-package->cl-source-package sbcl-trivia.trivial))
-This system contains the CFFI foreign slot access extension.")))
+(define-public ecl-trivia.trivial
+ (sbcl-package->ecl-package sbcl-trivia.trivial))
(define-public sbcl-trivia
(package
- (inherit sbcl-trivia.level0)
+ (inherit sbcl-trivia.trivial)
(name "sbcl-trivia")
- (inputs
- `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
(native-inputs
`(("fiveam" ,sbcl-fiveam)
- ("trivia.ppcre" ,sbcl-trivia.ppcre)
- ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
- ("trivia.cffi" ,sbcl-trivia.cffi)
("optima" ,sbcl-optima)))
- (arguments
- `(#:test-asd-file "trivia.test.asd"))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.")))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("fare-quasiquote" ,sbcl-fare-quasiquote)
+ ("iterate" ,sbcl-iterate)
+ ("trivia.trivial" ,sbcl-trivia.trivial)
+ ("type-i" ,sbcl-type-i)))
+ (arguments
+ '(#:asd-systems '("trivia"
+ "trivia.ppcre"
+ "trivia.quasiquote"
+ "trivia.cffi")
+ #:test-asd-file "trivia.test.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("trivia.level0.asd"
+ "trivia.level1.asd"
+ "trivia.level2.asd"
+ "trivia.trivial.asd"))
+ #t)))))))
(define-public cl-trivia
(sbcl-package->cl-source-package sbcl-trivia))
+(define-public ecl-trivia
+ (sbcl-package->ecl-package sbcl-trivia))
+
(define-public sbcl-mk-string-metrics
(package
(name "sbcl-mk-string-metrics")
(define-public cl-mk-string-metrics
(sbcl-package->cl-source-package sbcl-mk-string-metrics))
+(define-public ecl-mk-string-metrics
+ (sbcl-package->ecl-package sbcl-mk-string-metrics))
+
(define-public sbcl-cl-str
- (let ((commit "eb480f283e28802d67b35bf916506701152f9a2a"))
- (package
- (name "sbcl-cl-str")
- (version (git-version "0.17" "1" commit))
- (home-page "https://github.com/vindarel/cl-str")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (sha256
- (base32 "1hpq5m8zjjnzns370zy27z2vcm1p8n2ka5ij2x67gyc9amz9vla0"))
- (file-name (git-file-name name version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
- ("cl-change-case" ,sbcl-cl-change-case)))
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
- (arguments
- `(#:asd-file "str.asd"
- #:asd-system-name "str"
- #:test-asd-file "str.test.asd"))
- (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
- (description "A modern and consistent Common Lisp string manipulation
+ (package
+ (name "sbcl-cl-str")
+ (version "0.19")
+ (home-page "https://github.com/vindarel/cl-str")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (sha256
+ (base32 "1jyza2jhn7w6fl4w87pv0m87z5ia48m6dqw12k0mdh7l3mgjq839"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
+ ("cl-change-case" ,sbcl-cl-change-case)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (arguments
+ `(#:asd-systems '("str")
+ #:test-asd-file "str.test.asd"))
+ (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
+ (description "A modern and consistent Common Lisp string manipulation
library that focuses on modernity, simplicity and discoverability:
@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
@code{str:concat strings} instead of an unusual format construct; one
discoverable library instead of many; consistency and composability, where
@code{s} is always the last argument, which makes it easier to feed pipes and
arrows.")
- (license license:expat))))
+ (license license:expat)))
(define-public cl-str
(sbcl-package->cl-source-package sbcl-cl-str))
+(define-public ecl-cl-str
+ (sbcl-package->ecl-package sbcl-cl-str))
+
(define-public sbcl-cl-xmlspam
(let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
(package
power of CXML is available when necessary.")
(license license:bsd-3))))
-;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
-;; asdf-build-system/sbcl as of 2019-08-02. We should fix
-;; asdf-build-system/sbcl.
-(define-public cl-dbus
+(define-public cl-xmlspam
+ (sbcl-package->cl-source-package sbcl-cl-xmlspam))
+
+(define-public ecl-cl-xmlspam
+ (sbcl-package->ecl-package sbcl-cl-xmlspam))
+
+(define-public sbcl-dbus
(let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
(revision "1"))
(package
- (name "cl-dbus")
- (build-system asdf-build-system/source)
+ (name "sbcl-dbus")
(version (git-version "20190408" revision commit))
(home-page "https://github.com/death/dbus")
(source
(sha256
(base32
"0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
- ;; Inputs must be propagated or else packages depending on this won't
- ;; have the necessary packages.
- (propagated-inputs
+ (build-system asdf-build-system/sbcl)
+ (inputs
`(("alexandria" ,sbcl-alexandria)
("trivial-garbage" ,sbcl-trivial-garbage)
("babel" ,sbcl-babel)
objects as well as send and notify other objects connected to a bus.")
(license license:bsd-2))))
+(define-public cl-dbus
+ (sbcl-package->cl-source-package sbcl-dbus))
+
+(define-public ecl-dbus
+ (sbcl-package->ecl-package sbcl-dbus))
+
(define-public sbcl-cl-hooks
(let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
(revision "1"))
"1fh8r7kf8s3hvqdg6b71b8p7w3v2kkga9bw8j3qqdxhzr6anpm0b"))))
(inputs
`(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("usocket" ,sbcl-usocket)
- ("usocket-server" ,sbcl-usocket-server)))
+ ("usocket" ,sbcl-usocket)))
(synopsis "Common Lisp abstraction layer over platform dependent functionality")
(description "@code{s-sysdeps} is an abstraction layer over platform
dependent functionality. This simple package is used as a building block in a
(sbcl-package->ecl-package sbcl-s-sysdeps))
(define-public sbcl-cl-prevalence
- (let ((commit "1e5f030d94237b33d20947a2f6c194abedb10727")
- (revision "3"))
+ (let ((commit "5a76be036092ed6c18cb695a9e03bce87e21b840")
+ (revision "4"))
(package
(name "sbcl-cl-prevalence")
(build-system asdf-build-system/sbcl)
(file-name (git-file-name name version))
(sha256
(base32
- "13yb8lv2aap5wvqa6hw7ms31xnax58f4m2nxifkssrzkb2w2qf29"))))
+ "050h6hwv8f16b5v6fzba8zmih92hgaaq27i2x9wv1iib41gbia3r"))))
(inputs
`(("s-sysdeps" ,sbcl-s-sysdeps)
("s-xml" ,sbcl-s-xml)))
"0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("local-time" ,sbcl-local-time)))
+ `(("local-time" ,sbcl-local-time)
+ ("series" ,sbcl-series)))
+ (arguments
+ '(#:asd-systems '("periods"
+ "periods-series")))
(synopsis "Common Lisp library for manipulating date/time objects")
(description
"Periods is a Common Lisp library providing a set of utilities for
(define-public ecl-periods
(sbcl-package->ecl-package sbcl-periods))
-(define-public sbcl-periods-series
- (package
- (inherit sbcl-periods)
- (name "sbcl-periods-series")
- (inputs
- `(("periods" ,sbcl-periods)
- ("series" ,sbcl-series)))
- (arguments
- '(#:asd-file "periods-series.asd"
- #:asd-system-name "periods-series"))
- (description
- "Periods-series is an extension of the periods Common Lisp library
-providing functions compatible with the series Common Lisp library.")))
-
-(define-public cl-periods-series
- (sbcl-package->cl-source-package sbcl-periods-series))
-
-(define-public ecl-periods-series
- (sbcl-package->ecl-package sbcl-periods-series))
-
(define-public sbcl-metatilities-base
(let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
(revision "1"))
(inputs
`(("metatilities-base" ,sbcl-metatilities-base)))
(arguments
- '(#:phases
+ '(#:asd-files '("cl-containers.asd")
+ #:phases
(modify-phases %standard-phases
(add-after 'unpack 'relax-version-checks
(lambda _
(define-public ecl-xlunit
(sbcl-package->ecl-package sbcl-xlunit))
-(define-public sbcl-fprog
+(define-public sbcl-cambl
(let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
(revision "1"))
(package
- (name "sbcl-fprog")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cambl")
+ (version (git-version "4.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/jwiegley/cambl")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cambl" version))
(sha256
- (base32
- "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
+ (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Functional programming utilities for Common Lisp")
- (description
- "@code{fprog} is a Common Lisp library allowing iteration over
-immutable lists sharing identical sublists.")
- (home-page "https://github.com/jwiegley/cambl")
- (license license:bsd-3))))
-
-(define-public cl-fprog
- (sbcl-package->cl-source-package sbcl-fprog))
-
-(define-public ecl-fprog
- (sbcl-package->ecl-package sbcl-fprog))
-
-(define-public sbcl-cambl
- (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
- (revision "1"))
- (package
- (inherit sbcl-fprog)
- (name "sbcl-cambl")
- (version (git-version "4.0.0" revision commit))
(native-inputs
`(("xlunit" ,sbcl-xlunit)))
(inputs
`(("alexandria" ,sbcl-alexandria)
("cl-containers" ,sbcl-cl-containers)
("local-time" ,sbcl-local-time)
- ("periods" ,sbcl-periods)
- ("fprog" ,sbcl-fprog)))
+ ("periods" ,sbcl-periods)))
+ (arguments
+ '(#:asd-files '("fprog.asd"
+ "cambl.asd")))
(synopsis "Commoditized amounts and balances for Common Lisp")
(description
"CAMBL is a Common Lisp library providing a convenient facility for
working with commoditized values. It does not allow compound units (and so is
not suited for scientific operations) but does work rather nicely for the
-purpose of financial calculations."))))
+purpose of financial calculations.")
+ (home-page "https://github.com/jwiegley/cambl")
+ (license license:bsd-3))))
(define-public cl-cambl
(sbcl-package->cl-source-package sbcl-cambl))
`(("cambl" ,sbcl-cambl)
("cl-ppcre" ,sbcl-cl-ppcre)
("local-time" ,sbcl-local-time)
- ("periods-series" ,sbcl-periods-series)))
+ ("periods" ,sbcl-periods)))
(arguments
'(#:phases
(modify-phases %standard-phases
(define-public cl-gobject-introspection
(sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
+(define-public ecl-cl-gobject-introspection
+ (sbcl-package->ecl-package sbcl-cl-gobject-introspection))
+
(define-public sbcl-string-case
(let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
(revision "0"))
(sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
(define-public sbcl-serapeum
- (let ((commit "a2ca90cbdcb9f76c2822286110c7abe9ba5b76c2")
- (revision "2"))
+ (let ((commit "c5e352a9f04a84a93742193c01734f4fb31d9f82")
+ (revision "3"))
(package
(name "sbcl-serapeum")
(version (git-version "0.0.0" revision commit))
(file-name (git-file-name name version))
(sha256
(base32
- "1lrk2kf7qh5g6f8xvyg8wf89frzb5mw6m1jzgy46jy744f459i8q"))))
+ "16767pxl766c15jznr4srcbp7cnxf8w9lkyaqpp5w5crqymw84nw"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
("trivia" ,sbcl-trivia)
- ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
("split-sequence" ,sbcl-split-sequence)
("string-case" ,sbcl-string-case)
("parse-number" ,sbcl-parse-number)
("trivial-garbage" ,sbcl-trivial-garbage)
("bordeaux-threads" ,sbcl-bordeaux-threads)
("named-readtables" ,sbcl-named-readtables)
- ("fare-quasiquote-extras" ,sbcl-fare-quasiquote-extras)
+ ("fare-quasiquote" ,sbcl-fare-quasiquote)
("parse-declarations-1.0" ,sbcl-parse-declarations)
("global-vars" ,sbcl-global-vars)
("trivial-file-size" ,sbcl-trivial-file-size)
(define-public cl-serapeum
(sbcl-package->cl-source-package sbcl-serapeum))
+(define-public ecl-serapeum
+ (sbcl-package->ecl-package sbcl-serapeum))
+
(define-public sbcl-arrows
(let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
(revision "0"))
(inputs
`(("alexandria" ,sbcl-alexandria)
("iterate" ,sbcl-iterate)
- ("metabang-bind" ,sbcl-metabang-bind)))
- (propagated-inputs
- ;; Swank doesn't have a pre-compiled package, therefore we must
- ;; propagate its sources.
- `(("swank" ,cl-slime-swank)))
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("swank" ,sbcl-slime-swank)))
(arguments
'(#:phases
(modify-phases %standard-phases
(define-public cl-stefil
(sbcl-package->cl-source-package sbcl-stefil))
+(define-public ecl-stefil
+ (sbcl-package->ecl-package sbcl-stefil))
+
(define-public sbcl-graph
(let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
(revision "0"))
(file-name (git-file-name name version))
(sha256
(base32
- "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
- (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
+ "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("stefil" ,sbcl-stefil)))
(inputs
`(("alexandria" ,sbcl-alexandria)
("cl-heap" ,sbcl-cl-heap)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)))
+ ("named-readtables" ,sbcl-named-readtables)
+ ("yason" ,sbcl-yason)))
(arguments
- '(#:test-asd-file "graph-test.asd"))
+ '(#:asd-systems '("graph"
+ "graph/dot"
+ "graph/json")))
(synopsis "Graph data structure and algorithms for Common Lisp")
(description
"The GRAPH Common Lisp library provides a data structures to represent
(define-public cl-graph
(sbcl-package->cl-source-package sbcl-graph))
-(define-public sbcl-graph-dot
- (package
- (inherit sbcl-graph)
- (name "sbcl-graph-dot")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
- ("graph" ,sbcl-graph)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-graph)
- ((#:asd-file _ "") "graph-dot.asd")
- ((#:asd-system-name _ #f) "graph-dot")))
- (synopsis "Serialize graphs to and from DOT format")))
-
-(define-public sbcl-graph-json
- (package
- (inherit sbcl-graph)
- (name "sbcl-graph-json")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
- ("graph" ,sbcl-graph)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)
- ("yason" ,sbcl-yason)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-graph)
- ((#:asd-file _ "") "graph-json.asd")
- ((#:asd-system-name _ #f) "graph-json")))
- (synopsis "Serialize graphs to and from JSON format")))
+(define-public ecl-graph
+ (sbcl-package->ecl-package sbcl-graph))
(define-public sbcl-trivial-indent
(let ((commit "2d016941751647c6cc5bd471751c2cf68861c94a")
(define-public cl-trivial-indent
(sbcl-package->cl-source-package sbcl-trivial-indent))
+(define-public ecl-trivial-indent
+ (sbcl-package->ecl-package sbcl-trivial-indent))
+
(define-public sbcl-documentation-utils
(let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
(revision "0"))
(define-public cl-form-fiddle
(sbcl-package->cl-source-package sbcl-form-fiddle))
+(define-public ecl-form-fiddle
+ (sbcl-package->ecl-package sbcl-form-fiddle))
+
(define-public sbcl-parachute
(let ((commit "ca04dd8e43010a6dfffa26dbe1d62af86008d666")
(revision "0"))
(define-public cl-parachute
(sbcl-package->cl-source-package sbcl-parachute))
+(define-public ecl-parachute
+ (sbcl-package->ecl-package sbcl-parachute))
+
(define-public sbcl-array-utils
(let ((commit "f90eb9070d0b2205af51126a35033574725e5c56")
(revision "0"))
(define-public cl-array-utils
(sbcl-package->cl-source-package sbcl-array-utils))
+(define-public ecl-array-utils
+ (sbcl-package->ecl-package sbcl-array-utils))
+
(define-public sbcl-plump
(let ((commit "34f890fe46efdebe7bb70d218f1937e98f632bf9")
(revision "1"))
(define-public cl-plump
(sbcl-package->cl-source-package sbcl-plump))
+(define-public ecl-plump
+ (sbcl-package->ecl-package sbcl-plump))
+
+;;; Split the antik package in two to work around the circular dependency
+;;; between antik/antik and antik/gsll.
(define-public sbcl-antik-base
(let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
(revision "1"))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
("cl-ppcre" ,sbcl-cl-ppcre)
+ ("drakma" ,sbcl-drakma)
+ ("fare-utils" ,sbcl-fare-utils)
("iterate" ,sbcl-iterate)
("metabang-bind" ,sbcl-metabang-bind)
("named-readtables" ,sbcl-named-readtables)
- ("split-sequence" ,sbcl-split-sequence)))
+ ("split-sequence" ,sbcl-split-sequence)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("trivial-utf-8" ,sbcl-trivial-utf-8)))
(native-inputs
`(("lisp-unit" ,sbcl-lisp-unit)))
+ (arguments
+ '(#:asd-systems '("antik-base"
+ "foreign-array")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("antik.asd"
+ "physical-dimension.asd"
+ "science-data.asd"))
+ #t)))))
(synopsis "Scientific and engineering computation in Common Lisp")
(description
"Antik provides a foundation for scientific and engineering
(sbcl-package->cl-source-package sbcl-antik-base))
(define-public ecl-antik-base
- (sbcl-package->ecl-package sbcl-antik-base))
-
-(define-public sbcl-foreign-array
- (package
- (inherit sbcl-antik-base)
- (name "sbcl-foreign-array")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-antik-base)
- ((#:asd-file _ "") "foreign-array.asd")
- ((#:asd-system-name _ #f) "foreign-array")))
- (inputs
- `(("antik-base" ,sbcl-antik-base)
- ("cffi" ,sbcl-cffi)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("static-vectors" ,sbcl-static-vectors)))
- (synopsis "Common Lisp library providing access to foreign arrays")))
-
-(define-public cl-foreign-array
- (sbcl-package->cl-source-package sbcl-foreign-array))
-
-(define-public ecl-foreign-array
- (sbcl-package->ecl-package sbcl-foreign-array))
-
-(define-public sbcl-physical-dimension
- (package
- (inherit sbcl-antik-base)
- (name "sbcl-physical-dimension")
- (inputs
- `(("fare-utils" ,sbcl-fare-utils)
- ("foreign-array" ,sbcl-foreign-array)
- ("trivial-utf-8" ,sbcl-trivial-utf-8)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-antik-base)
- ((#:asd-file _ "") "physical-dimension.asd")
- ((#:asd-system-name _ #f) "physical-dimension")))
- (synopsis
- "Common Lisp library providing computations with physical units")))
-
-(define-public cl-physical-dimension
- (sbcl-package->cl-source-package sbcl-physical-dimension))
-
-(define-public sbcl-science-data
- (package
- (inherit sbcl-antik-base)
- (name "sbcl-science-data")
- (inputs
- `(("physical-dimension" ,sbcl-physical-dimension)
- ("drakma" ,sbcl-drakma)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-antik-base)
- ((#:asd-file _ "") "science-data.asd")
- ((#:asd-system-name _ #f) "science-data")))
- (synopsis
- "Common Lisp library for scientific and engineering numerical data")))
-
-(define-public cl-science-data
- (sbcl-package->cl-source-package sbcl-science-data))
+ (let ((pkg (sbcl-package->ecl-package sbcl-antik-base)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'unpack 'fix-readtable
+ (lambda _
+ (substitute* "input-output/readtable.lisp"
+ (("#-ccl")
+ "#-(or ccl ecl)"))
+ #t)))))))))
(define-public sbcl-gsll
(let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
`(("lisp-unit" ,sbcl-lisp-unit)))
(inputs
`(("alexandria" ,sbcl-alexandria)
- ("cffi-grovel" ,sbcl-cffi-grovel)
- ("cffi-libffi" ,sbcl-cffi-libffi)
- ("foreign-array" ,sbcl-foreign-array)
+ ("antik-base" ,sbcl-antik-base)
+ ("cffi" ,sbcl-cffi)
("gsl" ,gsl)
("metabang-bind" ,sbcl-metabang-bind)
("trivial-features" ,sbcl-trivial-features)
(define-public cl-gsll
(sbcl-package->cl-source-package sbcl-gsll))
+(define-public ecl-gsll
+ (sbcl-package->ecl-package sbcl-gsll))
+
(define-public sbcl-antik
(package
(inherit sbcl-antik-base)
(name "sbcl-antik")
(inputs
- `(("gsll" ,sbcl-gsll)
- ("physical-dimension" ,sbcl-physical-dimension)))
+ `(("antik-base" ,sbcl-antik-base)
+ ("gsll" ,sbcl-gsll)))
(arguments
- (substitute-keyword-arguments (package-arguments sbcl-antik-base)
- ((#:asd-file _ "") "antik.asd")
- ((#:asd-system-name _ #f) "antik")))))
+ '(#:asd-systems '("antik"
+ "science-data")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("antik-base.asd"
+ "foreign-array.asd"))
+ #t)))))))
(define-public cl-antik
(sbcl-package->cl-source-package sbcl-antik))
(define-public ecl-cl-interpol
(sbcl-package->ecl-package sbcl-cl-interpol))
-(define sbcl-symbol-munger-boot0
- ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
- ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
- (let ((commit "cc2bb4b7acd454d756484aec81ba487648385fc3")
+(define-public sbcl-symbol-munger
+ (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
(revision "1"))
(package
- (name "sbcl-symbol-munger-boot0")
+ (name "sbcl-symbol-munger")
(version (git-version "0.0.1" revision commit))
(source
(origin
(file-name (git-file-name name version))
(sha256
(base32
- "0diav5ricqsybqvbp4bkxyj3bn3v9n7xb2pqqc4vg1algsw2pyjl"))))
+ "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-file "symbol-munger.asd"
- #:asd-system-name "symbol-munger"))
(inputs
- `(("iterate" ,sbcl-iterate)
- ("alexandria" ,sbcl-alexandria)))
- (native-inputs
- `(("lisp-unit" ,sbcl-lisp-unit)))
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)))
+ (arguments
+ ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
+ ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
+ '(#:tests? #f))
(synopsis
"Capitalization and spacing conversion functions for Common Lisp")
(description
;; See https://github.com/AccelerationNet/symbol-munger/issues/5
(license license:expat))))
-(define sbcl-lisp-unit2-boot0
+(define-public cl-symbol-munger
+ (sbcl-package->cl-source-package sbcl-symbol-munger))
+
+(define-public ecl-symbol-munger
+ (sbcl-package->ecl-package sbcl-symbol-munger))
+
+(define-public sbcl-lisp-unit2
;; There is a cyclical dependency between symbol-munger and lisp-unit2.
;; See https://github.com/AccelerationNet/symbol-munger/issues/4
(let ((commit "fb9721524d1e4e73abb223ee036d74ce14a5505c")
(revision "1"))
(package
- (name "sbcl-lisp-unit2-boot0")
+ (name "sbcl-lisp-unit2")
(version (git-version "0.2.0" revision commit))
(source
(origin
(base32
"1rsqy8y0jqll6xn9a593848f5wvd5ribv4csry1ly0hmdhfnqzlp"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-file "lisp-unit2.asd"
- #:asd-system-name "lisp-unit2"))
(inputs
`(("alexandria" ,sbcl-alexandria)
("cl-interpol" ,sbcl-cl-interpol)
("iterate" ,sbcl-iterate)
- ("symbol-munger-boot0" ,sbcl-symbol-munger-boot0)))
+ ("symbol-munger" ,sbcl-symbol-munger)))
(synopsis "Test Framework for Common Lisp")
(description
"LISP-UNIT2 is a Common Lisp library that supports unit testing in the
(home-page "https://github.com/AccelerationNet/lisp-unit2")
(license license:expat))))
-(define-public sbcl-symbol-munger
- (let ((commit "97598d4c3c53fd5da72ab78908fbd5d8c7a13416")
- (revision "1"))
- (package
- (name "sbcl-symbol-munger")
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/AccelerationNet/symbol-munger")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0y8jywjy0ldyhp7bxf16fdvdd2qgqnd7nlhlqfpfnzxcqk4xy1km"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)))
- (native-inputs
- `(("lisp-unit2-boot0" ,sbcl-lisp-unit2-boot0)))
- (synopsis
- "Capitalization and spacing conversion functions for Common Lisp")
- (description
- "This is a Common Lisp library to change the capitalization and spacing
-of a string or a symbol. It can convert to and from Lisp, english, underscore
-and camel-case rules.")
- (home-page "https://github.com/AccelerationNet/symbol-munger")
- ;; The package declares a BSD license, but all of the license
- ;; text is MIT.
- ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
- (license license:expat))))
-
-(define-public cl-symbol-munger
- (sbcl-package->cl-source-package sbcl-symbol-munger))
-
-(define-public ecl-symbol-munger
- (sbcl-package->ecl-package sbcl-symbol-munger))
-
-(define-public sbcl-lisp-unit2
- (package
- (inherit sbcl-lisp-unit2-boot0)
- (name "sbcl-lisp-unit2")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-interpol" ,sbcl-cl-interpol)
- ("iterate" ,sbcl-iterate)
- ("symbol-munger" ,sbcl-symbol-munger)))))
-
(define-public cl-lisp-unit2
(sbcl-package->cl-source-package sbcl-lisp-unit2))
(sbcl-package->ecl-package sbcl-lisp-unit2))
(define-public sbcl-cl-csv
- (let ((commit "3eba29c8364b033fbe0d189c2500559278b6a362")
- (revision "1"))
+ (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651")
+ (revision "2"))
(package
(name "sbcl-cl-csv")
(version (git-version "1.0.6" revision commit))
(file-name (git-file-name name version))
(sha256
(base32
- "07h4ni89jzx93clx453hlnnb5g53hhlcmz5hghqv6ysam48lc8g6"))))
+ "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x"))))
(build-system asdf-build-system/sbcl)
(arguments
;; See: https://github.com/AccelerationNet/cl-csv/pull/34
(define-public ecl-external-program
(sbcl-package->ecl-package sbcl-external-program))
-(define sbcl-cl-ana-boot0
+(define-public sbcl-cl-ana
(let ((commit "fa7cee4c50aa1c859652813049ba0da7c18a0df9")
(revision "1"))
(package
- (name "sbcl-cl-ana-boot0")
+ (name "sbcl-cl-ana")
(version (git-version "0.0.0" revision commit))
(source
(origin
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
+ (base32 "0mr47l57m276dbpap7irr4fcnk5fgknhf6mgv4043s8h73amk5qh"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("cl-fad" ,sbcl-cl-fad)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("antik" ,sbcl-antik)
+ ("cffi" ,sbcl-cffi)
+ ("cl-csv" ,sbcl-cl-csv)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("external-program" ,sbcl-external-program)
+ ("gsl" ,gsl)
+ ("gsll" ,sbcl-gsll)
+ ("hdf5" ,hdf5-parallel-openmpi)
+ ("iterate" ,sbcl-iterate)
+ ("libffi" ,libffi)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "hdf-cffi/hdf-cffi.lisp"
+ (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
+ (string-append (assoc-ref inputs "hdf5")
+ "/lib/libhdf5.so")))
+ (substitute* "gsl-cffi/gsl-cffi.lisp"
+ (("define-foreign-library gsl-cffi" all)
+ (string-append all " (:unix "
+ (assoc-ref inputs "gsl")
+ "/lib/libgsl.so)")))
+ #t)))))
(synopsis "Common Lisp data analysis library")
(description
"CL-ANA is a data analysis library in Common Lisp providing tabular and
(home-page "https://github.com/ghollisjr/cl-ana")
(license license:gpl3))))
-(define-public sbcl-cl-ana.pathname-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.pathname-utils")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "pathname-utils/cl-ana.pathname-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.pathname-utils")))))
-
-(define-public cl-ana.pathname-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.pathname-utils))
-
-(define-public ecl-cl-ana.pathname-utils
- (sbcl-package->ecl-package sbcl-cl-ana.pathname-utils))
-
-(define-public sbcl-cl-ana.package-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.package-utils")
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "package-utils/cl-ana.package-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.package-utils")))))
-
-(define-public cl-ana.package-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.package-utils))
-
-(define-public ecl-cl-ana.package-utils
- (sbcl-package->ecl-package sbcl-cl-ana.package-utils))
-
-(define-public sbcl-cl-ana.string-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.string-utils")
- (inputs
- `(("split-sequence" ,sbcl-split-sequence)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "string-utils/cl-ana.string-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.string-utils")))))
-
-(define-public cl-ana.string-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.string-utils))
-
-(define-public ecl-cl-ana.string-utils
- (sbcl-package->ecl-package sbcl-cl-ana.string-utils))
-
-(define-public sbcl-cl-ana.functional-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.functional-utils")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "functional-utils/cl-ana.functional-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.functional-utils")))))
-
-(define-public cl-ana.functional-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.functional-utils))
-
-(define-public ecl-cl-ana.functional-utils
- (sbcl-package->ecl-package sbcl-cl-ana.functional-utils))
-
-(define-public sbcl-cl-ana.list-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.list-utils")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "list-utils/cl-ana.list-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.list-utils")))))
+(define-public cl-ana
+ (sbcl-package->cl-source-package sbcl-cl-ana))
-(define-public cl-ana.list-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.list-utils))
+(define-public sbcl-archive
+ (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
+ (revision "1"))
+ (package
+ (name "sbcl-archive")
+ (version (git-version "0.9" revision commit))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/archive")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-fad" ,sbcl-cl-fad)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Common Lisp library for tar and cpio archives")
+ (description
+ "This is a Common Lisp library to read and write disk-based file
+archives such as those generated by the tar and cpio programs on Unix.")
+ (home-page "https://github.com/sharplispers/archive")
+ (license license:bsd-3))))
-(define-public ecl-cl-ana.list-utils
- (sbcl-package->ecl-package sbcl-cl-ana.list-utils))
+(define-public cl-archive
+ (sbcl-package->cl-source-package sbcl-archive))
-(define-public sbcl-cl-ana.generic-math
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.generic-math")
- (inputs
- `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "generic-math/cl-ana.generic-math.asd")
- ((#:asd-system-name _ #f) "cl-ana.generic-math")))))
+(define-public ecl-archive
+ (sbcl-package->ecl-package sbcl-archive))
-(define-public cl-ana.generic-math
- (sbcl-package->cl-source-package sbcl-cl-ana.generic-math))
+(define-public sbcl-misc-extensions
+ (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
+ (revision "1"))
+ (package
+ (name "sbcl-misc-extensions")
+ (version (git-version "3.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Collection of small macros and extensions for Common Lisp")
+ (description
+ "This project is intended as a catchall for small, general-purpose
+extensions to Common Lisp. It contains:
-(define-public ecl-cl-ana.generic-math
- (sbcl-package->ecl-package sbcl-cl-ana.generic-math))
+@itemize
+@item @code{new-let}, a macro that combines and generalizes @code{let},
+@code{let*} and @code{multiple-value-bind},
+@item @code{gmap}, an iteration macro that generalizes @code{map}.
+@end itemize\n")
+ (home-page "https://common-lisp.net/project/misc-extensions/")
+ (license license:public-domain))))
-(define-public sbcl-cl-ana.math-functions
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.math-functions")
- (inputs
- `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("gsll" ,sbcl-gsll)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "math-functions/cl-ana.math-functions.asd")
- ((#:asd-system-name _ #f) "cl-ana.math-functions")))))
+(define-public cl-misc-extensions
+ (sbcl-package->cl-source-package sbcl-misc-extensions))
-(define-public cl-ana.math-functions
- (sbcl-package->cl-source-package sbcl-cl-ana.math-functions))
+(define-public ecl-misc-extensions
+ (sbcl-package->ecl-package sbcl-misc-extensions))
-(define-public sbcl-cl-ana.calculus
+(define-public sbcl-mt19937
(package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.calculus")
- (inputs
- `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "calculus/cl-ana.calculus.asd")
- ((#:asd-system-name _ #f) "cl-ana.calculus")))))
-
-(define-public cl-ana.calculus
- (sbcl-package->cl-source-package sbcl-cl-ana.calculus))
+ (name "sbcl-mt19937")
+ (version "1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
+ "mt19937-latest.tar.gz"))
+ (sha256
+ (base32
+ "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Mersenne Twister pseudo-random number generator")
+ (description
+ "MT19937 is a portable Mersenne Twister pseudo-random number generator
+for Common Lisp.")
+ (home-page "https://www.cliki.net/mt19937")
+ (license license:public-domain)))
-(define-public ecl-cl-ana.calculus
- (sbcl-package->ecl-package sbcl-cl-ana.calculus))
+(define-public cl-mt19937
+ (sbcl-package->cl-source-package sbcl-mt19937))
-(define-public sbcl-cl-ana.symbol-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.symbol-utils")
- (inputs
- `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "symbol-utils/cl-ana.symbol-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.symbol-utils")))))
+(define-public ecl-mt19937
+ (sbcl-package->ecl-package sbcl-mt19937))
-(define-public cl-ana.symbol-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.symbol-utils))
+(define-public sbcl-fset
+ (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
+ (revision "1"))
+ (package
+ (name "sbcl-fset")
+ (version (git-version "1.3.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slburson/fset")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
+ (snippet '(begin
+ ;; Remove obsolete copy of system definition.
+ (delete-file "Code/fset.asd")
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("misc-extensions" ,sbcl-misc-extensions)
+ ("mt19937" ,sbcl-mt19937)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (synopsis "Functional set-theoretic collections library")
+ (description
+ "FSet is a functional set-theoretic collections library for Common Lisp.
+Functional means that all update operations return a new collection rather than
+modifying an existing one in place. Set-theoretic means that collections may
+be nested arbitrarily with no additional programmer effort; for instance, sets
+may contain sets, maps may be keyed by sets, etc.")
+ (home-page "https://common-lisp.net/project/fset/Site/index.html")
+ (license license:llgpl))))
-(define-public ecl-cl-ana.symbol-utils
- (sbcl-package->ecl-package sbcl-cl-ana.symbol-utils))
+(define-public cl-fset
+ (sbcl-package->cl-source-package sbcl-fset))
-(define-public sbcl-cl-ana.macro-utils
+(define-public ecl-fset
(package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.macro-utils")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("split-sequence" ,sbcl-split-sequence)))
+ (inherit (sbcl-package->ecl-package sbcl-fset))
(arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "macro-utils/cl-ana.macro-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.macro-utils")))))
-
-(define-public cl-ana.macro-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.macro-utils))
-
-(define-public ecl-cl-ana.macro-utils
- (sbcl-package->ecl-package sbcl-cl-ana.macro-utils))
-
-(define-public sbcl-cl-ana.binary-tree
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.binary-tree")
- (inputs
- `(("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "binary-tree/cl-ana.binary-tree.asd")
- ((#:asd-system-name _ #f) "cl-ana.binary-tree")))))
-
-(define-public cl-ana.binary-tree
- (sbcl-package->cl-source-package sbcl-cl-ana.binary-tree))
-
-(define-public ecl-cl-ana.binary-tree
- (sbcl-package->ecl-package sbcl-cl-ana.binary-tree))
-
-(define-public sbcl-cl-ana.tensor
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.tensor")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "tensor/cl-ana.tensor.asd")
- ((#:asd-system-name _ #f) "cl-ana.tensor")))))
-
-(define-public cl-ana.tensor
- (sbcl-package->cl-source-package sbcl-cl-ana.tensor))
-
-(define-public ecl-cl-ana.tensor
- (sbcl-package->ecl-package sbcl-cl-ana.tensor))
-
-(define-public sbcl-cl-ana.error-propogation
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.error-propogation")
- (inputs
- `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "error-propogation/cl-ana.error-propogation.asd")
- ((#:asd-system-name _ #f) "cl-ana.error-propogation")))))
-
-(define-public cl-ana.error-propogation
- (sbcl-package->cl-source-package sbcl-cl-ana.error-propogation))
-
-(define-public sbcl-cl-ana.quantity
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.quantity")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "quantity/cl-ana.quantity.asd")
- ((#:asd-system-name _ #f) "cl-ana.quantity")))))
-
-(define-public cl-ana.quantity
- (sbcl-package->cl-source-package sbcl-cl-ana.quantity))
-
-(define-public sbcl-cl-ana.table
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.table")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "table/cl-ana.table.asd")
- ((#:asd-system-name _ #f) "cl-ana.table")))))
-
-(define-public cl-ana.table
- (sbcl-package->cl-source-package sbcl-cl-ana.table))
-
-(define-public ecl-cl-ana.table
- (sbcl-package->ecl-package sbcl-cl-ana.table))
-
-(define-public sbcl-cl-ana.table-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.table-utils")
- (inputs
- `(("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "table-utils/cl-ana.table-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.table-utils")))))
-
-(define-public cl-ana.table-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.table-utils))
-
-(define-public ecl-cl-ana.table-utils
- (sbcl-package->ecl-package sbcl-cl-ana.table-utils))
-
-(define-public sbcl-cl-ana.hdf-cffi
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.hdf-cffi")
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("hdf5" ,hdf5-parallel-openmpi)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "hdf-cffi/cl-ana.hdf-cffi.asd")
- ((#:asd-system-name _ #f) "cl-ana.hdf-cffi")
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "hdf-cffi/hdf-cffi.lisp"
- (("/usr/lib/i386-linux-gnu/hdf5/serial/libhdf5.so")
- (string-append
- (assoc-ref inputs "hdf5")
- "/lib/libhdf5.so")))))))))))
-
-(define-public cl-ana.hdf-cffi
- (sbcl-package->cl-source-package sbcl-cl-ana.hdf-cffi))
-
-(define-public ecl-cl-ana.hdf-cffi
- (sbcl-package->ecl-package sbcl-cl-ana.hdf-cffi))
-
-(define-public sbcl-cl-ana.int-char
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.int-char")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "int-char/cl-ana.int-char.asd")
- ((#:asd-system-name _ #f) "cl-ana.int-char")))))
-
-(define-public cl-ana.int-char
- (sbcl-package->cl-source-package sbcl-cl-ana.int-char))
-
-(define-public ecl-cl-ana.int-char
- (sbcl-package->ecl-package sbcl-cl-ana.int-char))
-
-(define-public sbcl-cl-ana.memoization
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.memoization")
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "memoization/cl-ana.memoization.asd")
- ((#:asd-system-name _ #f) "cl-ana.memoization")))))
-
-(define-public cl-ana.memoization
- (sbcl-package->cl-source-package sbcl-cl-ana.memoization))
-
-(define-public ecl-cl-ana.memoization
- (sbcl-package->ecl-package sbcl-cl-ana.memoization))
-
-(define-public sbcl-cl-ana.typespec
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.typespec")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "typespec/cl-ana.typespec.asd")
- ((#:asd-system-name _ #f) "cl-ana.typespec")))))
-
-(define-public cl-ana.typespec
- (sbcl-package->cl-source-package sbcl-cl-ana.typespec))
-
-(define-public ecl-cl-ana.typespec
- (sbcl-package->ecl-package sbcl-cl-ana.typespec))
-
-(define-public sbcl-cl-ana.hdf-typespec
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.hdf-typespec")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "hdf-typespec/cl-ana.hdf-typespec.asd")
- ((#:asd-system-name _ #f) "cl-ana.hdf-typespec")))))
-
-(define-public cl-ana.hdf-typespec
- (sbcl-package->cl-source-package sbcl-cl-ana.hdf-typespec))
-
-(define-public ecl-cl-ana.hdf-typespec
- (sbcl-package->ecl-package sbcl-cl-ana.hdf-typespec))
-
-(define-public sbcl-cl-ana.hdf-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.hdf-utils")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
- ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
- ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "hdf-utils/cl-ana.hdf-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.hdf-utils")))))
-
-(define-public cl-ana.hdf-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.hdf-utils))
-
-(define-public ecl-cl-ana.hdf-utils
- (sbcl-package->ecl-package sbcl-cl-ana.hdf-utils))
-
-(define-public sbcl-cl-ana.typed-table
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.typed-table")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)
- ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "typed-table/cl-ana.typed-table.asd")
- ((#:asd-system-name _ #f) "cl-ana.typed-table")))))
-
-(define-public cl-ana.typed-table
- (sbcl-package->cl-source-package sbcl-cl-ana.typed-table))
-
-(define-public ecl-cl-ana.typed-table
- (sbcl-package->ecl-package sbcl-cl-ana.typed-table))
-
-(define-public sbcl-cl-ana.hdf-table
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.hdf-table")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
- ("cl-ana.hdf-cffi" ,sbcl-cl-ana.hdf-cffi)
- ("cl-ana.hdf-typespec" ,sbcl-cl-ana.hdf-typespec)
- ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
- ("cl-ana.table" ,sbcl-cl-ana.table)
- ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
- ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "hdf-table/cl-ana.hdf-table.asd")
- ((#:asd-system-name _ #f) "cl-ana.hdf-table")))))
-
-(define-public cl-ana.hdf-table
- (sbcl-package->cl-source-package sbcl-cl-ana.hdf-table))
-
-(define-public ecl-cl-ana.hdf-table
- (sbcl-package->ecl-package sbcl-cl-ana.hdf-table))
-
-(define-public sbcl-cl-ana.gsl-cffi
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.gsl-cffi")
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("gsl" ,gsl)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "gsl-cffi/cl-ana.gsl-cffi.asd")
- ((#:asd-system-name _ #f) "cl-ana.gsl-cffi")
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gsl-cffi/gsl-cffi.lisp"
- (("define-foreign-library gsl-cffi" all)
- (string-append all " (:unix "
- (assoc-ref inputs "gsl")
- "/lib/libgsl.so)")))))))))))
-
-(define-public cl-ana.gsl-cffi
- (sbcl-package->cl-source-package sbcl-cl-ana.gsl-cffi))
-
-(define-public ecl-cl-ana.gsl-cffi
- (sbcl-package->ecl-package sbcl-cl-ana.gsl-cffi))
-
-(define-public sbcl-cl-ana.ntuple-table
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.ntuple-table")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-ana.gsl-cffi" ,sbcl-cl-ana.gsl-cffi)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)
- ("cl-ana.typed-table" ,sbcl-cl-ana.typed-table)
- ("cl-ana.typespec" ,sbcl-cl-ana.typespec)
- ("gsll" ,sbcl-gsll)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "ntuple-table/cl-ana.ntuple-table.asd")
- ((#:asd-system-name _ #f) "cl-ana.ntuple-table")))))
-
-(define-public cl-ana.ntuple-table
- (sbcl-package->cl-source-package sbcl-cl-ana.ntuple-table))
-
-(define-public sbcl-cl-ana.csv-table
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.csv-table")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("antik" ,sbcl-antik)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)
- ("cl-csv" ,sbcl-cl-csv)
- ("iterate" ,sbcl-iterate)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "csv-table/cl-ana.csv-table.asd")
- ((#:asd-system-name _ #f) "cl-ana.csv-table")))))
-
-(define-public cl-ana.csv-table
- (sbcl-package->cl-source-package sbcl-cl-ana.csv-table))
-
-(define-public sbcl-cl-ana.reusable-table
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.reusable-table")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.table" ,sbcl-cl-ana.table)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "reusable-table/cl-ana.reusable-table.asd")
- ((#:asd-system-name _ #f) "cl-ana.reusable-table")))))
-
-(define-public cl-ana.reusable-table
- (sbcl-package->cl-source-package sbcl-cl-ana.reusable-table))
-
-(define-public ecl-cl-ana.reusable-table
- (sbcl-package->ecl-package sbcl-cl-ana.reusable-table))
-
-(define-public sbcl-cl-ana.linear-algebra
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.linear-algebra")
- (inputs
- `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
- ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
- ("gsll" ,sbcl-gsll)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "linear-algebra/cl-ana.linear-algebra.asd")
- ((#:asd-system-name _ #f) "cl-ana.linear-algebra")))))
-
-(define-public cl-ana.linear-algebra
- (sbcl-package->cl-source-package sbcl-cl-ana.linear-algebra))
-
-(define-public sbcl-cl-ana.lorentz
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.lorentz")
- (inputs
- `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
- ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
- ("iterate" ,sbcl-iterate)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "lorentz/cl-ana.lorentz.asd")
- ((#:asd-system-name _ #f) "cl-ana.lorentz")))))
-
-(define-public cl-ana.lorentz
- (sbcl-package->cl-source-package sbcl-cl-ana.lorentz))
-
-(define-public sbcl-cl-ana.clos-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.clos-utils")
- (inputs
- `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
- ("closer-mop" ,sbcl-closer-mop)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "clos-utils/cl-ana.clos-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.clos-utils")))))
-
-(define-public cl-ana.clos-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.clos-utils))
-
-(define-public ecl-cl-ana.clos-utils
- (sbcl-package->ecl-package sbcl-cl-ana.clos-utils))
-
-(define-public sbcl-cl-ana.hash-table-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.hash-table-utils")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "hash-table-utils/cl-ana.hash-table-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.hash-table-utils")))))
-
-(define-public cl-ana.hash-table-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.hash-table-utils))
-
-(define-public ecl-cl-ana.hash-table-utils
- (sbcl-package->ecl-package sbcl-cl-ana.hash-table-utils))
-
-(define-public sbcl-cl-ana.map
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.map")
- (inputs
- `(("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "map/cl-ana.map.asd")
- ((#:asd-system-name _ #f) "cl-ana.map")))))
-
-(define-public cl-ana.map
- (sbcl-package->cl-source-package sbcl-cl-ana.map))
-
-(define-public ecl-cl-ana.map
- (sbcl-package->ecl-package sbcl-cl-ana.map))
-
-(define-public sbcl-cl-ana.fitting
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.fitting")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
- ("gsll" ,sbcl-gsll)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "fitting/cl-ana.fitting.asd")
- ((#:asd-system-name _ #f) "cl-ana.fitting")))))
-
-(define-public cl-ana.fitting
- (sbcl-package->cl-source-package sbcl-cl-ana.fitting))
-
-(define-public sbcl-cl-ana.histogram
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.histogram")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)
- ("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
- ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
- ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
- ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.tensor" ,sbcl-cl-ana.tensor)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "histogram/cl-ana.histogram.asd")
- ((#:asd-system-name _ #f) "cl-ana.histogram")))))
-
-(define-public cl-ana.histogram
- (sbcl-package->cl-source-package sbcl-cl-ana.histogram))
-
-(define-public sbcl-cl-ana.file-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.file-utils")
- (inputs
- `(("external-program" ,sbcl-external-program)
- ("split-sequence" ,sbcl-split-sequence)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "file-utils/cl-ana.file-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.file-utils")))))
-
-(define-public cl-ana.file-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.file-utils))
-
-(define-public ecl-cl-ana.file-utils
- (sbcl-package->ecl-package sbcl-cl-ana.file-utils))
-
-(define-public sbcl-cl-ana.statistics
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.statistics")
- (inputs
- `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.map" ,sbcl-cl-ana.map)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "statistics/cl-ana.statistics.asd")
- ((#:asd-system-name _ #f) "cl-ana.statistics")))))
-
-(define-public cl-ana.statistics
- (sbcl-package->cl-source-package sbcl-cl-ana.statistics))
-
-(define-public sbcl-cl-ana.gnuplot-interface
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.gnuplot-interface")
- (inputs
- `(("external-program" ,sbcl-external-program)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "gnuplot-interface/cl-ana.gnuplot-interface.asd")
- ((#:asd-system-name _ #f) "cl-ana.gnuplot-interface")))))
-
-(define-public cl-ana.gnuplot-interface
- (sbcl-package->cl-source-package sbcl-cl-ana.gnuplot-interface))
-
-(define-public ecl-cl-ana.gnuplot-interface
- (sbcl-package->ecl-package sbcl-cl-ana.gnuplot-interface))
-
-(define-public sbcl-cl-ana.plotting
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.plotting")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
- ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.gnuplot-interface" ,sbcl-cl-ana.gnuplot-interface)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
- ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
- ("external-program" ,sbcl-external-program)
- ("split-sequence" ,sbcl-split-sequence)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "plotting/cl-ana.plotting.asd")
- ((#:asd-system-name _ #f) "cl-ana.plotting")))))
-
-(define-public cl-ana.plotting
- (sbcl-package->cl-source-package sbcl-cl-ana.plotting))
-
-(define-public sbcl-cl-ana.table-viewing
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.table-viewing")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "table-viewing/cl-ana.table-viewing.asd")
- ((#:asd-system-name _ #f) "cl-ana.table-viewing")))))
-
-(define-public cl-ana.table-viewing
- (sbcl-package->cl-source-package sbcl-cl-ana.table-viewing))
-
-(define-public sbcl-cl-ana.serialization
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.serialization")
- (inputs
- `(("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
- ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
- ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.typespec" ,sbcl-cl-ana.typespec)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "serialization/cl-ana.serialization.asd")
- ((#:asd-system-name _ #f) "cl-ana.serialization")))))
-
-(define-public cl-ana.serialization
- (sbcl-package->cl-source-package sbcl-cl-ana.serialization))
-
-(define-public sbcl-cl-ana.makeres
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
- ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
- ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
- ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
- ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
- ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
- ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
- ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)
- ("external-program" ,sbcl-external-program)))
- (native-inputs
- `(("cl-fad" ,sbcl-cl-fad)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres/cl-ana.makeres.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres")))))
-
-(define-public cl-ana.makeres
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres))
-
-(define-public sbcl-cl-ana.makeres-macro
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres-macro")
- (inputs
- `(("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres-macro/cl-ana.makeres-macro.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres-macro")))))
-
-(define-public cl-ana.makeres-macro
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres-macro))
-
-(define-public sbcl-cl-ana.makeres-block
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres-block")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres-block/cl-ana.makeres-block.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres-block")))))
-
-(define-public cl-ana.makeres-block
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres-block))
-
-(define-public sbcl-cl-ana.makeres-progress
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres-progress")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres-progress/cl-ana.makeres-progress.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres-progress")))))
-
-(define-public cl-ana.makeres-progress
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres-progress))
-
-(define-public sbcl-cl-ana.makeres-table
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres-table")
- (inputs
- `(("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
- ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
- ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
- ("cl-ana.hdf-utils" ,sbcl-cl-ana.hdf-utils)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
- ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
- ("cl-ana.memoization" ,sbcl-cl-ana.memoization)
- ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
- ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)))
- (native-inputs
- `(("cl-fad" ,sbcl-cl-fad)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres-table/cl-ana.makeres-table.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres-table")))))
-
-(define-public cl-ana.makeres-table
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres-table))
-
-(define-public sbcl-cl-ana.makeres-graphviz
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres-graphviz")
- (inputs
- `(("cl-ana.makeres" ,sbcl-cl-ana.makeres)
- ("external-program" ,sbcl-external-program)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres-graphviz/cl-ana.makeres-graphviz.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres-graphviz")))))
-
-(define-public cl-ana.makeres-graphviz
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres-graphviz))
-
-(define-public sbcl-cl-ana.makeres-branch
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres-branch")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.makeres" ,sbcl-cl-ana.makeres)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres-branch/cl-ana.makeres-branch.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres-branch")))))
-
-(define-public cl-ana.makeres-branch
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres-branch))
-
-(define-public sbcl-cl-ana.makeres-utils
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.makeres-utils")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
- ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
- ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
- ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
- ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
- ("cl-ana.string-utils" ,sbcl-cl-ana.string-utils)
- ("cl-ana.symbol-utils" ,sbcl-cl-ana.symbol-utils)
- ("cl-ana.table" ,sbcl-cl-ana.table)))
- (native-inputs
- `(("cl-fad" ,sbcl-cl-fad)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "makeres-utils/cl-ana.makeres-utils.asd")
- ((#:asd-system-name _ #f) "cl-ana.makeres-utils")))))
-
-(define-public cl-ana.makeres-utils
- (sbcl-package->cl-source-package sbcl-cl-ana.makeres-utils))
-
-(define-public sbcl-cl-ana.statistical-learning
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana.statistical-learning")
- (inputs
- `(("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.functional-utils" ,sbcl-cl-ana.functional-utils)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
- ("cl-ana.list-utils" ,sbcl-cl-ana.list-utils)
- ("cl-ana.macro-utils" ,sbcl-cl-ana.macro-utils)
- ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.statistics" ,sbcl-cl-ana.statistics)))
- (native-inputs
- `(("cl-fad" ,sbcl-cl-fad)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "")
- "statistical-learning/cl-ana.statistical-learning.asd")
- ((#:asd-system-name _ #f) "cl-ana.statistical-learning")))))
-
-(define-public cl-ana.statistical-learning
- (sbcl-package->cl-source-package sbcl-cl-ana.statistical-learning))
-
-(define-public sbcl-cl-ana
- (package
- (inherit sbcl-cl-ana-boot0)
- (name "sbcl-cl-ana")
- (inputs
- `(("cl-ana.binary-tree" ,sbcl-cl-ana.binary-tree)
- ("cl-ana.calculus" ,sbcl-cl-ana.calculus)
- ("cl-ana.clos-utils" ,sbcl-cl-ana.clos-utils)
- ("cl-ana.csv-table" ,sbcl-cl-ana.csv-table)
- ("cl-ana.error-propogation" ,sbcl-cl-ana.error-propogation)
- ("cl-ana.file-utils" ,sbcl-cl-ana.file-utils)
- ("cl-ana.fitting" ,sbcl-cl-ana.fitting)
- ("cl-ana.generic-math" ,sbcl-cl-ana.generic-math)
- ("cl-ana.hash-table-utils" ,sbcl-cl-ana.hash-table-utils)
- ("cl-ana.hdf-table" ,sbcl-cl-ana.hdf-table)
- ("cl-ana.histogram" ,sbcl-cl-ana.histogram)
- ("cl-ana.int-char" ,sbcl-cl-ana.int-char)
- ("cl-ana.linear-algebra" ,sbcl-cl-ana.linear-algebra)
- ("cl-ana.lorentz" ,sbcl-cl-ana.lorentz)
- ("cl-ana.map" ,sbcl-cl-ana.map)
- ("cl-ana.makeres" ,sbcl-cl-ana.makeres)
- ("cl-ana.makeres-block" ,sbcl-cl-ana.makeres-block)
- ("cl-ana.makeres-branch" ,sbcl-cl-ana.makeres-branch)
- ("cl-ana.makeres-graphviz" ,sbcl-cl-ana.makeres-graphviz)
- ("cl-ana.makeres-macro" ,sbcl-cl-ana.makeres-macro)
- ("cl-ana.makeres-progress" ,sbcl-cl-ana.makeres-progress)
- ("cl-ana.makeres-table" ,sbcl-cl-ana.makeres-table)
- ("cl-ana.makeres-utils" ,sbcl-cl-ana.makeres-utils)
- ("cl-ana.math-functions" ,sbcl-cl-ana.math-functions)
- ("cl-ana.ntuple-table" ,sbcl-cl-ana.ntuple-table)
- ("cl-ana.package-utils" ,sbcl-cl-ana.package-utils)
- ("cl-ana.pathname-utils" ,sbcl-cl-ana.pathname-utils)
- ("cl-ana.plotting" ,sbcl-cl-ana.plotting)
- ("cl-ana.quantity" ,sbcl-cl-ana.quantity)
- ("cl-ana.reusable-table" ,sbcl-cl-ana.reusable-table)
- ("cl-ana.serialization" ,sbcl-cl-ana.serialization)
- ("cl-ana.statistics" ,sbcl-cl-ana.statistics)
- ("cl-ana.statistical-learning" ,sbcl-cl-ana.statistical-learning)
- ("cl-ana.table" ,sbcl-cl-ana.table)
- ("cl-ana.table-utils" ,sbcl-cl-ana.table-utils)
- ("cl-ana.table-viewing" ,sbcl-cl-ana.table-viewing)
- ("cl-ana.tensor" ,sbcl-cl-ana.tensor)
- ("libffi" ,libffi)))
- (native-inputs
- `(("cl-fad" ,sbcl-cl-fad)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-ana-boot0)
- ((#:asd-file _ "") "cl-ana.asd")
- ((#:asd-system-name _ #f) "cl-ana")))))
-
-(define-public cl-ana
- (sbcl-package->cl-source-package sbcl-cl-ana))
-
-(define-public sbcl-archive
- (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
- (revision "1"))
- (package
- (name "sbcl-archive")
- (version (git-version "0.9" revision commit))
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/archive")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-fad" ,sbcl-cl-fad)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (synopsis "Common Lisp library for tar and cpio archives")
- (description
- "This is a Common Lisp library to read and write disk-based file
-archives such as those generated by the tar and cpio programs on Unix.")
- (home-page "https://github.com/sharplispers/archive")
- (license license:bsd-3))))
-
-(define-public cl-archive
- (sbcl-package->cl-source-package sbcl-archive))
-
-(define-public ecl-archive
- (sbcl-package->ecl-package sbcl-archive))
-
-(define-public sbcl-misc-extensions
- (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
- (revision "1"))
- (package
- (name "sbcl-misc-extensions")
- (version (git-version "3.3" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Collection of small macros and extensions for Common Lisp")
- (description
- "This project is intended as a catchall for small, general-purpose
-extensions to Common Lisp. It contains:
-
-@itemize
-@item @code{new-let}, a macro that combines and generalizes @code{let},
-@code{let*} and @code{multiple-value-bind},
-@item @code{gmap}, an iteration macro that generalizes @code{map}.
-@end itemize\n")
- (home-page "https://common-lisp.net/project/misc-extensions/")
- (license license:public-domain))))
-
-(define-public cl-misc-extensions
- (sbcl-package->cl-source-package sbcl-misc-extensions))
-
-(define-public ecl-misc-extensions
- (sbcl-package->ecl-package sbcl-misc-extensions))
-
-(define-public sbcl-mt19937
- (package
- (name "sbcl-mt19937")
- (version "1.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://common-lisp.net/project/asdf-packaging/"
- "mt19937-latest.tar.gz"))
- (sha256
- (base32
- "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Mersenne Twister pseudo-random number generator")
- (description
- "MT19937 is a portable Mersenne Twister pseudo-random number generator
-for Common Lisp.")
- (home-page "https://www.cliki.net/mt19937")
- (license license:public-domain)))
-
-(define-public cl-mt19937
- (sbcl-package->cl-source-package sbcl-mt19937))
-
-(define-public ecl-mt19937
- (sbcl-package->ecl-package sbcl-mt19937))
-
-(define-public sbcl-fset
- (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
- (revision "1"))
- (package
- (name "sbcl-fset")
- (version (git-version "1.3.2" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/slburson/fset")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
- (snippet '(begin
- ;; Remove obsolete copy of system definition.
- (delete-file "Code/fset.asd")
- #t))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("misc-extensions" ,sbcl-misc-extensions)
- ("mt19937" ,sbcl-mt19937)
- ("named-readtables" ,sbcl-named-readtables)))
- (synopsis "Functional set-theoretic collections library")
- (description
- "FSet is a functional set-theoretic collections library for Common Lisp.
-Functional means that all update operations return a new collection rather than
-modifying an existing one in place. Set-theoretic means that collections may
-be nested arbitrarily with no additional programmer effort; for instance, sets
-may contain sets, maps may be keyed by sets, etc.")
- (home-page "https://common-lisp.net/project/fset/Site/index.html")
- (license license:llgpl))))
-
-(define-public cl-fset
- (sbcl-package->cl-source-package sbcl-fset))
+ ;; Tests fails on ECL with "The function FSET::MAKE-CHAR is undefined".
+ '(#:tests? #f))))
(define-public sbcl-cl-cont
(let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
(inputs
`(("alexandria" ,sbcl-alexandria)
("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
("libuv" ,libuv)))
(arguments
`(#:phases
(define-public ecl-cl-libuv
(sbcl-package->ecl-package sbcl-cl-libuv))
-(define-public sbcl-cl-async-base
+(define-public sbcl-cl-async
(let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
(revision "1"))
(package
- (name "sbcl-cl-async-base")
+ (name "sbcl-cl-async")
(version (git-version "0.6.1" revision commit))
(source
(origin
"11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ `(("babel" ,sbcl-babel)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
("cffi" ,sbcl-cffi)
- ("cl-libuv" ,sbcl-cl-libuv)))
- (arguments
- `(#:asd-file "cl-async.asd"))
- (synopsis "Base system for cl-async")
- (description
- "Cl-async is a library for general purpose, non-blocking programming in
-Common Lisp. It uses the libuv library as backend.")
- (home-page "https://orthecreedence.github.io/cl-async/")
- (license license:expat))))
-
-(define-public cl-async-base
- (sbcl-package->cl-source-package sbcl-cl-async-base))
-
-(define-public ecl-cl-async-base
- (sbcl-package->ecl-package sbcl-cl-async-base))
-
-(define-public sbcl-cl-async-util
- (package
- (inherit sbcl-cl-async-base)
- (name "sbcl-cl-async-util")
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("cl-async-base" ,sbcl-cl-async-base)
- ("cl-libuv" ,sbcl-cl-libuv)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("fast-io" ,sbcl-fast-io)
- ("vom" ,sbcl-vom)))
- (synopsis "Internal utilities for cl-async")))
-
-(define-public cl-async-util
- (sbcl-package->cl-source-package sbcl-cl-async-util))
-
-(define-public ecl-cl-async-util
- (sbcl-package->ecl-package sbcl-cl-async-util))
-
-(define-public sbcl-cl-async
- (package
- (inherit sbcl-cl-async-base)
- (name "sbcl-cl-async")
- (inputs
- `(("babel" ,sbcl-babel)
- ("cffi" ,sbcl-cffi)
- ("cl-async-base" ,sbcl-cl-async-base)
- ("cl-async-util" ,sbcl-cl-async-util)
- ("cl-libuv" ,sbcl-cl-libuv)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("static-vectors" ,sbcl-static-vectors)
- ("trivial-features" ,sbcl-trivial-features)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (synopsis "Asynchronous operations for Common Lisp")))
-
-(define-public cl-async
- (sbcl-package->cl-source-package sbcl-cl-async))
-
-(define-public ecl-cl-async
- (sbcl-package->ecl-package sbcl-cl-async))
-
-(define-public sbcl-cl-async-repl
- (package
- (inherit sbcl-cl-async-base)
- (name "sbcl-cl-async-repl")
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cl-async" ,sbcl-cl-async)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
- ((#:asd-file _ "") "cl-async-repl.asd")))
- (synopsis "REPL integration for cl-async")))
-
-(define-public cl-async-repl
- (sbcl-package->cl-source-package sbcl-cl-async-repl))
-
-(define-public ecl-cl-async-repl
- (sbcl-package->ecl-package sbcl-cl-async-repl))
-
-(define-public sbcl-cl-async-ssl
- (package
- (inherit sbcl-cl-async-base)
- (name "sbcl-cl-async-ssl")
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("cl-async" ,sbcl-cl-async)
- ("openssl" ,openssl)
- ("vom" ,sbcl-vom)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cl-async-base)
- ((#:asd-file _ "") "cl-async-ssl.asd")
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
+ ("cl-libuv" ,sbcl-cl-libuv)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("fast-io" ,sbcl-fast-io)
+ ("openssl" ,openssl)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("vom" ,sbcl-vom)))
+ (arguments
+ `(#:asd-systems '("cl-async"
+ "cl-async-repl"
+ "cl-async-ssl")
+ #:phases
+ (modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
(substitute* "src/ssl/package.lisp"
(("libssl\\.so")
(string-append (assoc-ref inputs "openssl")
"/lib/libssl.so")))
- #t))))))
- (synopsis "SSL wrapper around cl-async socket implementation")))
+ #t)))))
+ (synopsis "Asynchronous operations for Common Lisp")
+ (description
+ "Cl-async is a library for general purpose, non-blocking programming in
+Common Lisp. It uses the libuv library as backend.")
+ (home-page "https://orthecreedence.github.io/cl-async/")
+ (license license:expat))))
-(define-public cl-async-ssl
- (sbcl-package->cl-source-package sbcl-cl-async-ssl))
+(define-public cl-async
+ (sbcl-package->cl-source-package sbcl-cl-async))
-(define-public ecl-cl-async-ssl
- (sbcl-package->ecl-package sbcl-cl-async-ssl))
+(define-public ecl-cl-async
+ (sbcl-package->ecl-package sbcl-cl-async))
(define-public sbcl-blackbird
(let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
`(("imagemagick" ,imagemagick)
("tk" ,tk)))
(arguments
- `(#:asd-file "ltk/ltk.asd"
+ `(#:asd-systems '("ltk"
+ "ltk-mw"
+ "ltk-remote")
#:tests? #f
- #:phases (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "ltk/ltk.lisp"
- (("#-freebsd \"wish\"")
- (string-append "#-freebsd \""
- (assoc-ref inputs "tk")
- "/bin/wish\""))
- (("do-execute \"convert\"")
- (string-append "do-execute \""
- (assoc-ref inputs "imagemagick")
- "/bin/convert\"")))
- #t)))))
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "ltk/ltk.lisp"
+ (("#-freebsd \"wish\"")
+ (string-append "#-freebsd \""
+ (assoc-ref inputs "tk")
+ "/bin/wish\""))
+ (("do-execute \"convert\"")
+ (string-append "do-execute \""
+ (assoc-ref inputs "imagemagick")
+ "/bin/convert\"")))
+ #t))
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "ltk/ltk-remote.lisp"
+ (("\\(:export")
+ "(:shadow #:raise) (:export"))
+ #t)))))
(synopsis "Common Lisp bindings for the Tk GUI toolkit")
(description
"LTK is a Common Lisp binding for the Tk graphics toolkit. It is written
(define-public ecl-ltk
(sbcl-package->ecl-package sbcl-ltk))
-(define-public sbcl-ltk-mw
- (package
- (inherit sbcl-ltk)
- (name "sbcl-ltk-mw")
- (inputs
- `(("ltk" ,sbcl-ltk)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-ltk)
- ((#:asd-file _) "ltk/ltk-mw.asd")
- ((#:phases _) '%standard-phases)))
- (synopsis "Extra widgets for LTK")
- (description
- "This is a collection of higher-level widgets built on top of LTK.")))
-
-(define-public cl-ltk-mw
- (sbcl-package->cl-source-package sbcl-ltk-mw))
-
-(define-public ecl-ltk-mw
- (sbcl-package->ecl-package sbcl-ltk-mw))
-
-(define-public sbcl-ltk-remote
- (package
- (inherit sbcl-ltk)
- (name "sbcl-ltk-remote")
- (inputs
- `(("ltk" ,sbcl-ltk)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-ltk)
- ((#:asd-file _) "ltk/ltk-remote.asd")
- ((#:phases _) '%standard-phases)))
- (synopsis "Remote GUI support for LTK")
- (description
- "This LTK extension allows the GUI to be displayed on a computer different
-from the one running the Lisp program by using a TCP connection.")))
-
-(define-public cl-ltk-remote
- (sbcl-package->cl-source-package sbcl-ltk-remote))
-
(define-public sbcl-cl-lex
(let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
(revision "1"))
"/LICENSE")))
(inputs
`(("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
("hdf5" ,hdf5-1.10)))
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-system-name "hdf5-cffi"
- #:asd-file "hdf5-cffi.asd"
- #:test-asd-file "hdf5-cffi.test.asd"
+ `(#:test-asd-file "hdf5-cffi.test.asd"
;; Tests depend on hdf5-cffi.examples.asd in addition to hdf5-cffi.asd,
;; I don't know if there is a way to tell asdf-build-system to load
;; an additional system first, so tests are disabled.
(home-page "https://github.com/lvaruzza/cl-randist")
(license license:bsd-2)
(arguments
- `(#:asd-system-name "cl-randist"
- #:asd-file "cl-randist.asd"
- #:tests? #f))))
+ `(#:tests? #f))))
(define-public cl-randist
(sbcl-package->cl-source-package sbcl-cl-randist))
(inputs
`(("documentation-utils" ,sbcl-documentation-utils)))
(arguments
- `(#:asd-system-name "float-features"
- #:asd-file "float-features.asd"
- #:tests? #f))))
+ `(#:tests? #f))))
(define-public cl-float-features
(sbcl-package->cl-source-package sbcl-float-features))
("symbol-munger" ,sbcl-symbol-munger)
("closer-mop" ,sbcl-closer-mop)))
(arguments
- `(#:asd-system-name "function-cache"
- #:asd-file "function-cache.asd"
- #:tests? #f))))
+ `(#:tests? #f))))
(define-public cl-function-cache
(sbcl-package->cl-source-package sbcl-function-cache))
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-system-name "type-r"
- #:asd-file "type-r.asd"
- #:test-asd-file "type-r.test.asd")))))
+ `(#:test-asd-file "type-r.test.asd")))))
(define-public cl-type-r
(sbcl-package->cl-source-package sbcl-type-r))
+(define-public ecl-type-r
+ (sbcl-package->ecl-package sbcl-type-r))
+
(define-public sbcl-trivialib-type-unify
(let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
(revision "1"))
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-system-name "trivialib.type-unify"
- #:asd-file "trivialib.type-unify.asd"
+ `(#:asd-systems '("trivialib.type-unify")
#:test-asd-file "trivialib.type-unify.test.asd")))))
(define-public cl-trivialib-type-unify
(sbcl-package->cl-source-package sbcl-trivialib-type-unify))
+(define-public ecl-trivialib-type-unify
+ (sbcl-package->ecl-package sbcl-trivialib-type-unify))
+
(define-public sbcl-specialized-function
- (let ((commit "b96b6afaf8358bf91cc0703e62a5a4ee20d2b7bc")
- (revision "1"))
+ (let ((commit "dee56d2d2b6ecd10500ad291c56217698604ec35")
+ (revision "2"))
(package
(name "sbcl-specialized-function")
(version (git-version "0.0.0" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "12j45ff0n26578vmfbhb9mfbdchw4wy023k0m2ppgl9s0z4bhjaj"))))
+ (base32 "1mcc7mmpbnmgnr1cl2jl5r1ai54gn7fbisv2c14sh9za5w4sib82"))))
(build-system asdf-build-system/sbcl)
(synopsis "Julia-like dispatch for Common Lisp")
(description
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-system-name "specialized-function"
- #:asd-file "specialized-function.asd"
+ `(#:asd-files '("specialized-function.asd")
#:test-asd-file "specialized-function.test.asd")))))
(define-public cl-specialized-function
(sbcl-package->cl-source-package sbcl-specialized-function))
+(define-public ecl-specialized-function
+ (sbcl-package->ecl-package sbcl-specialized-function))
+
(define-public sbcl-constantfold
(let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
(revision "1"))
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-system-name "constantfold"
- #:asd-file "constantfold.asd"
+ `(#:asd-files '("constantfold.asd")
#:test-asd-file "constantfold.test.asd")))))
(define-public cl-constantfold
(sbcl-package->cl-source-package sbcl-constantfold))
+(define-public ecl-constantfold
+ (sbcl-package->ecl-package sbcl-constantfold))
+
(define-public sbcl-gtype
- (let ((commit "42275e3606242ae91e9c8dfa30c18ced50a35b66")
- (revision "1"))
+ (let ((commit "2442e32485635525af278ebd8fa69a27d5b8cf18")
+ (revision "2"))
(package
(name "sbcl-gtype")
(version (git-version "0.1" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "1f56dba998v945jcxhha391557n6md1ql25b7icfwwfivhmlaa9b"))))
+ (base32 "0hbkfdw00v7bsa6zbric34p5w6hfwxycccg8wc2faq0cxhsvpv9h"))))
(build-system asdf-build-system/sbcl)
(synopsis "C++/Julia-like parametric types in Common Lisp")
(description
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-system-name "gtype"
- #:asd-file "gtype.asd"
+ `(#:asd-files '("gtype.asd")
#:test-asd-file "gtype.test.asd")))))
(define-public cl-gtype
(sbcl-package->cl-source-package sbcl-gtype))
+(define-public ecl-gtype
+ (let ((pkg (sbcl-package->ecl-package sbcl-gtype)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; The tests fail on ECL with a COMPILE-FILE-ERROR for t/package.lisp.
+ ((#:tests? _ #f) #f))))))
+
(define-public sbcl-numcl
- (let ((commit "1cf7dfa59f763a24a501092870e9c5ee745d0c17")
- (revision "1"))
+ (let ((commit "3e8d40bf774e070e7af1d3dbf01bc8c37dbebd3a")
+ (revision "2"))
(package
(name "sbcl-numcl")
(version (git-version "0.1.0" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0i3jby9hf4ii7blivgyza80g0vmjfhk8537i5i7kqqk0i5sdnym2"))))
+ (base32 "1hqpr68f6xkxaj1hjjayyh97wcdmj51k20qrd3nsv1rcpmdc5ll4"))))
(build-system asdf-build-system/sbcl)
(synopsis "Numpy clone in Common Lisp")
(description
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-system-name "numcl"
- #:asd-file "numcl.asd"
- #:test-asd-file "numcl.test.asd")))))
+ `(#:asd-files '("numcl.asd")
+ #:test-asd-file "numcl.test.asd"
+ ;; Tests fail on SBCL with "Heap exhausted, game over",
+ ;; but they pass on ECL.
+ #:tests? #f)))))
(define-public cl-numcl
(sbcl-package->cl-source-package sbcl-numcl))
+(define-public ecl-numcl
+ (let ((pkg (sbcl-package->ecl-package sbcl-numcl)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:tests? _ #f) #t))))))
+
(define-public sbcl-pzmq
(let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
(revision "1"))
("let-plus" ,sbcl-let-plus)))
(inputs
`(("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
("zeromq" ,zeromq)))
(arguments
`(#:phases (modify-phases %standard-phases
(define-public cl-mysql
(sbcl-package->cl-source-package sbcl-cl-mysql))
-(define-public sbcl-simple-date
+(define-public ecl-cl-mysql
+ (sbcl-package->ecl-package sbcl-cl-mysql))
+
+(define-public sbcl-postmodern
(let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a")
(revision "1"))
(package
- (name "sbcl-simple-date")
+ (name "sbcl-postmodern")
(version (git-version "1.19" revision commit))
(source
(origin
(build-system asdf-build-system/sbcl)
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
- (synopsis "Basic date and time objects for Common Lisp")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("global-vars" ,sbcl-global-vars)
+ ("md5" ,sbcl-md5)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("usocket" ,sbcl-usocket)))
+ (arguments
+ ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
+ ;; cl-postgres/tests and s-sql/tests.
+ `(#:tests? #f
+ #:asd-systems '("postmodern"
+ "simple-date/postgres-glue")))
+ (synopsis "Common Lisp library for interacting with PostgreSQL")
(description
- "@code{simple-date} is a very basic implementation of date and time
-objects, used to support storing and retrieving time-related SQL types.")
- (home-page "https://marijnhaverbeke.nl/postmodern/")
- (license license:zlib))))
-
-(define-public cl-simple-date
- (sbcl-package->cl-source-package sbcl-simple-date))
-
-(define-public ecl-simple-date
- (sbcl-package->ecl-package sbcl-simple-date))
-
-(define-public sbcl-cl-postgres
- (package
- (inherit sbcl-simple-date)
- (name "sbcl-cl-postgres")
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)
- ("simple-date" ,sbcl-simple-date)))
- (inputs
- `(("md5" ,sbcl-md5)
- ("split-sequence" ,sbcl-split-sequence)
- ("usocket" ,sbcl-usocket)))
- (arguments
- `(#:tests? #f)) ; TODO: Break simple-date/postgres-glue circular dependency
- (synopsis "Common Lisp interface for PostgreSQL")
- (description
- "@code{cl-postgres} is a low-level library used for interfacing with
-a PostgreSQL server over a socket.")))
-
-(define-public cl-postgres
- (sbcl-package->cl-source-package sbcl-cl-postgres))
-
-(define-public ecl-cl-postgres
- (package
- (inherit (sbcl-package->ecl-package sbcl-cl-postgres))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-ecl
- (lambda _
- (substitute* "cl-postgres.asd"
- (("\\) \"usocket\"") " :ecl) \"usocket\""))
- #t)))
- #:tests? #f))))
-
-(define-public sbcl-simple-date-postgres-glue
- (package
- (inherit sbcl-simple-date)
- (name "sbcl-simple-date-postgres-glue")
- (inputs
- `(("cl-postgres" ,sbcl-cl-postgres)
- ("simple-date" ,sbcl-simple-date)))
- (arguments
- `(#:asd-file "simple-date.asd"
- #:asd-system-name "simple-date/postgres-glue"))))
-
-(define-public cl-simple-date-postgres-glue
- (sbcl-package->cl-source-package sbcl-simple-date-postgres-glue))
-
-(define-public sbcl-s-sql
- (package
- (inherit sbcl-simple-date)
- (name "sbcl-s-sql")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-postgres" ,sbcl-cl-postgres)))
- (arguments
- `(#:tests? #f)) ; TODO: Break postmodern circular dependency
- (synopsis "Lispy DSL for SQL")
- (description
- "@code{s-sql} is a Common Lisp library that can be used to compile
-s-expressions to strings of SQL code, escaping any Lisp values inside, and
-doing as much as possible of the work at compile time.")))
-
-(define-public cl-s-sql
- (sbcl-package->cl-source-package sbcl-s-sql))
-
-(define-public sbcl-postmodern
- (package
- (inherit sbcl-simple-date)
- (name "sbcl-postmodern")
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)
- ("simple-date" ,sbcl-simple-date)
- ("simple-date-postgres-glue" ,sbcl-simple-date-postgres-glue)))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cl-postgres" ,sbcl-cl-postgres)
- ("closer-mop" ,sbcl-closer-mop)
- ("global-vars" ,sbcl-global-vars)
- ("s-sql" ,sbcl-s-sql)
- ("split-sequence" ,sbcl-split-sequence)))
- (arguments
- ;; TODO: Fix missing dependency errors for simple-date/postgres-glue,
- ;; cl-postgres/tests and s-sql/tests.
- `(#:tests? #f))
- (synopsis "Common Lisp library for interacting with PostgreSQL")
- (description
- "@code{postmodern} is a Common Lisp library for interacting with
+ "@code{postmodern} is a Common Lisp library for interacting with
PostgreSQL databases. It provides the following features:
@itemize
@item A syntax for mixing SQL and Lisp code.
@item Convenient support for prepared statements and stored procedures.
@item A metaclass for simple database-access objects.
-@end itemize\n")))
+@end itemize\n")
+ (home-page "https://marijnhaverbeke.nl/postmodern/")
+ (license license:zlib))))
(define-public cl-postmodern
(sbcl-package->cl-source-package sbcl-postmodern))
+(define-public ecl-postmodern
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-postmodern))
+ (arguments
+ `(#:tests? #f
+ #:asd-systems '("postmodern"
+ "simple-date/postgres-glue")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "cl-postgres.asd"
+ (("\\) \"usocket\"")
+ " :ecl) \"usocket\""))
+ #t)))))))
+
(define-public sbcl-dbi
;; Master includes a breaking change which other packages depend on since
;; Quicklisp decided to follow it:
(sha256
(base32 "0r3n4rw12qqxad0cryym2ibm4ddl49gbq4ra227afibsr43nw5k3"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rove" ,sbcl-rove)
+ ("trivial-types" ,sbcl-trivial-types)))
(inputs
`(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-mysql" ,sbcl-cl-mysql)
+ ("cl-sqlite" ,sbcl-cl-sqlite)
("closer-mop" ,sbcl-closer-mop)
- ("split-sequence" ,sbcl-split-sequence)))
+ ("postmodern" ,sbcl-postmodern)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
(arguments
- `(#:tests? #f)) ; TODO: Break circular dependency with dbd-*
+ `(#:asd-systems '("dbi"
+ "dbd-mysql"
+ "dbd-postgres"
+ "dbd-sqlite3")))
(synopsis "Database independent interface for Common Lisp")
(description
"@code{dbi} is a Common Lisp library providing a database independent
(define-public cl-dbi
(sbcl-package->cl-source-package sbcl-dbi))
-(define-public sbcl-dbd-mysql
- (package
- (inherit sbcl-dbi)
- (name "sbcl-dbd-mysql")
- (inputs
- `(("cl-mysql" ,sbcl-cl-mysql)
- ("dbi" ,sbcl-dbi)))
- (synopsis "Database driver for MySQL")))
-
-(define-public cl-dbd-mysql
- (sbcl-package->cl-source-package sbcl-dbd-mysql))
-
-(define-public sbcl-dbd-postgres
- (package
- (inherit sbcl-dbi)
- (name "sbcl-dbd-postgres")
- (inputs
- `(("cl-postgres" ,sbcl-cl-postgres)
- ("dbi" ,sbcl-dbi)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (synopsis "Database driver for PostgreSQL")))
-
-(define-public cl-dbd-postgres
- (sbcl-package->cl-source-package sbcl-dbd-postgres))
-
-(define-public sbcl-dbd-sqlite3
- (package
- (inherit sbcl-dbi)
- (name "sbcl-dbd-sqlite3")
- (inputs
- `(("cl-sqlite" ,sbcl-cl-sqlite)
- ("dbi" ,sbcl-dbi)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (synopsis "Database driver for SQLite3")))
-
-(define-public cl-dbd-sqlite3
- (sbcl-package->cl-source-package sbcl-dbd-sqlite3))
+(define-public ecl-dbi
+ (sbcl-package->ecl-package sbcl-dbi))
(define-public sbcl-uffi
(package
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
+ #:asd-files '("uffi.asd")
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-permissions
;; asdf-build-system/source has its own phases and does not inherit
;; from asdf-build-system/sbcl phases.
(modify-phases %standard-phases/source
- (add-after 'unpack 'fix-permissions
- (lambda _
- (make-file-writable "doc/html.tar.gz")
- #t)))))))
+ ;; Already done in SBCL package.
+ (delete 'reset-gzip-timestamps))))))
(define-public sbcl-clsql
(package
#t))))
(build-system asdf-build-system/sbcl)
(native-inputs
- `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
- ("rt" ,sbcl-rt)
- ("uffi" ,sbcl-uffi)))
+ `(("rt" ,sbcl-rt)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("md5" ,sbcl-md5)
+ ("mysql" ,mysql)
+ ("postgresql" ,postgresql)
+ ("postmodern" ,sbcl-postmodern)
+ ("sqlite" ,sqlite)
+ ("uffi" ,sbcl-uffi)
+ ("zlib" ,zlib)))
(arguments
- `(#:phases
+ `(#:asd-files '("clsql.asd"
+ "clsql-uffi.asd"
+ "clsql-sqlite3.asd"
+ "clsql-postgresql.asd"
+ "clsql-postgresql-socket3.asd"
+ "clsql-mysql.asd")
+ #:asd-systems '("clsql"
+ "clsql-sqlite3"
+ "clsql-postgresql"
+ "clsql-postgresql-socket3"
+ "clsql-mysql")
+ #:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-permissions
(lambda _
(make-file-writable "doc/html.tar.gz")
#t))
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "clsql-uffi.asd"
+ (("\\(:version uffi \"2.0\"\\)")
+ "uffi"))
+ (substitute* "db-postgresql/postgresql-api.lisp"
+ (("\\(data :cstring\\)")
+ "(data :string)"))
+ #t))
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (substitute* "db-sqlite3/sqlite3-loader.lisp"
+ (("libsqlite3")
+ (string-append (assoc-ref inputs "sqlite")
+ "/lib/libsqlite3")))
+ (substitute* "db-postgresql/postgresql-loader.lisp"
+ (("libpq")
+ (string-append (assoc-ref inputs "postgresql")
+ "/lib/libpq")))
+ (let ((lib (string-append "#p\""
+ (assoc-ref outputs "out")
+ "/lib/\"")))
+ (substitute* "clsql-mysql.asd"
+ (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
+ lib))
+ (substitute* "db-mysql/mysql-loader.lisp"
+ (("libmysqlclient" all)
+ (string-append (assoc-ref inputs "mysql") "/lib/" all))
+ (("clsql-mysql-system::\\*library-file-dir\\*")
+ lib)))
+ #t))
+ (add-before 'build 'build-helper-library
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((mysql (assoc-ref inputs "mysql"))
+ (inc-dir (string-append mysql "/include/mysql"))
+ (lib-dir (string-append mysql "/lib"))
+ (shared-lib-dir (string-append (assoc-ref outputs "out")
+ "/lib"))
+ (shared-lib (string-append shared-lib-dir
+ "/clsql_mysql.so")))
+ (mkdir-p shared-lib-dir)
+ (invoke "gcc" "-fPIC" "-shared"
+ "-I" inc-dir
+ "db-mysql/clsql_mysql.c"
+ "-Wl,-soname=clsql_mysql"
+ "-L" lib-dir "-lmysqlclient" "-lz"
+ "-o" shared-lib)
+ #t)))
(add-after 'unpack 'fix-tests
(lambda _
(substitute* "clsql.asd"
("sqlite" ,sqlite)
("zlib" ,zlib)))
(propagated-inputs
- `(("cl-postgres" ,cl-postgres)
- ("cffi-uffi-compat" ,cl-cffi-uffi-compat)
+ `(("cffi" ,cl-cffi)
("md5" ,cl-md5)
+ ("postmodern" ,cl-postmodern)
("uffi" ,cl-uffi)))
(arguments
`(#:phases
(make-file-writable "doc/html.tar.gz")
#t)))))))
-(define-public sbcl-clsql-uffi
- (package
- (inherit sbcl-clsql)
- (name "sbcl-clsql-uffi")
- (inputs
- `(("cffi-uffi-compat" ,sbcl-cffi-uffi-compat)
- ("clsql" ,sbcl-clsql)
- ("uffi" ,sbcl-uffi)))
- (synopsis "UFFI helper functions for Common Lisp SQL interface library")))
-
-(define-public sbcl-clsql-sqlite3
- (package
- (inherit sbcl-clsql)
- (name "sbcl-clsql-sqlite3")
- (inputs
- `(("clsql" ,sbcl-clsql)
- ("clsql-uffi" ,sbcl-clsql-uffi)
- ("sqlite" ,sqlite)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-clsql)
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "db-sqlite3/sqlite3-loader.lisp"
- (("libsqlite3")
- (string-append (assoc-ref inputs "sqlite")
- "/lib/libsqlite3")))
- #t))))))
- (synopsis "SQLite3 driver for Common Lisp SQL interface library")))
-
-(define-public sbcl-clsql-postgresql
- (package
- (inherit sbcl-clsql)
- (name "sbcl-clsql-postgresql")
- (inputs
- `(("clsql" ,sbcl-clsql)
- ("clsql-uffi" ,sbcl-clsql-uffi)
- ("postgresql" ,postgresql)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-clsql)
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "db-postgresql/postgresql-loader.lisp"
- (("libpq")
- (string-append (assoc-ref inputs "postgresql")
- "/lib/libpq")))
- #t))))))
- (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
-
-(define-public sbcl-clsql-postgresql-socket3
- (package
- (inherit sbcl-clsql)
- (name "sbcl-clsql-postgresql-socket3")
- (inputs
- `(("cl-postgres" ,sbcl-cl-postgres)
- ("clsql" ,sbcl-clsql)
- ("md5" ,sbcl-md5)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-clsql)
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'create-asd-file 'fix-asd-file
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (lib (string-append out "/lib/" (%lisp-type)))
- (asd (string-append lib "/clsql-postgresql-socket3.asd")))
- (substitute* asd
- (("CLSQL-POSTGRESQL-SOCKET-SYSTEM::")
- "")))
- #t))))))
- (synopsis "PostgreSQL driver for Common Lisp SQL interface library")))
-
-(define-public sbcl-clsql-mysql
- (package
- (inherit sbcl-clsql)
- (name "sbcl-clsql-mysql")
- (inputs
- `(("mysql" ,mysql)
- ("sbcl-clsql" ,sbcl-clsql)
- ("sbcl-clsql-uffi" ,sbcl-clsql-uffi)
- ("zlib" ,zlib)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-clsql)
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((lib (string-append "#p\""
- (assoc-ref outputs "out")
- "/lib/\"")))
- (substitute* "clsql-mysql.asd"
- (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
- lib))
- (substitute* "db-mysql/mysql-loader.lisp"
- (("libmysqlclient" all)
- (string-append (assoc-ref inputs "mysql") "/lib/" all))
- (("clsql-mysql-system::\\*library-file-dir\\*")
- lib)))
- #t))
- (add-before 'build 'build-helper-library
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let* ((mysql (assoc-ref inputs "mysql"))
- (inc-dir (string-append mysql "/include/mysql"))
- (lib-dir (string-append mysql "/lib"))
- (shared-lib-dir (string-append (assoc-ref outputs "out")
- "/lib"))
- (shared-lib (string-append shared-lib-dir
- "/clsql_mysql.so")))
- (mkdir-p shared-lib-dir)
- (invoke "gcc" "-fPIC" "-shared"
- "-I" inc-dir
- "db-mysql/clsql_mysql.c"
- "-Wl,-soname=clsql_mysql"
- "-L" lib-dir "-lmysqlclient" "-lz"
- "-o" shared-lib)
- #t)))))))
- (synopsis "MySQL driver for Common Lisp SQL interface library")))
+(define-public ecl-clsql
+ (let ((pkg (sbcl-package->ecl-package sbcl-clsql)))
+ (package
+ (inherit pkg)
+ (inputs
+ (alist-delete "uffi" (package-inputs pkg)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:asd-files asd-files '())
+ `(cons "clsql-cffi.asd" ,asd-files)))))))
(define-public sbcl-sycamore
(let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
(sha256
(base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-file "src/sycamore.asd"))
(inputs
`(("alexandria" ,sbcl-alexandria)
("cl-ppcre" ,sbcl-cl-ppcre)))
(define-public cl-sycamore
(sbcl-package->cl-source-package sbcl-sycamore))
+(define-public ecl-sycamore
+ (sbcl-package->ecl-package sbcl-sycamore))
+
(define-public sbcl-trivial-package-local-nicknames
(package
(name "sbcl-trivial-package-local-nicknames")
(define-public cl-trivial-package-local-nicknames
(sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
+(define-public ecl-trivial-package-local-nicknames
+ (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames))
+
(define-public sbcl-enchant
(let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
(package
(define-public cl-enchant
(sbcl-package->cl-source-package sbcl-enchant))
+(define-public ecl-enchant
+ (sbcl-package->ecl-package sbcl-enchant))
+
(define-public sbcl-cl-change-case
(let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
(package
(define-public cl-change-case
(sbcl-package->cl-source-package sbcl-cl-change-case))
+(define-public ecl-cl-change-case
+ (sbcl-package->ecl-package sbcl-cl-change-case))
+
(define-public sbcl-moptilities
(let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
(package
`(("closer-mop" ,sbcl-closer-mop)))
(native-inputs
`(("lift" ,sbcl-lift)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "lift-standard.config"
+ ((":relative-to lift-test")
+ ":relative-to moptilities-test"))
+ #t)))))
(synopsis "Compatibility layer for Common Lisp MOP implementation differences")
(description
"MOP utilities provide a common interface between Lisps and make the
(sha256
(base32 "15viw5pi5sa7qq9b4n2rr3dj2jkqr180rh9z1lh8w3rgl42i2adc"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- ;; The cleanup phase moves files around but we need to keep the
- ;; directory structure for the grovel-generated library.
- (replace 'cleanup
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (lib (string-append out "/lib/sbcl/")))
- (delete-file-recursively (string-append lib "src"))
- (delete-file-recursively (string-append lib "tests"))
- (for-each delete-file
- (filter (lambda (file)
- (not (member (basename file) '("libosicat.so"))))
- (find-files (string-append lib "posix") ".*"))))
- #t)))))
(inputs
`(("alexandria" ,sbcl-alexandria)
("cffi" ,sbcl-cffi)
("trivial-features" ,sbcl-trivial-features)))
(native-inputs
- `(("cffi-grovel" ,sbcl-cffi-grovel)
- ("rt" ,sbcl-rt)))
+ `(("rt" ,sbcl-rt)))
(synopsis "Operating system interface for Common Lisp")
(description
"Osicat is a lightweight operating system interface for Common Lisp on
(define-public cl-osicat
(sbcl-package->cl-source-package sbcl-osicat))
+(define-public ecl-osicat
+ (sbcl-package->ecl-package sbcl-osicat))
+
(define-public sbcl-clx-xembed
(let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
(revision "1"))
(base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-system-name "xembed"))
+ `(#:asd-systems '("xembed")))
(inputs
`(("sbcl-clx" ,sbcl-clx)))
(synopsis "CL(x) xembed protocol implementation ")
"0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:asd-system-name "quantile-estimator"))
+ '(#:asd-files '("quantile-estimator.asd")))
(inputs
`(("alexandria" ,sbcl-alexandria)))
(home-page "https://github.com/deadtrickster/quantile-estimator.cl")
(inputs
`(("alexandria" ,sbcl-alexandria)
("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-fad" ,sbcl-cl-fad)
("cl-ppcre" ,sbcl-cl-ppcre)
+ ("drakma" ,sbcl-drakma)
+ ("hunchentoot" ,sbcl-hunchentoot)
("local-time" ,sbcl-local-time)
- ("quantile-estimator" ,sbcl-quantile-estimator)))
+ ("quantile-estimator" ,sbcl-quantile-estimator)
+ ("salza2" ,sbcl-salza2)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("trivial-utf-8" ,sbcl-trivial-utf-8)))
+ (arguments
+ '(#:asd-files '("prometheus.asd"
+ "prometheus.collectors.sbcl.asd"
+ "prometheus.collectors.process.asd"
+ "prometheus.formats.text.asd"
+ "prometheus.exposers.hunchentoot.asd"
+ "prometheus.pushgateway.asd")
+ #:asd-systems '("prometheus"
+ "prometheus.collectors.sbcl"
+ "prometheus.collectors.process"
+ "prometheus.formats.text"
+ "prometheus.exposers.hunchentoot"
+ "prometheus.pushgateway")))
(home-page "https://github.com/deadtrickster/prometheus.cl")
(synopsis "Prometheus.io Common Lisp client")
(description "Prometheus.io Common Lisp client.")
(define-public ecl-prometheus
(sbcl-package->ecl-package sbcl-prometheus))
-(define-public sbcl-prometheus.collectors.sbcl
- (package
- (inherit sbcl-prometheus)
- (name "sbcl-prometheus.collectors.sbcl")
- (inputs `(("prometheus" ,sbcl-prometheus)))
- (synopsis "Prometheus collector for SBCL metrics")
- (description "Prometheus collector for SBCL metrics.")))
-
-(define-public cl-prometheus.collectors.sbcl
- (sbcl-package->cl-source-package sbcl-prometheus.collectors.sbcl))
-
-(define-public sbcl-prometheus.collectors.process
- (package
- (inherit sbcl-prometheus)
- (name "sbcl-prometheus.collectors.process")
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
- ("cl-fad" ,sbcl-cl-fad)
- ("prometheus" ,sbcl-prometheus)
- ("split-sequence" ,sbcl-split-sequence)))
- (synopsis "Prometheus collector for process metrics")
- (description "Prometheus collector for process metrics.")))
-
-(define-public cl-prometheus.collectors.process
- (sbcl-package->cl-source-package sbcl-prometheus.collectors.process))
-
-(define-public ecl-prometheus.collectors.process
- (sbcl-package->ecl-package sbcl-prometheus.collectors.process))
-
-(define-public sbcl-prometheus.formats.text
- (package
- (inherit sbcl-prometheus)
- (name "sbcl-prometheus.formats.text")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("prometheus" ,sbcl-prometheus)))
- (synopsis "Prometheus client text format")
- (description "Prometheus client text format.")))
-
-(define-public cl-prometheus.formats.text
- (sbcl-package->cl-source-package sbcl-prometheus.formats.text))
-
-(define-public ecl-prometheus.formats.text
- (sbcl-package->ecl-package sbcl-prometheus.formats.text))
-
-(define-public sbcl-prometheus.exposers.hunchentoot
- (package
- (inherit sbcl-prometheus)
- (name "sbcl-prometheus.exposers.hunchentoot")
- (inputs
- `(("hunchentoot" ,sbcl-hunchentoot)
- ("prometheus" ,sbcl-prometheus)
- ("prometheus.formats.text" ,sbcl-prometheus.formats.text)
- ("salza2" ,sbcl-salza2)
- ("trivial-utf-8" ,sbcl-trivial-utf-8)))
- (synopsis "Prometheus collector for Hunchentoot metrics")
- (description "Prometheus collector for Hunchentoot metrics")))
-
-(define-public cl-prometheus.exposers.hunchentoot
- (sbcl-package->cl-source-package sbcl-prometheus.exposers.hunchentoot))
-
-(define-public sbcl-prometheus.pushgateway
- (package
- (inherit sbcl-prometheus)
- (name "sbcl-prometheus.pushgateway")
- (inputs
- `(("drakma" ,sbcl-drakma)
- ("prometheus" ,sbcl-prometheus)
- ("prometheus.formats.text" ,sbcl-prometheus.formats.text)))
- (synopsis "Prometheus Pushgateway client")
- (description "Prometheus Pushgateway client.")))
-
-(define-public cl-prometheus.pushgateway
- (sbcl-package->cl-source-package sbcl-prometheus.pushgateway))
-
-(define-public ecl-prometheus.pushgateway
- (sbcl-package->ecl-package sbcl-prometheus.pushgateway))
-
(define-public sbcl-uuid
(let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
(package
(define-public ecl-dissect
(sbcl-package->ecl-package sbcl-dissect))
-;; TODO: Uses ASDF's package-inferred-system which is not supported by
-;; asdf-build-system/sbcl as of 2020-05-21. We should fix
-;; asdf-build-system/sbcl.
(define-public sbcl-rove
(package
(name "sbcl-rove")
`(#:test-asd-file "sxql-test.asd"))
(inputs
`(("alexandria" ,sbcl-alexandria)
- ("cl-syntax-annot" ,sbcl-cl-syntax-annot)
+ ("cl-syntax" ,sbcl-cl-syntax)
("iterate" ,sbcl-iterate)
("optima" ,sbcl-optima)
("split-sequence" ,sbcl-split-sequence)
("trivial-types" ,sbcl-trivial-types)))
(native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
+ `(("prove" ,sbcl-prove)))
(home-page "https://github.com/fukamachi/sxql")
(synopsis "SQL generator for Common Lisp")
(description "SQL generator for Common Lisp.")
"05ss4nz1jb9kb796295482b62w5cj29msfj8zis33sp2rw2vmv2g"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-system-name "1am"))
+ `(#:asd-systems '("1am")))
(home-page "https://github.com/lmj/1am")
(synopsis "Minimal testing framework for Common Lisp")
(description "A minimal testing framework for Common Lisp.")
(substitute* "src/low-level/librdkafka-bindings.lisp"
(("librdkafka" all)
(string-append (assoc-ref inputs "librdkafka") "/lib/"
- all)))))
- (add-before 'cleanup 'move-bundle
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (actual (string-append out "/lib/sbcl/src/cl-rdkafka.fasl"))
- (expected (string-append
- out "/lib/sbcl/cl-rdkafka--system.fasl")))
- (copy-file actual expected)
- #t))))))
+ all))))))))
(inputs
`(("bordeaux-threads" ,sbcl-bordeaux-threads)
("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
("librdkafka" ,librdkafka)
("lparallel" ,sbcl-lparallel)
("trivial-garbage" ,sbcl-trivial-garbage)))
(define-public cl-rdkafka
(sbcl-package->cl-source-package sbcl-cl-rdkafka))
+(define-public ecl-cl-rdkafka
+ (sbcl-package->ecl-package sbcl-cl-rdkafka))
+
(define-public sbcl-acclimation
(let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
(package
(define-public cl-acclimation
(sbcl-package->cl-source-package sbcl-acclimation))
-(define-public sbcl-clump-2-3-tree
+(define-public ecl-acclimation
+ (sbcl-package->ecl-package sbcl-acclimation))
+
+(define-public sbcl-clump
(let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
(package
- (name "sbcl-clump-2-3-tree")
+ (name "sbcl-clump")
(version (git-version "0.0.0" "1" commit))
(source
(origin
(sha256
(base32
"1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
- (arguments
- '(#:asd-file "2-3-tree/clump-2-3-tree.asd"
- #:asd-system-name "clump-2-3-tree"))
(inputs
`(("acclimation" ,sbcl-acclimation)))
(build-system asdf-build-system/sbcl)
(home-page "https://github.com/robert-strandh/Clump")
- (synopsis "Implementation of 2-3 trees for Common Lisp")
+ (synopsis "Collection of tree implementations for Common Lisp")
(description "The purpose of this library is to provide a collection of
implementations of trees.
sequences of objects.")
(license license:bsd-2))))
-(define-public sbcl-clump-binary-tree
- (package
- (inherit sbcl-clump-2-3-tree)
- (name "sbcl-clump-binary-tree")
- (arguments
- '(#:asd-file "Binary-tree/clump-binary-tree.asd"
- #:asd-system-name "clump-binary-tree"))
- (synopsis "Implementation of binary trees for Common Lisp")))
-
-(define-public sbcl-clump
- (package
- (inherit sbcl-clump-2-3-tree)
- (name "sbcl-clump")
- (arguments
- '(#:asd-file "clump.asd"
- #:asd-system-name "clump"))
- (inputs
- `(("clump-2-3-tree" ,sbcl-clump-2-3-tree)
- ("clump-binary-tree" ,sbcl-clump-binary-tree)))
- (synopsis "Collection of tree implementations for Common Lisp")))
-
(define-public cl-clump
(sbcl-package->cl-source-package sbcl-clump))
-(define-public sbcl-cluffer-base
+(define-public ecl-clump
+ (sbcl-package->ecl-package sbcl-clump))
+
+(define-public sbcl-cluffer
(let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
(package
- (name "sbcl-cluffer-base")
+ (name "sbcl-cluffer")
(version (git-version "0.0.0" "1" commit))
(source
(origin
(sha256
(base32
"1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
- (arguments
- '(#:asd-file "Base/cluffer-base.asd"
- #:asd-system-name "cluffer-base"))
- (inputs
- `(("acclimation" ,sbcl-acclimation)))
(build-system asdf-build-system/sbcl)
+ (inputs
+ `(("acclimation" ,sbcl-acclimation)
+ ("clump" ,sbcl-clump)))
(home-page "https://github.com/robert-strandh/cluffer")
(synopsis "Common Lisp library providing a protocol for text-editor buffers")
(description "Cluffer is a library for representing the buffer of a text
implementations of those protocols for different purposes.")
(license license:bsd-2))))
-(define-public sbcl-cluffer-standard-line
- (package
- (inherit sbcl-cluffer-base)
- (name "sbcl-cluffer-standard-line")
- (arguments
- '(#:asd-file "Standard-line/cluffer-standard-line.asd"
- #:asd-system-name "cluffer-standard-line"))
- (inputs
- `(("cluffer-base" ,sbcl-cluffer-base)))))
-
-(define-public sbcl-cluffer-standard-buffer
- (package
- (inherit sbcl-cluffer-base)
- (name "sbcl-cluffer-standard-buffer")
- (arguments
- '(#:asd-file "Standard-buffer/cluffer-standard-buffer.asd"
- #:asd-system-name "cluffer-standard-buffer"))
- (inputs
- `(("cluffer-base" ,sbcl-cluffer-base)
- ("clump" ,sbcl-clump)))))
-
-(define-public sbcl-cluffer-simple-line
- (package
- (inherit sbcl-cluffer-base)
- (name "sbcl-cluffer-simple-line")
- (arguments
- '(#:asd-file "Simple-line/cluffer-simple-line.asd"
- #:asd-system-name "cluffer-simple-line"))
- (inputs
- `(("cluffer-base" ,sbcl-cluffer-base)))))
-
-(define-public sbcl-cluffer-simple-buffer
- (package
- (inherit sbcl-cluffer-base)
- (name "sbcl-cluffer-simple-buffer")
- (arguments
- '(#:asd-file "Simple-buffer/cluffer-simple-buffer.asd"
- #:asd-system-name "cluffer-simple-buffer"))
- (inputs
- `(("cluffer-base" ,sbcl-cluffer-base)))))
-
-(define-public sbcl-cluffer
- (package
- (inherit sbcl-cluffer-base)
- (name "sbcl-cluffer")
- (arguments
- '(#:asd-file "cluffer.asd"
- #:asd-system-name "cluffer"))
- (inputs
- `(("cluffer-base" ,sbcl-cluffer-base)
- ("cluffer-standard-line" ,sbcl-cluffer-standard-line)
- ("cluffer-standard-buffer" ,sbcl-cluffer-standard-buffer)
- ("cluffer-simple-line" ,sbcl-cluffer-simple-line)
- ("cluffer-simple-buffer" ,sbcl-cluffer-simple-buffer)))))
-
(define-public cl-cluffer
(sbcl-package->cl-source-package sbcl-cluffer))
+(define-public ecl-cluffer
+ (sbcl-package->ecl-package sbcl-cluffer))
+
(define-public sbcl-cl-libsvm-format
(let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
(revision "0"))
"0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
+ `(("prove" ,sbcl-prove)))
(inputs
`(("alexandria" ,sbcl-alexandria)))
(synopsis "LibSVM data format reader for Common Lisp")
"14x95rlg80ay5hv645ki57pqvy12v28hz4k1w0f6bsfi2rmpxchq"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
+ `(("prove" ,sbcl-prove)))
(inputs
`(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
("cl-store" ,sbcl-cl-store)))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)
("trivial-garbage" ,sbcl-trivial-garbage)))
(inputs
`(("alexandria" ,sbcl-alexandria)
(inputs
`(("alexandria" ,sbcl-alexandria)
("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
("freetype" ,freetype)
("trivial-garbage" ,sbcl-trivial-garbage)))
(arguments
(("\"libfreetype\"")
(string-append "\"" (assoc-ref inputs "freetype")
"/lib/libfreetype\"")))
- (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
- (("-I/usr/include/freetype")
- (string-append "-I" (assoc-ref inputs "freetype")
- "/include/freetype")))
- #t)))))
- (home-page "https://github.com/rpav/cl-freetype2")
- (synopsis "Common Lisp bindings for Freetype 2")
- (description
- "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's
-geared toward both using Freetype directly by providing a simplified API, as
-well as providing access to the underlying C structures and functions for use
-with other libraries which may also use Freetype.")
- (license license:bsd-3))))
-
-(define-public cl-freetype2
- (sbcl-package->cl-source-package sbcl-cl-freetype2))
-
-(define-public ecl-cl-freetype2
- (sbcl-package->ecl-package sbcl-cl-freetype2))
-
-(define-public sbcl-opticl-core
- (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
- (revision "0"))
- (package
- (name "sbcl-opticl-core")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/slyrus/opticl-core")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (home-page "https://github.com/slyrus/opticl-core")
- (synopsis "Core classes and pixel access macros for Opticl")
- (description
- "This Common Lisp library contains the core classes and pixel access
-macros for the Opticl image processing library.")
- (license license:bsd-2))))
-
-(define-public cl-opticl-core
- (sbcl-package->cl-source-package sbcl-opticl-core))
-
-(define-public ecl-opticl-core
- (sbcl-package->ecl-package sbcl-opticl-core))
-
-(define-public sbcl-retrospectiff
- (let ((commit "c2a69d77d5010f8cdd9045b3e36a08a73da5d321")
- (revision "0"))
- (package
- (name "sbcl-retrospectiff")
- (version (git-version "0.2" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/slyrus/retrospectiff")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0qsn9hpd8j2kp43dk05j8dczz9zppdff5rrclbp45n3ksk9inw8i"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("cl-jpeg" ,sbcl-cl-jpeg)
- ("com.gigamonkeys.binary-data" ,sbcl-com.gigamonkeys.binary-data)
- ("deflate" ,sbcl-deflate)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("ieee-floats" ,sbcl-ieee-floats)
- ("opticl-core" ,sbcl-opticl-core)))
- (home-page "https://github.com/slyrus/retrospectiff")
- (synopsis "Common Lisp library for TIFF images")
- (description
- "Retrospectiff is a common lisp library for reading and writing images
-in the TIFF (Tagged Image File Format) format.")
- (license license:bsd-2))))
-
-(define-public cl-retrospectif
- (sbcl-package->cl-source-package sbcl-retrospectiff))
-
-(define-public ecl-retrospectiff
- (sbcl-package->ecl-package sbcl-retrospectiff))
-
-(define-public sbcl-mmap
- (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
- (revision "0"))
- (package
- (name "sbcl-mmap")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/mmap")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("parachute" ,sbcl-parachute)
- ("trivial-features" ,sbcl-trivial-features)))
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("documentation-utils" ,sbcl-documentation-utils)))
- (home-page "https://shinmera.github.io/mmap/")
- (synopsis "File memory mapping for Common Lisp")
- (description
- "This is a utility library providing access to the @emph{mmap} family of
-functions in a portable way. It allows you to directly map a file into the
-address space of your process without having to manually read it into memory
-sequentially. Typically this is much more efficient for files that are larger
-than a few Kb.")
- (license license:zlib))))
-
-(define-public cl-mmap
- (sbcl-package->cl-source-package sbcl-mmap))
-
-(define-public ecl-mmap
- (sbcl-package->ecl-package sbcl-mmap))
-
-(define-public sbcl-3bz
- (let ((commit "d6119083b5e0b0a6dd3abc2877936c51f3f3deed")
- (revision "0"))
- (package
- (name "sbcl-3bz")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/3b/3bz")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0fyxzyf2b6sc0w8d9g4nlva861565z6f3xszj0lw29x526dd9rhj"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)
- ("cffi" ,sbcl-cffi)
- ("mmap" ,sbcl-mmap)
- ("nibbles" ,sbcl-nibbles)
- ("trivial-features" ,sbcl-trivial-features)))
- (arguments
- ;; FIXME: Without the following line, the build fails (see issue 41437).
- `(#:asd-system-name "3bz"))
- (home-page "https://github.com/3b/3bz")
- (synopsis "Deflate decompression for Common Lisp")
- (description
- "3bz is an implementation of Deflate decompression (RFC 1951) optionally
-with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
-foreign pointers (for use with mmap and similar, etc), and from CL octet
-vectors and streams.")
- (license license:expat))))
-
-(define-public cl-3bz
- (sbcl-package->cl-source-package sbcl-3bz))
-
-(define-public ecl-3bz
- (sbcl-package->ecl-package sbcl-3bz))
-
-(define-public sbcl-zpb-exif
- (package
- (name "sbcl-zpb-exif")
- (version "1.2.4")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/xach/zpb-exif")
- (commit (string-append "release-" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "15s227jhby55cisz14xafb0p1ws2jmrg2rrbbd00lrb97im84hy6"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://xach.com/lisp/zpb-exif/")
- (synopsis "EXIF information extractor for Common Lisp")
- (description
- "This is a Common Lisp library to extract EXIF information from image
-files.")
- (license license:bsd-2)))
-
-(define-public cl-zpb-exif
- (sbcl-package->cl-source-package sbcl-zpb-exif))
-
-(define-public ecl-zpb-exif
- (sbcl-package->ecl-package sbcl-zpb-exif))
-
-(define-public sbcl-pngload
- (package
- (name "sbcl-pngload")
- (version "2.0.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/bufferswap/pngload")
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1ix8dd0fxlf8xm0bszh1s7sx83hn0vqq8b8c9gkrd5m310w8mpvh"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("3bz" ,sbcl-3bz)
- ("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("mmap" ,sbcl-mmap)
- ("parse-float" ,sbcl-parse-float)
- ("static-vectors" ,sbcl-static-vectors)
- ("swap-bytes" ,sbcl-swap-bytes)
- ("zpb-exif" ,sbcl-zpb-exif)))
- (arguments
- ;; Test suite disabled because of a dependency cycle.
- ;; pngload tests depend on opticl which depends on pngload.
- '(#:tests? #f))
- (home-page "https://github.com/bufferswap/pngload")
- (synopsis "PNG image decoder for Common Lisp")
- (description
- "This is a Common Lisp library to load images in the PNG image format,
-both from files on disk, or streams in memory.")
- (license license:expat)))
+ (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
+ (("-I/usr/include/freetype")
+ (string-append "-I" (assoc-ref inputs "freetype")
+ "/include/freetype")))
+ #t)))))
+ (home-page "https://github.com/rpav/cl-freetype2")
+ (synopsis "Common Lisp bindings for Freetype 2")
+ (description
+ "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's
+geared toward both using Freetype directly by providing a simplified API, as
+well as providing access to the underlying C structures and functions for use
+with other libraries which may also use Freetype.")
+ (license license:bsd-3))))
-(define-public cl-pngload
- (sbcl-package->cl-source-package sbcl-pngload))
+(define-public cl-freetype2
+ (sbcl-package->cl-source-package sbcl-cl-freetype2))
-(define-public ecl-pngload
- (sbcl-package->ecl-package sbcl-pngload))
+(define-public ecl-cl-freetype2
+ (sbcl-package->ecl-package sbcl-cl-freetype2))
-(define-public sbcl-opticl
- (let ((commit "e8684416eca2e78e82a7b436d436ef2ea24c019d")
+(define-public sbcl-opticl-core
+ (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
(revision "0"))
(package
- (name "sbcl-opticl")
+ (name "sbcl-opticl-core")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slyrus/opticl")
+ (url "https://github.com/slyrus/opticl-core")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "03rirnnhhisjbimlmpi725h1d3x0cfv00r57988am873dyzawmm1"))))
+ (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-jpeg" ,sbcl-cl-jpeg)
- ("cl-tga" ,sbcl-cl-tga)
- ("png-read" ,sbcl-png-read)
- ("pngload" ,sbcl-pngload)
- ("retrospectiff" ,sbcl-retrospectiff)
- ("skippy" ,sbcl-skippy)
- ("zpng" ,sbcl-zpng)))
- (home-page "https://github.com/slyrus/opticl")
- (synopsis "Image processing library for Common Lisp")
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/slyrus/opticl-core")
+ (synopsis "Core classes and pixel access macros for Opticl")
(description
- "Opticl is a Common Lisp library for representing, processing, loading,
-and saving 2-dimensional pixel-based images.")
+ "This Common Lisp library contains the core classes and pixel access
+macros for the Opticl image processing library.")
(license license:bsd-2))))
-(define-public cl-opticl
- (sbcl-package->cl-source-package sbcl-opticl))
+(define-public cl-opticl-core
+ (sbcl-package->cl-source-package sbcl-opticl-core))
-(define-public sbcl-clim-lisp
- (let ((commit "27b4d7a667c9b3faa74cabcb57706b888314fff7")
+(define-public ecl-opticl-core
+ (sbcl-package->ecl-package sbcl-opticl-core))
+
+(define-public sbcl-retrospectiff
+ (let ((commit "c2a69d77d5010f8cdd9045b3e36a08a73da5d321")
(revision "0"))
(package
- (name "sbcl-clim-lisp")
- (version (git-version "0.9.7" revision commit))
+ (name "sbcl-retrospectiff")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mcclim/mcclim")
+ (url "https://github.com/slyrus/retrospectiff")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0jijfgkwas6xnpp5wiii6slcx9pgsalngacb8zm29x6pamx2193h"))))
+ (base32 "0qsn9hpd8j2kp43dk05j8dczz9zppdff5rrclbp45n3ksk9inw8i"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("closer-mop" ,sbcl-closer-mop)
- ("log4cl" ,sbcl-log4cl)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (home-page "https://common-lisp.net/project/mcclim/")
- (synopsis "Common Lisp GUI toolkit")
+ `(("cl-jpeg" ,sbcl-cl-jpeg)
+ ("com.gigamonkeys.binary-data" ,sbcl-com.gigamonkeys.binary-data)
+ ("deflate" ,sbcl-deflate)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("opticl-core" ,sbcl-opticl-core)))
+ (home-page "https://github.com/slyrus/retrospectiff")
+ (synopsis "Common Lisp library for TIFF images")
(description
- "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
-specification}, a toolkit for writing GUIs in Common Lisp.")
- (license license:lgpl2.1+))))
-
-(define-public sbcl-clim-basic
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-clim-basic")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("clim-lisp" ,sbcl-clim-lisp)
- ("flexichain" ,sbcl-flexichain)
- ("spatial-trees" ,sbcl-spatial-trees)
- ("trivial-features" ,sbcl-trivial-features)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (arguments
- '(#:asd-file "Core/clim-basic/clim-basic.asd"))))
-
-(define-public sbcl-clim-core
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-clim-core")
- (inputs
- `(("clim-basic" ,sbcl-clim-basic)))
- (arguments
- '(#:asd-file "Core/clim-core/clim-core.asd"))))
-
-(define-public sbcl-esa-mcclim
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-esa-mcclim")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("clim-core" ,sbcl-clim-core)))
- (arguments
- '(#:asd-file "Libraries/ESA/esa-mcclim.asd"))))
-
-(define-public sbcl-mcclim-fonts
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-fonts")
- (inputs
- `(("clim-basic" ,sbcl-clim-basic)))
- (arguments
- '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"))))
-
-(define-public sbcl-automaton
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-automaton")
- (inputs
- `())
- (arguments
- '(#:asd-file "Libraries/Drei/cl-automaton/automaton.asd"))))
-
-(define-public sbcl-persistent
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-persistent")
- (inputs
- `())
- (arguments
- '(#:asd-file "Libraries/Drei/Persistent/persistent.asd"))))
-
-(define-public sbcl-drei-mcclim
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-drei-mcclim")
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("automaton" ,sbcl-automaton)
- ("clim-core" ,sbcl-clim-core)
- ("esa-mcclim" ,sbcl-esa-mcclim)
- ("flexichain" ,sbcl-flexichain)
- ("mcclim-fonts" ,sbcl-mcclim-fonts)
- ("persistent" ,sbcl-persistent)
- ("swank" ,cl-slime-swank)))
- (arguments
- '(#:asd-file "Libraries/Drei/drei-mcclim.asd"))))
-
-(define-public sbcl-clim
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-clim")
- (inputs
- `(("clim-core" ,sbcl-clim-core)
- ("drei-mcclim" ,sbcl-drei-mcclim)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Core/clim/clim.asd"))))
-
-(define-public sbcl-mcclim-backend-common
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-backend-common")
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("clim" ,sbcl-clim)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/common/mcclim-backend-common.asd"))))
-
-(define-public sbcl-mcclim-clx
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-clx")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-unicode" ,sbcl-cl-unicode)
- ("clx" ,sbcl-clx)
- ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
- ("mcclim-fonts" ,sbcl-mcclim-fonts)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/CLX/mcclim-clx.asd"))))
-
-(define-public sbcl-mcclim-fonts-truetype
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-fonts-truetype")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-aa" ,sbcl-cl-aa)
- ("cl-paths-ttf" ,sbcl-cl-paths-ttf)
- ("cl-vectors" ,sbcl-cl-vectors)
- ("clim-basic" ,sbcl-clim-basic)
- ("font-dejavu" ,font-dejavu)
- ("zpb-ttf" ,sbcl-zpb-ttf)))
- (arguments
- '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"
- #:asd-system-name "mcclim-fonts/truetype"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- ;; mcclim-truetype uses DejaVu as default font and
- ;; sets the path at build time.
- (substitute* "Extensions/fonts/fontconfig.lisp"
- (("/usr/share/fonts/truetype/dejavu/")
- (string-append (assoc-ref inputs "font-dejavu")
- "/share/fonts/truetype/")))
- #t)))))))
-
-(define-public sbcl-mcclim-fonts-clx-truetype
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-fonts-clx-truetype")
- (inputs
- `(("mcclim-clx" ,sbcl-mcclim-clx)
- ("mcclim-fonts-truetype" ,sbcl-mcclim-fonts-truetype)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "./Extensions/fonts/mcclim-fonts.asd"
- #:asd-system-name "mcclim-fonts/clx-truetype"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "Extensions/fonts/mcclim-fonts.asd"
- ((":depends-on \\(#:mcclim-fonts/truetype")
- ":depends-on (#:mcclim-fonts-truetype"))
- #t)))))))
-
-(define-public sbcl-mcclim-clx-truetype
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-clx-truetype")
- (inputs
- `(("mcclim-clx" ,sbcl-mcclim-clx)
- ("mcclim-fonts-clx-truetype" ,sbcl-mcclim-fonts-clx-truetype)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/CLX/mcclim-clx.asd"
- #:asd-system-name "mcclim-clx/truetype"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "Backends/CLX/mcclim-clx.asd"
- (("mcclim-fonts/clx-truetype")
- "mcclim-fonts-clx-truetype"))
- #t)))))))
-
-(define-public sbcl-mcclim-fontconfig
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-fontconfig")
- (native-inputs
- `(("pkg-config" ,pkg-config)))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
- ("fontconfig" ,fontconfig)))
- (arguments
- '(#:asd-file "Extensions/fontconfig/mcclim-fontconfig.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "Extensions/fontconfig/src/functions.lisp"
- (("libfontconfig\\.so")
- (string-append (assoc-ref inputs "fontconfig")
- "/lib/libfontconfig.so")))
- #t))
- (add-after 'unpack 'fix-build
- (lambda _
- ;; The cffi-grovel system does not get loaded automatically,
- ;; so we load it explicitly.
- (substitute* "Extensions/fontconfig/mcclim-fontconfig.asd"
- (("\\(asdf:defsystem #:mcclim-fontconfig" all)
- (string-append "(asdf:load-system :cffi-grovel)\n" all)))
- #t)))))))
-
-(define-public sbcl-mcclim-harfbuzz
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-harfbuzz")
- (native-inputs
- `(("pkg-config" ,pkg-config)))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cffi-grovel" ,sbcl-cffi-grovel)
- ("freetype" ,freetype)
- ("harfbuzz" ,harfbuzz)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (arguments
- '(#:asd-file "Extensions/harfbuzz/mcclim-harfbuzz.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "Extensions/harfbuzz/src/functions.lisp"
- (("libharfbuzz\\.so")
- (string-append (assoc-ref inputs "harfbuzz")
- "/lib/libharfbuzz.so")))
- #t))
- (add-after 'unpack 'fix-build
- (lambda _
- ;; The cffi-grovel system does not get loaded automatically,
- ;; so we load it explicitly.
- (substitute* "Extensions/harfbuzz/mcclim-harfbuzz.asd"
- (("\\(asdf:defsystem #:mcclim-harfbuzz" all)
- (string-append "(asdf:load-system :cffi-grovel)\n" all)))
- #t)))))))
+ "Retrospectiff is a common lisp library for reading and writing images
+in the TIFF (Tagged Image File Format) format.")
+ (license license:bsd-2))))
-(define-public sbcl-mcclim-fonts-clx-freetype
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-fonts-clx-freetype")
- (inputs
- `(("cl-freetype2" ,sbcl-cl-freetype2)
- ("mcclim-clx" ,sbcl-mcclim-clx)
- ("mcclim-fontconfig" ,sbcl-mcclim-fontconfig)
- ("mcclim-fonts" ,sbcl-mcclim-fonts)
- ("mcclim-harfbuzz" ,sbcl-mcclim-harfbuzz)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"
- #:asd-system-name "mcclim-fonts/clx-freetype"))))
+(define-public cl-retrospectif
+ (sbcl-package->cl-source-package sbcl-retrospectiff))
-(define-public sbcl-mcclim-clx-freetype
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-clx-freetype")
- (inputs
- `(("mcclim-clx" ,sbcl-mcclim-clx)
- ("mcclim-fonts-clx-freetype" ,sbcl-mcclim-fonts-clx-freetype)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/CLX/mcclim-clx.asd"
- #:asd-system-name "mcclim-clx/freetype"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "Backends/CLX/mcclim-clx.asd"
- (("mcclim-fonts/clx-freetype")
- "mcclim-fonts-clx-freetype"))
- #t)))))))
+(define-public ecl-retrospectiff
+ (sbcl-package->ecl-package sbcl-retrospectiff))
-(define-public sbcl-mcclim-render
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-render")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-vectors" ,sbcl-cl-vectors)
- ("clim-basic" ,sbcl-clim-basic)
- ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
- ("mcclim-fonts-truetype" ,sbcl-mcclim-fonts-truetype)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Extensions/render/mcclim-render.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "Extensions/render/mcclim-render.asd"
- (("mcclim-fonts/truetype")
- "mcclim-fonts-truetype"))
- #t)))))))
+(define-public sbcl-mmap
+ (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
+ (revision "0"))
+ (package
+ (name "sbcl-mmap")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/mmap")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("parachute" ,sbcl-parachute)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("documentation-utils" ,sbcl-documentation-utils)))
+ (home-page "https://shinmera.github.io/mmap/")
+ (synopsis "File memory mapping for Common Lisp")
+ (description
+ "This is a utility library providing access to the @emph{mmap} family of
+functions in a portable way. It allows you to directly map a file into the
+address space of your process without having to manually read it into memory
+sequentially. Typically this is much more efficient for files that are larger
+than a few Kb.")
+ (license license:zlib))))
-(define-public sbcl-mcclim-clx-fb
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-clx-fb")
- (inputs
- `(("mcclim-backend-common" ,sbcl-mcclim-backend-common)
- ("mcclim-clx" ,sbcl-mcclim-clx)
- ("mcclim-render" ,sbcl-mcclim-render)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/CLX-fb/mcclim-clx-fb.asd"))))
+(define-public cl-mmap
+ (sbcl-package->cl-source-package sbcl-mmap))
-(define-public sbcl-mcclim-null
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-null")
- (inputs
- `(("clim" ,sbcl-clim)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/Null/mcclim-null.asd"))))
+(define-public ecl-mmap
+ (sbcl-package->ecl-package sbcl-mmap))
-(define-public sbcl-clim-postscript-font
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-clim-postscript-font")
- (inputs
- `(("clim-basic" ,sbcl-clim-basic)
- ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/PostScript/clim-postscript-font.asd"))))
+(define-public sbcl-3bz
+ (let ((commit "d6119083b5e0b0a6dd3abc2877936c51f3f3deed")
+ (revision "0"))
+ (package
+ (name "sbcl-3bz")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/3b/3bz")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0fyxzyf2b6sc0w8d9g4nlva861565z6f3xszj0lw29x526dd9rhj"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("cffi" ,sbcl-cffi)
+ ("mmap" ,sbcl-mmap)
+ ("nibbles" ,sbcl-nibbles)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (arguments
+ ;; FIXME: Without the following line, the build fails (see issue 41437).
+ `(#:asd-systems '("3bz")))
+ (home-page "https://github.com/3b/3bz")
+ (synopsis "Deflate decompression for Common Lisp")
+ (description
+ "3bz is an implementation of Deflate decompression (RFC 1951) optionally
+with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
+foreign pointers (for use with mmap and similar, etc), and from CL octet
+vectors and streams.")
+ (license license:expat))))
-(define-public sbcl-clim-postscript
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-clim-postscript")
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("clim-basic" ,sbcl-clim-basic)
- ("clim-postscript-font" ,sbcl-clim-postscript-font)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/PostScript/clim-postscript.asd"
- ;; Test suite disabled because of a dependency cycle.
- ;; The tests depend on mcclim/test-util, which depends on mcclim,
- ;; wich depends on mcclim/extensions, which depends on clim-postscript.
- #:tests? #f))))
+(define-public cl-3bz
+ (sbcl-package->cl-source-package sbcl-3bz))
-(define-public sbcl-clim-pdf
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-clim-pdf")
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("cl-pdf" ,sbcl-cl-pdf)
- ("clim-basic" ,sbcl-clim-basic)
- ("clim-postscript-font" ,sbcl-clim-postscript-font)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Backends/PDF/clim-pdf.asd"
- ;; Test suite disabled because of a dependency cycle.
- ;; The tests depend on mcclim/test-util, which depends on mcclim,
- ;; wich depends on mcclim/extensions, which depends on clim-pdf.
- #:tests? #f))))
+(define-public ecl-3bz
+ (sbcl-package->ecl-package sbcl-3bz))
-(define-public sbcl-mcclim-looks
+(define-public sbcl-zpb-exif
(package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-looks")
- (inputs
- `(("clim" ,sbcl-clim)
- ("mcclim-clx" ,sbcl-mcclim-clx)
- ("mcclim-clx-fb" ,sbcl-mcclim-clx-fb)
- ("mcclim-clx-freetype" ,sbcl-mcclim-clx-freetype)
- ("mcclim-clx-truetype" ,sbcl-mcclim-clx-truetype)
- ("mcclim-null" ,sbcl-mcclim-null)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "mcclim.asd"
- #:asd-system-name "mcclim/looks"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "mcclim.asd"
- (("mcclim-clx/truetype")
- "mcclim-clx-truetype")
- (("mcclim-clx/freetype")
- "mcclim-clx-freetype"))
- #t)))))))
+ (name "sbcl-zpb-exif")
+ (version "1.2.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/zpb-exif")
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "15s227jhby55cisz14xafb0p1ws2jmrg2rrbbd00lrb97im84hy6"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://xach.com/lisp/zpb-exif/")
+ (synopsis "EXIF information extractor for Common Lisp")
+ (description
+ "This is a Common Lisp library to extract EXIF information from image
+files.")
+ (license license:bsd-2)))
-(define-public sbcl-mcclim-franz
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-franz")
- (inputs
- `(("clim" ,sbcl-clim)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Extensions/Franz/mcclim-franz.asd"))))
+(define-public cl-zpb-exif
+ (sbcl-package->cl-source-package sbcl-zpb-exif))
-(define-public sbcl-mcclim-bezier-core
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-bezier-core")
- (inputs
- `(("clim" ,sbcl-clim)
- ("clim-pdf" ,sbcl-clim-pdf)
- ("clim-postscript" ,sbcl-clim-postscript)
- ("mcclim-null" ,sbcl-mcclim-null)
- ("mcclim-render" ,sbcl-mcclim-render)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Extensions/bezier/mcclim-bezier.asd"
- #:asd-system-name "mcclim-bezier/core"))))
+(define-public ecl-zpb-exif
+ (sbcl-package->ecl-package sbcl-zpb-exif))
-(define-public sbcl-mcclim-bezier-clx
+(define-public sbcl-pngload
(package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-bezier-clx")
+ (name "sbcl-pngload")
+ (version "2.0.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/bufferswap/pngload")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ix8dd0fxlf8xm0bszh1s7sx83hn0vqq8b8c9gkrd5m310w8mpvh"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- `(("clim" ,sbcl-clim)
- ("mcclim-bezier/core" ,sbcl-mcclim-bezier-core)
- ("mcclim-clx" ,sbcl-mcclim-clx)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ `(("3bz" ,sbcl-3bz)
+ ("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("mmap" ,sbcl-mmap)
+ ("parse-float" ,sbcl-parse-float)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("swap-bytes" ,sbcl-swap-bytes)
+ ("zpb-exif" ,sbcl-zpb-exif)))
(arguments
- '(#:asd-file "Extensions/bezier/mcclim-bezier.asd"
- #:asd-system-name "mcclim-bezier/clx"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "Extensions/bezier/mcclim-bezier.asd"
- (("mcclim-bezier/core\\)")
- "mcclim-bezier-core)"))
- #t)))))))
+ ;; Test suite disabled because of a dependency cycle.
+ ;; pngload tests depend on opticl which depends on pngload.
+ '(#:tests? #f))
+ (home-page "https://github.com/bufferswap/pngload")
+ (synopsis "PNG image decoder for Common Lisp")
+ (description
+ "This is a Common Lisp library to load images in the PNG image format,
+both from files on disk, or streams in memory.")
+ (license license:expat)))
-(define-public sbcl-mcclim-bezier
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-bezier")
- (inputs
- `(("mcclim-bezier/clx" ,sbcl-mcclim-bezier-clx)
- ("mcclim-bezier/core" ,sbcl-mcclim-bezier-core)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Extensions/bezier/mcclim-bezier.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "Extensions/bezier/mcclim-bezier.asd"
- (("\\(#:mcclim-bezier/core")
- "(#:mcclim-bezier-core")
- (("#:mcclim-bezier/clx\\)\\)")
- "#:mcclim-bezier-clx))"))
- #t)))))))
+(define-public cl-pngload
+ (sbcl-package->cl-source-package sbcl-pngload))
-(define-public sbcl-mcclim-bitmaps
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-bitmaps")
- (inputs
- `(("clim-basic" ,sbcl-clim-basic)
- ("opticl" ,sbcl-opticl)))
- (arguments
- '(#:asd-file "Extensions/bitmap-formats/mcclim-bitmaps.asd"))))
+(define-public ecl-pngload
+ (sbcl-package->ecl-package sbcl-pngload))
-(define-public sbcl-conditional-commands
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-conditional-commands")
- (inputs
- `(("clim-basic" ,sbcl-clim-basic)))
- (arguments
- '(#:asd-file "Extensions/conditional-commands/conditional-commands.asd"))))
+(define-public sbcl-opticl
+ (let ((commit "e8684416eca2e78e82a7b436d436ef2ea24c019d")
+ (revision "0"))
+ (package
+ (name "sbcl-opticl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slyrus/opticl")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "03rirnnhhisjbimlmpi725h1d3x0cfv00r57988am873dyzawmm1"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-jpeg" ,sbcl-cl-jpeg)
+ ("cl-tga" ,sbcl-cl-tga)
+ ("png-read" ,sbcl-png-read)
+ ("pngload" ,sbcl-pngload)
+ ("retrospectiff" ,sbcl-retrospectiff)
+ ("skippy" ,sbcl-skippy)
+ ("zpng" ,sbcl-zpng)))
+ (arguments
+ '(#:asd-files '("opticl.asd")))
+ (home-page "https://github.com/slyrus/opticl")
+ (synopsis "Image processing library for Common Lisp")
+ (description
+ "Opticl is a Common Lisp library for representing, processing, loading,
+and saving 2-dimensional pixel-based images.")
+ (license license:bsd-2))))
-(define-public sbcl-mcclim-layouts-tab
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-layouts-tab")
- (inputs
- `(("clim" ,sbcl-clim)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "Extensions/layouts/mcclim-layouts.asd"
- #:asd-system-name "mcclim-layouts/tab"))))
+(define-public cl-opticl
+ (sbcl-package->cl-source-package sbcl-opticl))
-(define-public sbcl-mcclim-extensions
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim-extensions")
- (inputs
- `(("clim-pdf" ,sbcl-clim-pdf)
- ("clim-postscript" ,sbcl-clim-postscript)
- ("conditional-commands" ,sbcl-conditional-commands)
- ("mcclim-bezier" ,sbcl-mcclim-bezier)
- ("mcclim-bitmaps" ,sbcl-mcclim-bitmaps)
- ("mcclim-franz" ,sbcl-mcclim-franz)
- ("mcclim-layouts-tab" ,sbcl-mcclim-layouts-tab)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:asd-file "mcclim.asd"
- #:asd-system-name "mcclim/extensions"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "mcclim.asd"
- (("mcclim-layouts/tab")
- "mcclim-layouts-tab"))
- #t)))))))
+(define-public ecl-opticl
+ (sbcl-package->ecl-package sbcl-opticl))
(define-public sbcl-mcclim
- (package
- (inherit sbcl-clim-lisp)
- (name "sbcl-mcclim")
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("mcclim-looks" ,sbcl-mcclim-looks)
- ("mcclim-extensions" ,sbcl-mcclim-extensions)
- ("swank" ,cl-slime-swank))) ; For drei-mcclim
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-asd-system-names
- (lambda _
- (substitute* "mcclim.asd"
- ((":depends-on \\(\"mcclim/looks\" \"mcclim/extensions\"\\)")
- ":depends-on (\"mcclim-looks\" \"mcclim-extensions\")"))
- #t)))
- ;; Test suite disabled because of a dependency cycle.
- ;; The tests depend on mcclim/test-util, which depends on mcclim.
- #:tests? #f))))
-
-(define-public cl-mcclim
- (let ((base (sbcl-package->cl-source-package sbcl-clim-lisp)))
+ (let ((commit "27b4d7a667c9b3faa74cabcb57706b888314fff7")
+ (revision "0"))
(package
- (inherit base)
- (name "cl-mcclim")
+ (name "sbcl-mcclim")
+ (version (git-version "0.9.7" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mcclim/mcclim")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0jijfgkwas6xnpp5wiii6slcx9pgsalngacb8zm29x6pamx2193h"))))
+ (build-system asdf-build-system/sbcl)
(native-inputs
- `(("fiveam" ,cl-fiveam)
+ `(("fiveam" ,sbcl-fiveam)
("pkg-config" ,pkg-config)))
(inputs
- `(("alexandria" ,cl-alexandria)
- ("babel" ,cl-babel)
- ("bordeaux-threads" ,cl-bordeaux-threads)
- ("cffi" ,cl-cffi)
- ("cl-aa" ,cl-aa)
- ("cl-freetype2" ,cl-freetype2)
- ("cl-paths-ttf" ,cl-paths-ttf)
- ("cl-pdf" ,cl-pdf)
- ("cl-unicode" ,cl-unicode)
- ("cl-vectors" ,cl-vectors)
- ("closer-mop" ,cl-closer-mop)
- ("clx" ,cl-clx)
- ("flexi-streams" ,cl-flexi-streams)
- ("flexichain" ,cl-flexichain)
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-freetype2" ,sbcl-cl-freetype2)
+ ("cl-pdf" ,sbcl-cl-pdf)
+ ("cffi" ,sbcl-cffi)
+ ("cl-unicode" ,sbcl-cl-unicode)
+ ("cl-vectors" ,sbcl-cl-vectors)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("clx" ,sbcl-clx)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("flexichain" ,sbcl-flexichain)
+ ("font-dejavu" ,font-dejavu)
("fontconfig" ,fontconfig)
("freetype" ,freetype)
("harfbuzz" ,harfbuzz)
- ("log4cl" ,cl-log4cl)
- ("opticl" ,cl-opticl)
- ("spatial-trees" ,cl-spatial-trees)
- ("trivial-features" ,cl-trivial-features)
- ("trivial-garbage" ,cl-trivial-garbage)
- ("trivial-gray-streams" ,cl-trivial-gray-streams)
- ("swank" ,cl-slime-swank)
- ("zpb-ttf" ,cl-zpb-ttf))))))
+ ("log4cl" ,sbcl-log4cl)
+ ("opticl" ,sbcl-opticl)
+ ("spatial-trees" ,sbcl-spatial-trees)
+ ("swank" ,sbcl-slime-swank)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("zpb-ttf" ,sbcl-zpb-ttf)))
+ (arguments
+ '(#:asd-systems '("mcclim"
+ "clim-examples")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ ;; mcclim-truetype uses DejaVu as default font and
+ ;; sets the path at build time.
+ (substitute* "Extensions/fonts/fontconfig.lisp"
+ (("/usr/share/fonts/truetype/dejavu/")
+ (string-append (assoc-ref inputs "font-dejavu")
+ "/share/fonts/truetype/")))
+ (substitute* "Extensions/fontconfig/src/functions.lisp"
+ (("libfontconfig\\.so")
+ (string-append (assoc-ref inputs "fontconfig")
+ "/lib/libfontconfig.so")))
+ (substitute* "Extensions/harfbuzz/src/functions.lisp"
+ (("libharfbuzz\\.so")
+ (string-append (assoc-ref inputs "harfbuzz")
+ "/lib/libharfbuzz.so")))
+ #t))
+ (add-after 'unpack 'fix-build
+ (lambda _
+ ;; The cffi-grovel system does not get loaded automatically,
+ ;; so we load it explicitly.
+ (substitute* "Extensions/fontconfig/mcclim-fontconfig.asd"
+ (("\\(asdf:defsystem #:mcclim-fontconfig" all)
+ (string-append "(asdf:load-system :cffi-grovel)\n" all)))
+ (substitute* "Extensions/harfbuzz/mcclim-harfbuzz.asd"
+ (("\\(asdf:defsystem #:mcclim-harfbuzz" all)
+ (string-append "(asdf:load-system :cffi-grovel)\n" all)))
+ #t)))))
+ (home-page "https://common-lisp.net/project/mcclim/")
+ (synopsis "Common Lisp GUI toolkit")
+ (description
+ "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
+specification}, a toolkit for writing GUIs in Common Lisp.")
+ (license license:lgpl2.1+))))
+
+(define-public cl-mcclim
+ (sbcl-package->cl-source-package sbcl-mcclim))
+
+(define-public ecl-mcclim
+ (sbcl-package->ecl-package sbcl-mcclim))
(define-public sbcl-cl-inflector
(let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
and decoder for Common Lisp.")
(license license:bsd-3)))
-(define-public cl-qbase64
- (sbcl-package->cl-source-package sbcl-qbase64))
+(define-public cl-qbase64
+ (sbcl-package->cl-source-package sbcl-qbase64))
+
+(define-public ecl-qbase64
+ (sbcl-package->ecl-package sbcl-qbase64))
+
+(define-public sbcl-lw-compat
+ ;; No release since 2013.
+ (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d"))
+ (package
+ (name "sbcl-lw-compat")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pcostanza/lw-compat/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/pcostanza/lw-compat/")
+ (synopsis "LispWorks utilities ported to other Common Lisp implementations")
+ (description "This package contains a few utility functions from the
+LispWorks library that are used in software such as ContextL.")
+ (license license:expat))))
+
+(define-public cl-lw-compat
+ (sbcl-package->cl-source-package sbcl-lw-compat))
-(define-public ecl-qbase64
- (sbcl-package->ecl-package sbcl-qbase64))
+(define-public ecl-lw-compat
+ (sbcl-package->ecl-package sbcl-lw-compat))
+
+(define-public sbcl-contextl
+ ;; No release since 2013.
+ (let ((commit "5d18a71a85824f6c25a9f35a21052f967b8b6bb9"))
+ (package
+ (name "sbcl-contextl")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pcostanza/contextl/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0gk1izx6l6g48nypmnm9r6mzjx0jixqjj2kc6klf8a88rr5xd226"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("closer-mop" ,sbcl-closer-mop)
+ ("lw-compat" ,sbcl-lw-compat)))
+ (home-page "https://github.com/pcostanza/contextl")
+ (synopsis "Context-oriented programming for Common Lisp")
+ (description "ContextL is a CLOS extension for Context-Oriented
+Programming (COP).
+
+Find overview of ContextL's features in an overview paper:
+@url{http://www.p-cos.net/documents/contextl-soa.pdf}. See also this general
+overview article about COP which also contains some ContextL examples:
+@url{http://www.jot.fm/issues/issue_2008_03/article4/}.")
+ (license license:expat))))
+
+(define-public cl-contextl
+ (sbcl-package->cl-source-package sbcl-contextl))
+
+(define-public ecl-contextl
+ (sbcl-package->ecl-package sbcl-contextl))
(define-public sbcl-hu.dwim.common-lisp
(package
("metabang-bind" ,sbcl-metabang-bind)))
(home-page "http://dwim.hu/")
(synopsis "Common Lisp library shared by other hu.dwim systems")
- (description "")
+ (description "This package contains a support library for other
+hu.dwim systems.")
(license license:public-domain)))
(define-public cl-hu.dwim.common
@itemize
@item Automatically export all or select slots at compile time.
-@item Define the @code{:initarg} and @code{:accesor} automatically.
+@item Define the @code{:initarg} and @code{:accessor} automatically.
@item Specify a name transformer for both the @code{:initarg} and
@code{:accessor}, etc.
@item Specify the @code{:initform} as second slot value.
(define-public ecl-envy
(sbcl-package->ecl-package sbcl-envy))
-(define sbcl-mito-core
+(define-public sbcl-mito
(let ((commit "d3b9e375ef364a65692da2185085a08c969ac88a")
(revision "1"))
(package
- (name "sbcl-mito-core")
+ (name "sbcl-mito")
(version (git-version "0.1" revision commit))
(home-page "https://github.com/fukamachi/mito")
(source
(sha256
(base32 "08mncgzjnbbsf1a6am3l73iw4lyfvz5ldjg5g84awfaxml4p73mb"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
(inputs
- `(("dbi" ,sbcl-dbi)
- ("sxql" ,sbcl-sxql)
+ `(("alexandria" ,sbcl-alexandria)
("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-reexport" ,sbcl-cl-reexport)
("closer-mop" ,sbcl-closer-mop)
+ ("dbi" ,sbcl-dbi)
("dissect" ,sbcl-dissect)
- ("optima" ,sbcl-optima)
- ("cl-reexport" ,sbcl-cl-reexport)
+ ("esrap" ,sbcl-esrap)
("local-time" ,sbcl-local-time)
- ("uuid" ,sbcl-uuid)
- ("alexandria" ,sbcl-alexandria)))
- (synopsis "ORM for Common Lisp with migrations and relationships support")
- (description "Mito is yet another object relational mapper, and it aims
-to be a successor of Integral.
-
-@itemize
-@item Support MySQL, PostgreSQL and SQLite3.
-@item Add id (serial/uuid primary key), created_at and updated_at by default
-like Ruby's ActiveRecord.
-@item Migrations.
-@item Database schema versioning.
-@end itemize\n")
- (license license:llgpl))))
-
-(define sbcl-mito-migration
- (package
- (inherit sbcl-mito-core)
- (name "sbcl-mito-migration")
- (inputs
- `(("mito-core" ,sbcl-mito-core)
- ("dbi" ,sbcl-dbi)
- ("sxql" ,sbcl-sxql)
- ("closer-mop" ,sbcl-closer-mop)
- ("cl-reexport" ,sbcl-cl-reexport)
- ("uuid" ,sbcl-uuid)
- ("alexandria" ,sbcl-alexandria)
- ("esrap" ,sbcl-esrap)))))
-
-(define sbcl-lack-middleware-mito
- (package
- (inherit sbcl-mito-core)
- (name "sbcl-lack-middleware-mito")
- (inputs
- `(("mito-core" ,sbcl-mito-core)
- ("dbi" ,sbcl-dbi)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- (substitute* "lack-middleware-mito.asd"
- (("cl-dbi") "dbi"))
- #t)))))))
-
-(define-public sbcl-mito
- (package
- (inherit sbcl-mito-core)
- (name "sbcl-mito")
- (inputs
- `(("mito-core" ,sbcl-mito-core)
- ("mito-migration" ,sbcl-mito-migration)
- ("lack-middleware-mito" ,sbcl-lack-middleware-mito)
- ("cl-reexport" ,sbcl-cl-reexport)))
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)
- ("dbd-mysql" ,sbcl-dbd-mysql)
- ("dbd-postgres" ,sbcl-dbd-postgres)
- ("dbd-sqlite3" ,sbcl-dbd-sqlite3)))
- (arguments
+ ("optima" ,sbcl-optima)
+ ("sxql" ,sbcl-sxql)
+ ("uuid" ,sbcl-uuid)))
+ (arguments
'(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'remove-non-functional-tests
#t)))
;; TODO: While all enabled tests pass, the phase fails with:
;; Component MITO-ASD::MITO-TEST not found, required by #<SYSTEM "mito">
- #:tests? #f))))
+ #:tests? #f))
+ (synopsis "ORM for Common Lisp with migrations and relationships support")
+ (description "Mito is yet another object relational mapper, and it aims
+to be a successor of Integral.
+
+@itemize
+@item Support MySQL, PostgreSQL and SQLite3.
+@item Add id (serial/uuid primary key), created_at and updated_at by default
+like Ruby's ActiveRecord.
+@item Migrations.
+@item Database schema versioning.
+@end itemize\n")
+ (license license:llgpl))))
(define-public cl-mito
(sbcl-package->cl-source-package sbcl-mito))
+(define-public ecl-mito
+ (sbcl-package->ecl-package sbcl-mito))
+
(define-public sbcl-kebab
(let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b")
(revision "1"))
("cl-interpol" ,sbcl-cl-interpol)
("split-sequence" ,sbcl-split-sequence)))
(native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)
- ("prove" ,sbcl-prove)))
+ `(("prove" ,sbcl-prove)))
(arguments
;; Tests passes but the phase fails with
;; Component KEBAB-ASD::KEBAB-TEST not found, required by #<SYSTEM "kebab">.
("optima" ,sbcl-optima)
("trivial-types" ,sbcl-trivial-types)
("closer-mop" ,sbcl-closer-mop)
- ("cl-syntax-annot" ,sbcl-cl-syntax-annot)
+ ("cl-syntax" ,sbcl-cl-syntax)
("sxql" ,sbcl-sxql)
("dbi" ,sbcl-dbi)
("babel" ,sbcl-babel)
("kebab" ,sbcl-kebab)
("log4cl" ,sbcl-log4cl)))
(native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)
- ("prove" ,sbcl-prove)
- ("dbd-sqlite3" ,sbcl-dbd-sqlite3)))
+ `(("prove" ,sbcl-prove)))
(arguments
;; TODO: Tests fail with
;; While evaluating the form starting at line 22, column 0
("prove" ,sbcl-prove)))
(arguments
;; Tests depend on caveman, which in turns depends on cl-project.
- '(#:tests? #f))
+ '(#:tests? #f
+ #:asd-files '("cl-project.asd")))
(synopsis "Generate a skeleton for modern Common Lisp projects")
(description "This library provides a modern project skeleton generator.
In contract with other generators, CL-Project generates one package per file
(build-system asdf-build-system/sbcl)
(inputs
`(("ningle" ,cl-ningle)
- ("lack-request" ,sbcl-lack-request)
- ("lack-response" ,sbcl-lack-response)
+ ("lack" ,sbcl-lack)
("cl-project" ,sbcl-cl-project)
("dbi" ,sbcl-dbi)
- ("cl-syntax-annot" ,sbcl-cl-syntax-annot)
+ ("cl-syntax" ,sbcl-cl-syntax)
("myway" ,sbcl-myway)
("quri" ,sbcl-quri)))
(native-inputs
`(("usocket" ,sbcl-usocket)
("dexador" ,sbcl-dexador)))
(arguments
- `(#:asd-file "caveman2.asd"
- #:asd-system-name "caveman2"
+ `(#:asd-files '("caveman2.asd")
+ #:asd-systems '("caveman2")
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'remove-v1
(for-each delete-file
'("README.v1.markdown" "caveman.asd" "caveman-test.asd")))))
;; TODO: Tests fail with:
- ;; writing /gnu/store/j4l1k28yq47qbg074b4yf1b7wnccg8j1-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
+ ;; writing /gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
;; While evaluating the form starting at line 38, column 0
;; of #P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp":
;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread #<SB-THREAD:THREAD "main thread" RUNNING
(define-public ecl-caveman
(sbcl-package->ecl-package sbcl-caveman))
+
+(define-public sbcl-lambda-fiddle
+ (let ((commit "d16bba55acf6065b412f64ab8fdff679a4a32b1e") ;; no tagged branch
+ (revision "1"))
+ (package
+ (name "sbcl-lambda-fiddle")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/lambda-fiddle")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1zarj1pqjqmk95kdx1axkgpwy2wq3canczk7f9z5hvaw5an6gand"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/Shinmera/lambda-fiddle")
+ (synopsis "Collection of utilities to process lambda-lists")
+ (description "This collection of utilities is useful in contexts where
+you want a macro that uses lambda-lists in some fashion but need more precise
+processing.")
+ (license license:zlib))))
+
+(define-public cl-lambda-fiddle
+ (sbcl-package->cl-source-package sbcl-lambda-fiddle))
+
+(define-public ecl-lambda-fiddle
+ (sbcl-package->ecl-package sbcl-lambda-fiddle))
+
+(define-public sbcl-xmls
+ (let ((commit "18546f0850b1338e03997ffd1696add1cb1800d1") ;; no tagged branch
+ (revision "1"))
+ (package
+ (name "sbcl-xmls")
+ (version (git-version "3.0.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpgoldman/xmls")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1lmvfml2ldbb1wkhm25jqqk2bhwsz52hhcgljbnzj1xr8xhc3anp"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/rpgoldman/xmls")
+ (synopsis "Non-validating XML parser for Common Lisp")
+ (description "Xmls is a self-contained, easily embedded parser that
+recognizes a useful subset of the XML spec. It provides a simple mapping from
+XML to Lisp structures or s-expressions and back.")
+ (license license:bsd-2))))
+
+(define-public cl-xmls
+ (sbcl-package->cl-source-package sbcl-xmls))
+
+(define-public ecl-xmls
+ (sbcl-package->ecl-package sbcl-xmls))
+
+(define-public sbcl-geco
+ (package
+ (name "sbcl-geco")
+ (version "2.01a")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/geco/download/"
+ "geco-" version ".tar.gz"))
+ (sha256
+ (base32 "0kk0bzr1019cfmf2b1jl1rk9shv3gx5z1znifxllg9mb98yqsgw0"))
+ (patches (search-patches "sbcl-geco-fix-organism-class.patch"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://common-lisp.net/project/geco/")
+ (synopsis "Genetic algorithm toolkit for Common Lisp")
+ (description
+ "GECO (Genetic Evolution through Combination of Objects) is an extensible,
+object-oriented framework for prototyping genetic algorithms in Common Lisp.")
+ (license license:lgpl2.1+)))
+
+(define-public cl-geco
+ (sbcl-package->cl-source-package sbcl-geco))
+
+(define-public ecl-geco
+ (sbcl-package->ecl-package sbcl-geco))
+
+(define-public sbcl-html-entities
+ (let ((commit "4af018048e891f41d77e7d680ed3aeb639e1eedb"))
+ (package
+ (name "sbcl-html-entities")
+ (version (git-version "0.02" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/BnMcGn/html-entities/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1b2yl6lf6vis17y4n5s505p7ica96bdafcl6vydy1hg50fy33nfr"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("ppcre" ,sbcl-cl-ppcre)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (home-page "https://github.com/BnMcGn/html-entities/")
+ (synopsis "Encode and decode entities in HTML with Common Lisp")
+ (description "Html-entities is a Common Lisp library that lets you
+encode and decode entities in HTML.")
+ (license license:expat))))
+
+(define-public cl-html-entities
+ (sbcl-package->cl-source-package sbcl-html-entities))
+
+(define-public ecl-html-entities
+ (sbcl-package->ecl-package sbcl-html-entities))
+
+(define-public sbcl-quicksearch
+ (let ((commit "fb02ecf7c876ec580ab18c7d2c8c7814c06af599"))
+ (package
+ (name "sbcl-quicksearch")
+ (version (git-version "0.01.04" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tkych/quicksearch/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "16k19zjkhh7r64vjq371k5jwjs7cdfjz83flh561n4h4v1z89fps"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("iterate" ,sbcl-iterate)
+ ("alexandria" ,sbcl-alexandria)
+ ("anaphora" ,sbcl-anaphora)
+ ("ppcre" ,sbcl-cl-ppcre)
+ ("drakma" ,sbcl-drakma)
+ ("html-entities" ,sbcl-html-entities)
+ ("yason" ,sbcl-yason)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("do-urlencode" ,sbcl-do-urlencode)))
+ (home-page "https://github.com/tkych/quicksearch/")
+ (synopsis "Search Engine Interface for Common Lisp packages")
+ (description "Quicksearch is a search-engine-interface for Common Lisp.
+The goal of Quicksearch is to find the Common Lisp library quickly. For
+example, if you will find the library about json, just type @code{(qs:?
+'json)} at REPL.
+
+The function @code{quicksearch} searches for Common Lisp projects in
+Quicklisp, Cliki, GitHub and BitBucket, then outputs results in REPL. The
+function @code{?} is abbreviation wrapper for @code{quicksearch}.")
+ (license license:expat))))
+
+(define-public cl-quicksearch
+ (sbcl-package->cl-source-package sbcl-quicksearch))
+
+(define-public ecl-quicksearch
+ (sbcl-package->ecl-package sbcl-quicksearch))
+
+(define-public sbcl-agutil
+ (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68"))
+ (package
+ (name "sbcl-agutil")
+ (version (git-version "0.0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alex-gutev/agutil/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivia" ,sbcl-trivia)))
+ (home-page "https://github.com/alex-gutev/agutil/")
+ (synopsis "Collection of Common Lisp utilities")
+ (description "A collection of Common Lisp utility functions and macros
+mostly not found in other utility packages.")
+ (license license:expat))))
+
+(define-public cl-agutil
+ (sbcl-package->cl-source-package sbcl-agutil))
+
+(define-public ecl-agutil
+ (sbcl-package->ecl-package sbcl-agutil))
+
+(define-public sbcl-custom-hash-table
+ (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa"))
+ (package
+ (name "sbcl-custom-hash-table")
+ (version (git-version "0.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/metawilm/cl-custom-hash-table")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-files '("cl-custom-hash-table.asd")
+ #:asd-systems '("cl-custom-hash-table")))
+ (home-page "https://github.com/metawilm/cl-custom-hash-table")
+ (synopsis "Custom hash tables for Common Lisp")
+ (description "This library allows creation of hash tables with arbitrary
+@code{test}/@code{hash} functions, in addition to the @code{test} functions
+allowed by the standard (@code{EQ}, @code{EQL}, @code{EQUAL} and
+@code{EQUALP}), even in implementations that don't support this functionality
+directly.")
+ (license license:expat))))
+
+(define-public cl-custom-hash-table
+ (sbcl-package->cl-source-package sbcl-custom-hash-table))
+
+(define-public ecl-custom-hash-table
+ (sbcl-package->ecl-package sbcl-custom-hash-table))
+
+(define-public sbcl-collectors
+ (let ((commit "13acef25d8422d1d82e067b1861e513587c166ee"))
+ (package
+ (name "sbcl-collectors")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/AccelerationNet/collectors")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1si68n1j6rpns8jw6ksqjpb937pdl30v7xza8rld7j5vh0jhy2yi"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("symbol-munger" ,sbcl-symbol-munger)))
+ (native-inputs
+ `(("lisp-unit2" ,sbcl-lisp-unit2)))
+ (home-page "https://github.com/AccelerationNet/collectors/")
+ (synopsis "Common lisp library providing collector macros")
+ (description "A small collection of common lisp macros to make
+collecting values easier.")
+ (license license:bsd-3))))
+
+(define-public cl-collectors
+ (sbcl-package->cl-source-package sbcl-collectors))
+
+(define-public ecl-collectors
+ (sbcl-package->ecl-package sbcl-collectors))
+
+(define-public cl-environments
+ ;; TODO: asdf-build-system/sbcl fails here, why? See if it works with the
+ ;; build system revamp once staging is merged after 2020-11-09.
+ (let ((commit "bbcd958a9ff23ce3e6ea5f8ee2edad9634819a3a")) ; No version in 2 years.
+ (package
+ (name "cl-environments")
+ (version (git-version "0.2.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alex-gutev/cl-environments")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1pfxl3vcdrb4mjy4q4c3c7q95kzv6rfjif3hzd5q91i9z621d64r"))))
+ (build-system asdf-build-system/source)
+ (propagated-inputs
+ `(("alexandria" ,cl-alexandria)
+ ("anaphora" ,cl-anaphora)
+ ("collectors" ,cl-collectors)
+ ("optima" ,cl-optima)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (home-page "https://github.com/alex-gutev/cl-environments")
+ (synopsis "Implements the Common Lisp standard environment access API")
+ (description "This library provides a uniform API, as specified in Common
+Lisp the Language 2, for accessing information about variable and function
+bindings from implementation-defined lexical environment objects. All major
+Common Lisp implementations are supported, even those which don't support the
+CLTL2 environment access API.")
+ (license license:expat))))
+
+(define-public sbcl-static-dispatch
+ (package
+ (name "sbcl-static-dispatch")
+ (version "0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alex-gutev/static-dispatch")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1wp5yz8liqqic3yifqf33qhccd755pd7ycvsq1j4i7k3f1wm18i0"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("agutil" ,sbcl-agutil)
+ ("alexandria" ,sbcl-alexandria)
+ ("anaphora" ,sbcl-anaphora)
+ ("arrows" ,sbcl-arrows)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("iterate" ,sbcl-iterate)
+ ("trivia" ,sbcl-trivia)))
+ (propagated-inputs
+ `(("cl-environments" ,cl-environments)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ ;; Use `arrows' instead of cl-arrows which is abandoned and unlicensed.
+ ;; https://github.com/nightfly19/cl-arrows/issues/5
+ (add-after 'unpack 'use-arrows-instead-of-cl-arrows
+ (lambda _
+ (for-each
+ (lambda (file)
+ (substitute* file
+ ((":cl-arrows") ":arrows")))
+ '("static-dispatch.asd"
+ "src/package.lisp"
+ "test/methods.lisp"
+ "test/test.lisp")))))))
+ (home-page "https://github.com/alex-gutev/static-dispatch")
+ (synopsis "Static generic function dispatch for Common Lisp")
+ (description "Static dispatch is a Common Lisp library, inspired by
+@code{inlined-generic-function}, which allows standard Common Lisp generic
+function dispatch to be performed statically (at compile time) rather than
+dynamically (runtime). This is similar to what is known as \"overloading\" in
+languages such as C++ and Java.
+
+The purpose of static dispatch is to provide an optimization in cases where
+the usual dynamic dispatch is too slow, and the dynamic features of generic
+functions, such as adding/removing methods at runtime are not required. An
+example of such a case is a generic equality comparison function. Currently
+generic functions are considered far too slow to implement generic arithmetic
+and comparison operations when used heavily in numeric code.")
+ (license license:expat)))
+
+(define-public cl-static-dispatch
+ (sbcl-package->cl-source-package sbcl-static-dispatch))
+
+(define-public ecl-static-dispatch
+ (sbcl-package->ecl-package sbcl-static-dispatch))
HCoop / jackhill / guix / guix.git / blobdiff