;;; Copyright © 2021 André A. Gomes <andremegafone@gmail.com>
;;; Copyright © 2021 Cage <cage-dev@twistfold.it>
;;; Copyright © 2021 Cameron Chaparro <cameron@cameronchaparro.com>
+;;; Copyright © 2021 Charles Jackson <charles.b.jackson@protonmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages web)
#:use-module (gnu packages webkit)
#:use-module (gnu packages xdisorg)
+ #:use-module (gnu packages xorg)
#:use-module (ice-9 match)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-19))
(define-public sbcl-cffi
(package
(name "sbcl-cffi")
- (version "0.23.0")
+ (version "0.24.1")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name "cffi-bootstrap" version))
(sha256
- (base32 "03s98imc5niwnpj3hhrafl7dmxq45g74h96sm68976k7ahi3vl5b"))))
+ (base32 "17ryim4xilb1rzxydfr7595dnhqkk02lmrbkqrkvi9091shi4cj3"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
(define-public ecl-cl-markup
(sbcl-package->ecl-package sbcl-cl-markup))
+;;; The following package is renamed from "markup" to "markup-reader" in order
+;;; not to conflict with the "cl-markup" package.
+(define-public sbcl-markup-reader
+ (let ((commit "d2d4d7b073554f47c24223a9304452966608702e")
+ (revision "1"))
+ (package
+ (name "sbcl-markup-reader")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/moderninterpreters/markup")
+ (commit commit)))
+ (file-name (git-file-name "markup-reader" version))
+ (sha256
+ (base32 "0i3v938j8zpzkd6p9j8gadp5zndjcdxhswj1qgsp592v6497rpzj"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("markup")))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-str" ,sbcl-cl-str)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (home-page "https://github.com/moderninterpreters/markup")
+ (synopsis "Reader-macro to read HTML tags inside of Common Lisp code")
+ (description
+ "Markup allows the use of HTML syntax with in Common Lisp code.
+This has the advantage of being able to copy HTML snippets and have them
+instantly be functional, less double quotes than a s-expression approach,
+and designers will be able to understand the embeded HTML.")
+ (license license:asl2.0))))
+
+(define-public ecl-markup-reader
+ (sbcl-package->ecl-package sbcl-markup-reader))
+
+(define-public cl-markup-reader
+ (sbcl-package->cl-source-package sbcl-markup-reader))
+
(define-public sbcl-cl-mustache
(package
(name "sbcl-cl-mustache")
(define-public sbcl-quri
(package
(name "sbcl-quri")
- (version "0.3.0")
+ (version "0.4.0")
(source
(origin
(method git-fetch)
(commit version)))
(file-name (git-file-name name version))
(sha256
- (base32 "1pkvpiwwhx2fcknr7x47h7036ypkg8xzsskqbl5z315ipfmi8s2m"))))
+ (base32 "0ka5haq3g72hvaz4hdv7y1d6df9ncmx029wwixn4r413gll5yxy7"))))
(build-system asdf-build-system/sbcl)
(arguments
;; Test system must be loaded before, otherwise tests fail with:
(define-public sbcl-static-vectors
(package
(name "sbcl-static-vectors")
- (version "1.8.6")
+ (version "1.8.9")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
- (base32 "01hwxzhyjkhsd3949g70120g7msw01byf0ia0pbj319q1a3cq7j9"))))
+ (base32 "079qa20lhanzsz1qf4iags91n0ziylbjgbcymm5a5qj7yryas4fw"))))
(native-inputs
`(("sbcl-fiveam" ,sbcl-fiveam)))
(inputs
(sbcl-package->ecl-package sbcl-cl-hooks))
(define-public sbcl-cl-autowrap
- (let ((revision "1")
- (commit "ae846d6968fc0d000de0c541638929a157f3009e"))
+ (let ((revision "2")
+ (commit "a5d71ebd7c21b87f449db1e16ab815750d7c0ea4"))
;; no taged branches
(package
(name "sbcl-cl-autowrap")
(uri (git-reference
(url "https://github.com/rpav/cl-autowrap")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-autowrap" version))
(sha256
- (base32 "1gisldp2zns92kdcaikghm7c38ldy2d884n8bfg0wcjvbz78p3ar"))))
+ (base32 "0795c817m1c41cz3ywzzg83z4pgkxdg6si553pay9mdgjvmrwmaw"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '("cl-plus-c" "cl-autowrap")))
(inputs
`(("alexandria" ,sbcl-alexandria)
("cffi" ,sbcl-cffi)
(sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
(define-public sbcl-serapeum
- (let ((commit "f5da17b635ecb11d8317800f1674e88ca779dac5")
- (revision "5"))
+ (let ((commit "c29a52ff0c5f6e60b09919c3a0daa8df7599ddb9")
+ (revision "6"))
(package
(name "sbcl-serapeum")
(version (git-version "0.0.0" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "16mz6xgcb5pkjg7xb760ga4hxbdhm9f843l42kc546hknhfq8x7b"))))
+ (base32 "0vij9jhji09way1rpd0r5sgjnh5amm3f2ymppnqkw0c6nnk2p0kd"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
(define-public ecl-trivialib-type-unify
(sbcl-package->ecl-package sbcl-trivialib-type-unify))
+(define-public sbcl-cl-unification
+ (let ((commit "01079f34d197495880aa49ab727d63774d83035c")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-unification")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/cl-unification/cl-unification")
+ (commit commit)))
+ (file-name (git-file-name "cl-unification" version))
+ (sha256
+ (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("ptester" ,sbcl-ptester)))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)))
+ (home-page "https://common-lisp.net/project/cl-unification/")
+ (synopsis "Unification framework for Common Lisp")
+ (description
+ "This package provides a framework to unify arbitrary
+Common Lisp objects while constructing bindings for placeholders
+(unification variables) in a template sublanguage.")
+ (license license:bsd-0))))
+
+(define-public ecl-cl-unification
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl-unification)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; The tests fail on ECL with:
+ ;; "In MAKE-ARRAY: the elements in :INITIAL-CONTENTS do not match
+ ;; the array dimensions."
+ ((#:tests? _ #f) #f))))))
+
+(define-public cl-unification
+ (sbcl-package->cl-source-package sbcl-cl-unification))
+
(define-public sbcl-specialized-function
(let ((commit "5e2b04432bdf728496e6ff7227f210f845af7247")
(revision "3"))
(sbcl-package->cl-source-package sbcl-cl-html-diff))
(define-public sbcl-tooter
- (let ((commit "b8d4b245b1d946bc9da6f51a3d8c2dc43e4d3868")
- (revision "1"))
+ (let ((commit "b1639d8a58dfe8020c82ed36697b7a668ef41a09")
+ (revision "2"))
(package
(name "sbcl-tooter")
(version (git-version "1.0.0" revision commit))
(commit commit)))
(file-name (git-file-name "tooter" version))
(sha256
- (base32 "0g40dlis4dbw4p3zxz3scx27b9zm8zlzihywapf5zqrdqfx5hpq9"))))
+ (base32 "0842lbj9ml6qxdm5xvhdbm87wyrvrq7bxawa6i8wk80n8lnvmhdw"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
(sbcl-package->cl-source-package sbcl-tooter))
(define-public sbcl-croatoan
- (let ((commit "7077ef14d27e8708515ad8d309886f516e7fbd98")
- (revision "2"))
+ (let ((commit "a577951d8dd607f828d6efb3290b4e8ac9f1e654")
+ (revision "3"))
(package
(name "sbcl-croatoan")
(version (git-version "0.0.1" revision commit))
(commit commit)))
(file-name (git-file-name "croatoan" version))
(sha256
- (base32 "0gf2sjpsdkd9s8imwy2wjrkdx82a5sc4yy9bndlnjlwmdraw4j37"))))
+ (base32 "1y7a13mzy0cz19pw0xvqwca1s7frfaqryaqwl1mrq7iz84sw0fcw"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:phases
(define-public cl-cepl
(sbcl-package->cl-source-package sbcl-cepl))
+
+(define-public sbcl-stmx
+ ;; No release for years and recent commits contain fixes for revent SBCL versions.
+ (let ((commit "a7bb44082cd53ee968965adff03d4351750711a1")
+ (revision "1"))
+ (package
+ (name "sbcl-stmx")
+ (version (git-version "2.0.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cosmos72/stmx/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1hfmh4vj271jdilir97qs6nqbi5nmn5alyls0w3d3xxqwi6ffqjs"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("log4cl" ,sbcl-log4cl)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (home-page "https://stmx.org/")
+ (synopsis "High performance Transactional Memory for Common Lisp")
+ (description
+ "STMX is a high-performance implementation of composable Transactional
+Memory, which is a concurrency control mechanism aimed at making concurrent
+programming easier to write and understand. Instead of traditional lock-based
+programming, one programs with atomic memory transactions, which can be
+composed together to make larger atomic memory transactions.
+
+A memory transaction gets committed if it returns normally, while it gets
+rolled back if it signals an error (and the error is propagated to the
+caller).
+
+Finally, memory transactions can safely run in parallel in different threads,
+are re-executed from the beginning in case of conflicts or if consistent reads
+cannot be guaranteed, and their effects are not visible from other threads
+until they commit.
+
+Memory transactions give freedom from deadlocks, are immune to thread-safety
+bugs and race conditions, provide automatic roll-back on failure, and aim at
+resolving the tension between granularity and concurrency.")
+ (license license:llgpl))))
+
+(define-public ecl-stmx
+ (sbcl-package->ecl-package sbcl-stmx))
+
+(define-public cl-stmx
+ (sbcl-package->cl-source-package sbcl-stmx))
+
+(define-public sbcl-binding-arrows
+ ;; Fork of sbcl-arrows that does not have a new tag.
+ (let ((commit "d19364ec8850880ed6e42078ccaa2ed9114dc83a")
+ (revision "1"))
+ (package
+ (name "sbcl-binding-arrows")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phoe/binding-arrows")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0hqikgzic7kjq2n1d924yldfm30qz67cmsk6gghi9cbmxkwdlwp8"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (home-page "https://github.com/phoe/binding-arrows")
+ (synopsis "Threading macros based on binding anonymous variables")
+ (description
+ "This system implements binding threading macros -- a kind of threading
+macros with different semantics than classical, Clojure core threading macros
+or their extension, swiss-arrows. Two Common Lisp implementations of those are
+@code{arrows} and @code{arrow-macros}.
+
+This system is a fork of @code{arrows} with changes in semantics that make it
+impossible to merge back upstream.")
+ (license license:expat))))
+
+(define-public ecl-binding-arrows
+ (sbcl-package->ecl-package sbcl-binding-arrows))
+
+(define-public cl-binding-arrows
+ (sbcl-package->cl-source-package sbcl-binding-arrows))
+
+(define-public sbcl-atomics
+ ;; No release in years.
+ (let ((commit "9ee0bdebcd2bb9b242671a75460db13fbf45454c")
+ (revision "1"))
+ (package
+ (name "sbcl-atomics")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/atomics")
+ (commit commit)))
+ (file-name (git-file-name "atomics" version))
+ (sha256
+ (base32 "0mp5jdqq0aamdhgnvw149cqqi3zg7dkkibp25qi4rafw1fnpd40z"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("documentation-utils" ,sbcl-documentation-utils)))
+ (native-inputs
+ `(("parachute" ,sbcl-parachute)))
+ (home-page "https://shinmera.github.io/atomics/")
+ (synopsis "Common Lisp portability layer for atomic operations")
+ (description
+ "This is a library for access to atomic operation primitives such as
+compare-and-swap. It aims to be a rather thin layer over what the
+implementations offer.")
+ (license license:zlib))))
+
+(define-public ecl-atomics
+ (sbcl-package->ecl-package sbcl-atomics))
+
+(define-public cl-atomics
+ (sbcl-package->cl-source-package sbcl-atomics))
+
+(define-public sbcl-cl-mock
+ ;; .asd version only got updated recently, despired the old GitHug "1.0.1" release.
+ (let ((commit "7988dca2093358911b67597a2cd1570c785dfe76"))
+ (package
+ (name "sbcl-cl-mock")
+ (version (git-version "1.0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Ferada/cl-mock/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0f40wikcf783jx26ip0nnhwjjfjvjiw7njqsqrb6kaphc8bgw0i1"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("trivia" ,sbcl-trivia)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (home-page "https://github.com/Ferada/cl-mock")
+ (synopsis "Mocking functions for Common Lisp testing")
+ (description
+ "This small library provides a way to replace the actual implementation
+of either regular or generic functions with mocks.")
+ (license license:agpl3))))
+
+(define-public ecl-cl-mock
+ (sbcl-package->ecl-package sbcl-cl-mock))
+
+(define-public cl-mock
+ (sbcl-package->cl-source-package sbcl-cl-mock))
+
+(define-public sbcl-cl-murmurhash
+ ;; No release.
+ (let ((commit "5433f5e95f1cce63a81259a471150834c6a59364")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-murmurhash")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/cl-murmurhash/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0251r0mpjm0y3qsm4lm7ncvrkxvgwc53spdm1p2mpayhvkkqqsws"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("babel" ,sbcl-babel)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "32-bit version of Murmurhash3 for Common Lisp")
+ (description
+ "This Common Lisp package offers an implementation of the 32-bit
+variant of MurmurHash3 (@url{https://github.com/aappleby/smhasher}), a fast
+non-crytographic hashing algorithm.")
+ (license license:expat))))
+
+(define-public ecl-cl-murmurhash
+ (sbcl-package->ecl-package sbcl-cl-murmurhash))
+
+(define-public cl-murmurhash
+ (sbcl-package->cl-source-package sbcl-cl-murmurhash))
+
+(define-public sbcl-cl-hamt
+ ;; No release
+ (let ((commit "7a99eaaca1f952029def9ad5a2b80a612a712208"))
+ (package
+ (name "sbcl-cl-hamt")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/danshapero/cl-hamt/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ycbd73ykfj5j9sdhlzamyv18qbjj6xqf7fhm4fa0nsyr6sr3rf5"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-murmurhash" ,sbcl-cl-murmurhash)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (home-page "https://github.com/danshapero/cl-hamt")
+ (synopsis "Dictionary & set data structure using hash array-mapped tries")
+ (description
+ "This library provides purely functional dictionaries and sets in
+Common Lisp based on the hash array-mapped trie data structure.")
+ (license license:bsd-3))))
+
+(define-public ecl-cl-hamt
+ (sbcl-package->ecl-package sbcl-cl-hamt))
+
+(define-public cl-hamt
+ (sbcl-package->cl-source-package sbcl-cl-hamt))
+
+(define-public sbcl-cl-gserver
+ (package
+ (name "sbcl-cl-gserver")
+ (version "1.7.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mdbergmann/cl-gserver")
+ (commit version)))
+ (file-name (git-file-name "cl-gserver" version))
+ (sha256
+ (base32 "1vkxs6ybi1pkpji2crmhq8c71zg0dn2ji0lcwhs0rivphz5jxk24"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("lparallel" ,sbcl-lparallel)
+ ("cl-speedy-queue" ,sbcl-cl-speedy-queue)
+ ("log4cl" ,sbcl-log4cl)
+ ("str" ,sbcl-cl-str)
+ ("blackbird" ,sbcl-blackbird)
+ ("cl-hamt" ,sbcl-cl-hamt)
+ ("binding-arrows" ,sbcl-binding-arrows)
+ ("atomics" ,sbcl-atomics)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("mock" ,sbcl-cl-mock)))
+ (home-page "https://mdbergmann.github.io/cl-gserver/index.html")
+ (synopsis "Actor framework for easy access to state and async operations")
+ (description
+ "@code{cl-gserver} is a 'message passing' library / framework with actors
+similar to Erlang or Akka. It supports creating reactive systems for parallel
+computing and event based message handling.")
+ (license license:agpl3)))
+
+(define-public ecl-cl-gserver
+ (sbcl-package->ecl-package sbcl-cl-gserver))
+
+(define-public cl-gserver
+ (sbcl-package->cl-source-package sbcl-cl-gserver))
+
+(define-public sbcl-cl-posix-mqueue
+ (let ((commit "8977370c7206d1f62bd1be80f4254af40654b83f")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-posix-mqueue")
+ (version (git-version "0.1.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xFA25E/cl-posix-mqueue")
+ (commit commit)))
+ (file-name (git-file-name "cl-posix-mqueue" version))
+ (sha256
+ (base32 "04519rg8vc782z097dzlb8nx0skab2fy2zd0m60r6mz2nw8xdvh6"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:test-asd-file "cl-posix-mqueue-tests.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-librt-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/spec.lisp"
+ (("librt.so" all)
+ (string-append (assoc-ref inputs "glibc") "/lib/" all))))))))
+ (native-inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("rove" ,sbcl-rove)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("cffi" ,sbcl-cffi)
+ ("glibc" ,glibc)
+ ("local-time" ,sbcl-local-time)))
+ (home-page "https://github.com/xFA25E/cl-posix-mqueue")
+ (synopsis "Common Lisp binding to POSIX mqueue")
+ (description
+ "This package provides Common Lisp bindings to POSIX message queue, an
+@acronym{IPC, Inter-Process Communication} method that is easy to use and quick
+to setup.")
+ (license license:gpl3))))
+
+(define-public ecl-cl-posix-mqueue
+ (sbcl-package->ecl-package sbcl-cl-posix-mqueue))
+
+(define-public cl-posix-mqueue
+ (sbcl-package->cl-source-package sbcl-cl-posix-mqueue))
+
+(define-public sbcl-sdl2
+ (let ((commit "bb2aa2a41cf799e3bb1ddf50de41fe389c6db668")
+ (revision "1"))
+ (package
+ (name "sbcl-sdl2")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/lispgames/cl-sdl2")
+ (commit commit)))
+ (file-name (git-file-name "cl-sdl2" version))
+ (sha256
+ (base32 "1a4904310z2wwq80grnlixmyz30452vgd4lh74y105j2yrr43z97"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libSDL2-2.0.so.0" all)
+ (string-append (assoc-ref inputs "libsdl2") "/lib/" all)))
+ #t)))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-autowrap" ,sbcl-cl-autowrap)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("libsdl2" ,sdl2)
+ ("trivial-channels" ,sbcl-trivial-channels)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://github.com/lispgames/cl-sdl2")
+ (synopsis "Common Lisp bindings for SDL2 using C2FFI")
+ (description
+ "This package provides a Common Lisp wrapper system for the SDL 2.0
+C Library.")
+ (license license:expat))))
+
+(define-public ecl-sdl2
+ (sbcl-package->ecl-package sbcl-sdl2))
+
+(define-public cl-sdl2
+ (sbcl-package->cl-source-package sbcl-sdl2))
+
+(define-public sbcl-cl-gamepad
+ (let ((commit "7e12137927b42db064ffbf9ea34bd4790ad4bb33")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-gamepad")
+ (version (git-version "3.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shirakumo/cl-gamepad")
+ (commit commit)))
+ (file-name (git-file-name "cl-gamepad" version))
+ (sha256
+ (base32 "1gzx590i7s81qmramnjvfzrrq5yppas8yxqq1jl3yzqhhjwjfvkd"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-evdev-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "evdev-cffi.lisp"
+ (("libevdev.so" all)
+ (string-append (assoc-ref inputs "libevdev")
+ "/lib/" all)))))
+ ;; Here we use a custom build phase to work around a compilation bug.
+ ;; Using 'asdf:compile-system' fails, but using 'asdf:load-system'
+ ;; succeeds (and also compiles the system).
+ ;; See https://github.com/Shirakumo/cl-gamepad/issues/8
+ (replace 'build
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (source-path (string-append out
+ "/share/common-lisp/"
+ (%lisp-type)))
+ (translations `((,source-path
+ :**/ :*.*.*)
+ (,(string-append out
+ "/lib/common-lisp/"
+ (%lisp-type))
+ :**/ :*.*.*))))
+ (setenv "ASDF_OUTPUT_TRANSLATIONS"
+ (format #f "~S" `(:output-translations
+ ,translations
+ :inherit-configuration)))
+ (setenv "HOME" (assoc-ref outputs "out"))
+ (with-directory-excursion (string-append source-path
+ "/cl-gamepad")
+ (invoke (%lisp-type)
+ "--eval" "(require :asdf)"
+ "--eval" "(asdf:load-asd (truename \"cl-gamepad.asd\"))"
+ "--eval" "(asdf:load-system :cl-gamepad)"
+ "--eval" "(quit)"))))))))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("libevdev" ,libevdev)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://shirakumo.github.io/cl-gamepad/")
+ (synopsis "Library for access to gamepads and joystick input devices")
+ (description
+ "This is a library to provide cross-platform access to gamepads,
+joysticks, and other such HID devices.")
+ (license license:zlib))))
+
+(define-public ecl-cl-gamepad
+ (sbcl-package->ecl-package sbcl-cl-gamepad))
+
+(define-public cl-gamepad
+ (sbcl-package->cl-source-package sbcl-cl-gamepad))
+
+(define-public sbcl-trial
+ (let ((commit "ba178cac3a5528c570c7e8dad66c58cc770db53a")
+ (revision "1"))
+ (package
+ (name "sbcl-trial")
+ (version (git-version "1.2.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shirakumo/trial")
+ (commit commit)))
+ (file-name (git-file-name "trial" version))
+ (sha256
+ (base32 "1vpv9nrpq93fz1c5cyi1hazaaz9ijbrf1l7zwp7gammndr5v028r"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("trivial-features" ,sbcl-trivial-features)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("3d-matrices" ,sbcl-3d-matrices)
+ ("3d-vectors" ,sbcl-3d-vectors)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-gamepad" ,sbcl-cl-gamepad)
+ ("cl-jpeg" ,sbcl-cl-jpeg)
+ ("cl-opengl" ,sbcl-cl-opengl)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-tga" ,sbcl-cl-tga)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("deploy" ,sbcl-deploy)
+ ("fast-io" ,sbcl-fast-io)
+ ("flare" ,sbcl-flare)
+ ("float-features" ,sbcl-float-features)
+ ("flow" ,sbcl-flow)
+ ("for" ,sbcl-for)
+ ("form-fiddle" ,sbcl-form-fiddle)
+ ("glsl-toolkit" ,sbcl-glsl-toolkit)
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("jsown" ,sbcl-jsown)
+ ("lambda-fiddle" ,sbcl-lambda-fiddle)
+ ("lquery" ,sbcl-lquery)
+ ("messagebox" ,sbcl-messagebox)
+ ("mmap" ,sbcl-mmap)
+ ("pathname-utils" ,sbcl-pathname-utils)
+ ("pngload" ,sbcl-pngload)
+ ("retrospectiff" ,sbcl-retrospectiff)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("terrable" ,sbcl-terrable)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("trivial-indent" ,sbcl-trivial-indent)
+ ("verbose" ,sbcl-verbose)
+ ("zpng" ,sbcl-zpng)))
+ (home-page "https://github.com/Shirakumo/trial")
+ (synopsis "Common Lisp game engine")
+ (description
+ "Trial is a game engine written in Common Lisp. Unlike many other
+engines, it is meant to be more of a loose connection of components that can be
+fit together as required by any particular game.")
+ (license license:zlib))))
+
+(define-public ecl-trial
+ (sbcl-package->ecl-package sbcl-trial))
+
+(define-public cl-trial
+ (sbcl-package->cl-source-package sbcl-trial))
+
+(define-public sbcl-org-sampler
+ (let ((commit "ee135a417750e5b1d810bb9574eb85223cb3038a")
+ (revision "1"))
+ (package
+ (name "sbcl-org-sampler")
+ (version (git-version "0.2.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jphmrst/cl-org-sampler")
+ (commit commit)))
+ (file-name (git-file-name "cl-org-sampler" version))
+ (sha256
+ (base32 "1dg029in14928qfxvfshyxmdwhzskzhxx3na0zy98ybx69b21qla"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)))
+ (home-page "https://github.com/jphmrst/cl-org-sampler")
+ (synopsis "Extracting Common Lisp docstrings as Emacs Org-mode documents")
+ (description
+ "ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode
+text for inclusion into a larger document.")
+ (license license:llgpl))))
+
+(define-public ecl-org-sampler
+ (sbcl-package->ecl-package sbcl-org-sampler))
+
+(define-public cl-org-sampler
+ (sbcl-package->cl-source-package sbcl-org-sampler))
+
+(define-public sbcl-acl-compat
+ ;; There does not seem to be proper releases.
+ (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5"))
+ (package
+ (name "sbcl-acl-compat")
+ (version (git-version "0.1.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "git://git.code.sf.net/p/portableaserve/git")
+ (commit commit)))
+ (file-name (git-file-name "acl-compat" version))
+ (sha256
+ (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'cd-acl-compat
+ (lambda _
+ (chdir "acl-compat")
+ #t)))))
+ (inputs
+ `(("puri" ,sbcl-puri)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("ironclad" ,sbcl-ironclad)
+ ("cl-fad" ,sbcl-cl-fad)))
+ (home-page "https://sourceforge.net/projects/portableaserve/")
+ (synopsis "AllegroServe, a web server written in Common Lisp")
+ (description
+ "The server part of AllegroServe can be used either as a standalone web
+server or a module loaded into an application to provide a user interface to
+the application. AllegroServe's proxy ability allows it to run on the gateway
+machine between some internal network and the Internet. AllegroServe's client
+functions allow Lisp programs to explore the web.")
+ (license license:llgpl))))
+
+(define-public cl-acl-compat
+ (sbcl-package->cl-source-package sbcl-acl-compat))
+
+(define-public sbcl-aserve
+ ;; There does not seem to be proper releases.
+ (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5"))
+ (package
+ (name "sbcl-aserve")
+ (version (git-version "1.2.50" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ ;; https://github.com/franzinc/aserve/ seems to be incompatible
+ ;; with SBCL, etc.
+ (url "git://git.code.sf.net/p/portableaserve/git")
+ (commit commit)))
+ (file-name (git-file-name "aserve" version))
+ (sha256
+ (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'cd-aserve
+ (lambda _
+ (chdir "aserve")
+ #t))
+ (add-after 'cd-aserve 'fix-asd
+ (lambda _
+ (substitute* "aserve.asd"
+ ((" :force t") ""))
+ #t))
+ (add-after 'cd-aserve 'fix-tests
+ (lambda _
+ (substitute* "test/t-aserve.cl"
+ (("\\(asdf:oos 'asdf:load-op :ptester\\)") ""))
+ #t)))))
+ (inputs
+ `(("acl-compat" ,sbcl-acl-compat)))
+ (home-page "https://franz.com/support/documentation/current/doc/aserve/aserve.html")
+ (synopsis "AllegroServe, a web server written in Common Lisp")
+ (description
+ "The server part of AllegroServe can be used either as a standalone web
+server or a module loaded into an application to provide a user interface to
+the application. AllegroServe's proxy ability allows it to run on the gateway
+machine between some internal network and the Internet. AllegroServe's client
+functions allow Lisp programs to explore the web.")
+ (license license:llgpl))))
+
+(define-public cl-aserve
+ (sbcl-package->cl-source-package sbcl-aserve))
+
+(define-public sbcl-rss
+ ;; No release.
+ (let ((commit "51d0145e91b86327ae5c36364f9c3048052e7a58"))
+ (package
+ (name "sbcl-rss")
+ (version (git-version "0.9.1.1" "2" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/cl-rss.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0wv3j13fj73gigriw5r9vi920hz05ld7zllsvbxdxvmyfy9k1kly"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("aserve" ,sbcl-aserve)
+ ("kmrcl" ,sbcl-kmrcl)
+ ("xmls" ,sbcl-xmls)))
+ (home-page "https://github.com/nsrahmad/cl-rss")
+ (synopsis "Common Lisp RSS processor")
+ (description
+ "This package provides a Common Lisp library for fetching and parsing
+RSS feeds data via HTTP. Currently, it supports RSS versions 0.90,
+0.91, and 0.92 as well as RSS version 2.")
+ (license license:bsd-3))))
+
+(define-public cl-rss
+ (sbcl-package->cl-source-package sbcl-rss))
+
+(define-public sbcl-trivial-with-current-source-form
+ (let ((commit "9e343e043a77a5478c1f77bb626db22335fbbfb8")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-with-current-source-form")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url
+ "https://github.com/scymtym/trivial-with-current-source-form")
+ (commit commit)))
+ (file-name (git-file-name "trivial-with-current-source-form" version))
+ (sha256
+ (base32 "15zs7mc422ycp1cvcxmirif1dq15mlmv8vzd6l6nzn4qgmph9wz0"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/scymtym/trivial-with-current-source-form")
+ (synopsis "Help producing better errors for macro users")
+ (description
+ "This library allows macro writers to provide better feedback to macro
+users when errors are signaled during macroexpansion. It uses the compiler's
+concept of a source-form to report where the error or warning is located.")
+ (license license:lgpl3))))
+
+(define-public ecl-trivial-with-current-source-form
+ ;; Trivial-with-current-source-form does not give any benefits on ECL.
+ ;; This package is so packages dependent on trivial-with-current-source-form
+ ;; can be loaded on ECL.
+ (sbcl-package->ecl-package sbcl-trivial-with-current-source-form))
+
+(define-public cl-trivial-with-current-source-form
+ (sbcl-package->cl-source-package sbcl-trivial-with-current-source-form))
+
+(define-public sbcl-tailrec
+ (let ((commit "a7cf91ef7bd73c118e96817e809a7ae587d4673f")
+ (revision "1"))
+ (package
+ (name "sbcl-tailrec")
+ (version (git-version "0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/charje/tailrec")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0a25xa2kqai480micv8ap5bg4pz1dg7q3lz61g1ygim96cdjpwhl"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandia" ,sbcl-alexandria)
+ ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)
+ ("trivial-with-current-source-form"
+ ,sbcl-trivial-with-current-source-form)))
+ (home-page "https://github.com/charje/tailrec")
+ (synopsis "Macro to optimize a Common Lisp function for tail recursion")
+ (description "Just wrap your Common Lisp function in this macro call and
+it will be optimized for tail recursion. You will be warned if the function
+is not tail recursive.")
+ (license license:llgpl))))
+
+(define-public ecl-tailrec
+ (sbcl-package->ecl-package sbcl-tailrec))
+
+(define-public cl-tailrec
+ (sbcl-package->cl-source-package sbcl-tailrec))
+
+(define-public sbcl-issr-core
+ (let ((commit "64e3b07a63a7ca3ad70ba42474f98ac4513580aa")
+ (revision "1"))
+ (package
+ (name "sbcl-issr-core")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/interactive-ssr/core")
+ (commit commit)))
+ (file-name (git-file-name "issr-core" version))
+ (sha256
+ (base32 "1bajb09crzadkirdpd6jrpcc55irjd4sxzavygr25l85pafyhniw"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-str" ,sbcl-cl-str)
+ ("global-vars" ,sbcl-global-vars)
+ ("plump" ,sbcl-plump)
+ ("tailrec" ,sbcl-tailrec)))
+ (home-page
+ "https://github.com/interactive-ssr/client/blob/master/main.org")
+ (synopsis "The core functionality for ISSR server modules")
+ (description
+ "ISSR core provides functions and variables for ISSR server modules so
+that different servers can behave similarly. The most important features are
+Document Object Model differencing to generate instructions to update a DOM,
+and DOM cleaning, to ensure that all remote DOMs are the same.")
+ (license license:llgpl))))
+
+(define-public ecl-issr-core
+ (sbcl-package->ecl-package sbcl-issr-core))
+
+(define-public cl-issr-core
+ (sbcl-package->cl-source-package sbcl-issr-core))
+
+(define-public sbcl-portal
+ (let ((commit "cc7ba6a54cea6ef63b17dcc6e653d91d9907f59e")
+ (revision "1"))
+ (package
+ (name "sbcl-portal")
+ (version (git-version "1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/charJe/portal")
+ (commit commit)))
+ (file-name (git-file-name "portal" version))
+ (sha256
+ (base32 "0fc81iwb4lpp8d2scdwafkixxwkfmq4gqns522zyb4bh6c1rfmwy"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("arrows" ,sbcl-arrows)
+ ("cl-base64" ,sbcl-cl-base64)
+ ("cl-str" ,sbcl-cl-str)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("global-vars" ,sbcl-global-vars)
+ ("ironclad" ,sbcl-ironclad)
+ ("parse-float" ,sbcl-parse-float)
+ ("usocket" ,sbcl-usocket)))
+ (home-page "https://github.com/charJe/portal")
+ (synopsis "Portable Websocket Server for Common Lisp")
+ (description
+ "This is a websocket server for Common Lisp using usockets to be
+portable between implementations and operating systems. It has a programming
+interface that allows for multiple websocket apps per server using Common Lisp
+keywords for different websocket events. It has useful restarts and
+customizable errors.")
+ (license license:llgpl))))
+
+(define-public ecl-portal
+ (sbcl-package->ecl-package sbcl-portal))
+
+(define-public cl-portal
+ (sbcl-package->cl-source-package sbcl-portal))
+
+(define-public sbcl-hunchenissr
+ (let ((commit "7df702f2e110999a2f31c7ebad81bfc39ac06670")
+ (revision "1"))
+ (package
+ (name "sbcl-hunchenissr")
+ (version (git-version "1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/interactive-ssr/hunchenissr")
+ (commit commit)))
+ (file-name (git-file-name "hunchenissr" version))
+ (sha256
+ (base32 "0826qrvk64pjspdklns29dv3zhzfhd6k42fq030xajv8a7hkcxda"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-base64" ,sbcl-cl-base64)
+ ("cl-str" ,sbcl-cl-str)
+ ("hunchentoot" ,sbcl-hunchentoot)
+ ("issr-core" ,sbcl-issr-core)
+ ("jonathan" ,sbcl-jonathan)
+ ("plump" ,sbcl-plump)
+ ("portal" ,sbcl-portal)))
+ (home-page "https://github.com/interactive-ssr/hunchenissr")
+ (synopsis "Interactive Server Side Rendering backend for Hunchentoot")
+ (description
+ "Hunchenissr works together with issr.js for the develpment of
+interactive (changing without page refreshes) websites making use of websocket
+and Common Lisp server HTML generation instead of mountains of convoluted
+Javascript.")
+ (license license:llgpl))))
+
+(define-public ecl-hunchenissr
+ (sbcl-package->ecl-package sbcl-hunchenissr))
+
+(define-public cl-hunchenissr
+ (sbcl-package->cl-source-package sbcl-hunchenissr))
+
+(define-public sbcl-hunchenissr-routes
+ (let ((commit "2e831975dc2a6c030f1b518747cf429be8484b31")
+ (revision "1"))
+ (package
+ (name "sbcl-hunchenissr-routes")
+ (version (git-version "0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/interactive-ssr/hunchenissr-routes")
+ (commit commit)))
+ (file-name (git-file-name "hunchenissr-routes" version))
+ (sha256
+ (base32 "1xyqacihxwk4vnffqlg93czmalscglp6sh3bwy3qwb7hdxv6yxz6"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-unification" ,sbcl-cl-unification)
+ ("hunchenissr" ,sbcl-hunchenissr)))
+ (home-page "https://github.com/interactive-ssr/hunchenissr-routes")
+ (synopsis "Enable path variables when using Hunchenissr")
+ (description
+ "This library enables path variables in networking routes when using
+Hunchenissr for Common Lisp. If a part of the path (between two slashes)
+starts with a question mark (?), that symbol (without question mark) will be
+bound to whatever value was in the same place in the URL (as a string).")
+ (license license:llgpl))))
+
+(define-public ecl-hunchenissr-routes
+ (sbcl-package->ecl-package sbcl-hunchenissr-routes))
+
+(define-public cl-hunchenissr-routes
+ (sbcl-package->cl-source-package sbcl-hunchenissr-routes))
HCoop / jackhill / guix / guix.git / blobdiff