gnu/packages/guile.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
   3 ;;; Copyright © 2014 Cyril Roelandt <tipecaml@gmail.com>
   4 ;;; Copyright © 2014, 2016, 2018 David Thompson <davet@gnu.org>
   5 ;;; Copyright © 2014, 2017, 2018 Mark H Weaver <mhw@netris.org>
   6 ;;; Copyright © 2015, 2017 Christopher Allan Webber <cwebber@dustycloud.org>
   7 ;;; Copyright © 2016 Jan Nieuwenhuizen <janneke@gnu.org>
   8 ;;; Copyright © 2016, 2017 Leo Famulari <leo@famulari.name>
   9 ;;; Copyright © 2016, 2019 Ricardo Wurmus <rekado@elephly.net>
  10 ;;; Copyright © 2017 Andy Wingo <wingo@igalia.com>
  11 ;;; Copyright © 2017 Marius Bakke <mbakke@fastmail.com>
  12 ;;; Copyright © 2017, 2019 Mathieu Othacehe <m.othacehe@gmail.com>
  13 ;;; Copyright © 2017 Tobias Geerinckx-Rice <me@tobias.gr>
  14 ;;; Copyright © 2017, 2018 Amirouche <amirouche@hypermove.net>
  15 ;;; Copyright © 2018 Danny Milosavljevic <dannym@scratchpost.org>
  16 ;;; Copyright © 2018 Eric Bavier <bavier@member.fsf.org>
  17 ;;; Copyright © 2019 Taylan Kammer <taylan.kammer@gmail.com>
  18 ;;;
  19 ;;; This file is part of GNU Guix.
  20 ;;;
  21 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  22 ;;; under the terms of the GNU General Public License as published by
  23 ;;; the Free Software Foundation; either version 3 of the License, or (at
  24 ;;; your option) any later version.
  25 ;;;
  26 ;;; GNU Guix is distributed in the hope that it will be useful, but
  27 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  28 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29 ;;; GNU General Public License for more details.
  30 ;;;
  31 ;;; You should have received a copy of the GNU General Public License
  32 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  33
  34 (define-module (gnu packages guile)
  35   #:use-module ((guix licenses) #:prefix license:)
  36   #:use-module (gnu packages)
  37   #:use-module (gnu packages autotools)
  38   #:use-module (gnu packages base)
  39   #:use-module (gnu packages bash)
  40   #:use-module (gnu packages bdw-gc)
  41   #:use-module (gnu packages compression)
  42   #:use-module (gnu packages dbm)
  43   #:use-module (gnu packages flex)
  44   #:use-module (gnu packages gawk)
  45   #:use-module (gnu packages gettext)
  46   #:use-module (gnu packages hurd)
  47   #:use-module (gnu packages libffi)
  48   #:use-module (gnu packages libunistring)
  49   #:use-module (gnu packages linux)
  50   #:use-module (gnu packages m4)
  51   #:use-module (gnu packages multiprecision)
  52   #:use-module (gnu packages pkg-config)
  53   #:use-module (gnu packages readline)
  54   #:use-module (gnu packages sqlite)
  55   #:use-module (gnu packages texinfo)
  56   #:use-module (gnu packages version-control)
  57   #:use-module (guix packages)
  58   #:use-module (guix download)
  59   #:use-module (guix git-download)
  60   #:use-module (guix build-system gnu)
  61   #:use-module (guix build-system guile)
  62   #:use-module (guix deprecation)
  63   #:use-module (guix utils)
  64   #:use-module (ice-9 match)
  65   #:use-module ((srfi srfi-1) #:prefix srfi-1:))
  66
  67 ;;; Commentary:
  68 ;;;
  69 ;;; GNU Guile, and modules and extensions.
  70 ;;;
  71 ;;; Code:
  72
  73 (define-public guile-1.8
  74   (package
  75    (name "guile")
  76    (version "1.8.8")
  77    (source (origin
  78             (method url-fetch)
  79             (uri (string-append "mirror://gnu/guile/guile-" version
  80                                 ".tar.gz"))
  81             (sha256
  82              (base32
  83               "0l200a0v7h8bh0cwz6v7hc13ds39cgqsmfrks55b1rbj5vniyiy3"))
  84             (patches (search-patches "guile-1.8-cpp-4.5.patch"))))
  85    (build-system gnu-build-system)
  86    (arguments '(#:configure-flags '("--disable-error-on-warning")
  87
  88                 ;; Insert a phase before `configure' to patch things up.
  89                 #:phases
  90                 (modify-phases %standard-phases
  91                   (add-before 'configure 'patch-stuff
  92                     (lambda* (#:key outputs #:allow-other-keys)
  93                       ;; Add a call to `lt_dladdsearchdir' so that
  94                       ;; `libguile-readline.so' & co. are in the
  95                       ;; loader's search path.
  96                       (substitute* "libguile/dynl.c"
  97                         (("lt_dlinit.*$" match)
  98                          (format #f
  99                                  "  ~a~%  lt_dladdsearchdir(\"~a/lib\");~%"
 100                                  match
 101                                  (assoc-ref outputs "out"))))
 102
 103                       ;; The usual /bin/sh...
 104                       (substitute* "ice-9/popen.scm"
 105                         (("/bin/sh") (which "sh")))
 106                       #t)))))
 107
 108    ;; When cross-compiling, a native version of Guile itself is needed.
 109    (native-inputs (if (%current-target-system)
 110                       `(("self" ,this-package))
 111                       '()))
 112
 113    (inputs `(("gawk" ,gawk)
 114              ("readline" ,readline)))
 115
 116    ;; Since `guile-1.8.pc' has "Libs: ... -lgmp -lltdl", these must be
 117    ;; propagated.
 118    (propagated-inputs `(("gmp" ,gmp)
 119                         ("libltdl" ,libltdl)))
 120
 121    (native-search-paths
 122     (list (search-path-specification
 123            (variable "GUILE_LOAD_PATH")
 124            (files '("share/guile/site")))))
 125
 126    (synopsis "Scheme implementation intended especially for extensions")
 127    (description
 128     "Guile is the GNU Ubiquitous Intelligent Language for Extensions, the
 129 official extension language of the GNU system.  It is an implementation of
 130 the Scheme language which can be easily embedded in other applications to
 131 provide a convenient means of extending the functionality of the application
 132 without requiring the source code to be rewritten.")
 133    (home-page "https://www.gnu.org/software/guile/")
 134    (license license:lgpl2.0+)))
 135
 136 (define-public guile-2.0
 137   (package
 138    (name "guile")
 139    (version "2.0.14")
 140    (source (origin
 141             (method url-fetch)
 142             (uri (string-append "mirror://gnu/guile/guile-" version
 143                                 ".tar.xz"))
 144             (sha256
 145              (base32
 146               "10lxc6l5alf3lzbs3ihnbfy6dfcrsyf8667wa57f26vf4mk2ai78"))))
 147    (build-system gnu-build-system)
 148
 149    ;; When cross-compiling, a native version of Guile itself is needed.
 150    (native-inputs `(,@(if (%current-target-system)
 151                           `(("self" ,this-package))
 152                           '())
 153                     ("pkgconfig" ,pkg-config)))
 154    (inputs `(("libffi" ,libffi)
 155              ,@(libiconv-if-needed)
 156
 157              ;; We need Bash when cross-compiling because some of the scripts
 158              ;; in bin/ refer to it.  Use 'bash-minimal' because we don't need
 159              ;; an interactive Bash with Readline and all.
 160              ,@(if (target-mingw?) '() `(("bash" ,bash-minimal)))))
 161    (propagated-inputs
 162     `( ;; These ones aren't normally needed here, but since `libguile-2.0.la'
 163        ;; reads `-lltdl -lunistring', adding them here will add the needed
 164        ;; `-L' flags.  As for why the `.la' file lacks the `-L' flags, see
 165        ;; <http://thread.gmane.org/gmane.comp.lib.gnulib.bugs/18903>.
 166       ("libunistring" ,libunistring)
 167
 168       ;; Depend on LIBLTDL, not LIBTOOL.  That way, we avoid some the extra
 169       ;; dependencies that LIBTOOL has, which is helpful during bootstrap.
 170       ("libltdl" ,libltdl)
 171
 172       ;; The headers and/or `guile-2.0.pc' refer to these packages, so they
 173       ;; must be propagated.
 174       ("bdw-gc" ,libgc)
 175       ("gmp" ,gmp)))
 176
 177    (outputs '("out" "debug"))
 178
 179    (arguments
 180     `(#:configure-flags '("--disable-static") ; saves 3 MiB
 181       #:phases
 182       (modify-phases %standard-phases
 183         (add-before 'configure 'pre-configure
 184           (lambda* (#:key inputs #:allow-other-keys)
 185             ;; Tell (ice-9 popen) the file name of Bash.
 186             (let ((bash (assoc-ref inputs "bash")))
 187               (substitute* "module/ice-9/popen.scm"
 188                 ;; If bash is #f allow fallback for user to provide
 189                 ;; "bash" in PATH.  This happens when cross-building to
 190                 ;; MinGW for which we do not have Bash yet.
 191                 (("/bin/sh")
 192                  ,@(if (target-mingw?)
 193                        '((if bash
 194                              (string-append bash "/bin/bash")
 195                              "bash"))
 196                        '((string-append bash "/bin/bash")))))
 197               #t))))))
 198
 199    (native-search-paths
 200     (list (search-path-specification
 201            (variable "GUILE_LOAD_PATH")
 202            (files '("share/guile/site/2.0")))
 203           (search-path-specification
 204            (variable "GUILE_LOAD_COMPILED_PATH")
 205            (files '("lib/guile/2.0/site-ccache")))))
 206
 207    (synopsis "Scheme implementation intended especially for extensions")
 208    (description
 209     "Guile is the GNU Ubiquitous Intelligent Language for Extensions, the
 210 official extension language of the GNU system.  It is an implementation of
 211 the Scheme language which can be easily embedded in other applications to
 212 provide a convenient means of extending the functionality of the application
 213 without requiring the source code to be rewritten.")
 214    (home-page "https://www.gnu.org/software/guile/")
 215    (license license:lgpl3+)))
 216
 217 (define-public guile-2.2
 218   (package (inherit guile-2.0)
 219     (name "guile")
 220     (version "2.2.7")
 221     (source (origin
 222               (method url-fetch)
 223
 224               ;; Note: we are limited to one of the compression formats
 225               ;; supported by the bootstrap binaries, so no lzip here.
 226               (uri (string-append "mirror://gnu/guile/guile-" version
 227                                   ".tar.xz"))
 228               (sha256
 229                (base32
 230                 "013mydzhfswqci6xmyc1ajzd59pfbdak15i0b090nhr9bzm7dxyd"))
 231               (modules '((guix build utils)))
 232               (patches (search-patches
 233                         "guile-2.2-skip-oom-test.patch"))
 234
 235               ;; Remove the pre-built object files.  Instead, build everything
 236               ;; from source, at the expense of significantly longer build
 237               ;; times (almost 3 hours on a 4-core Intel i5).
 238               (snippet '(begin
 239                           (for-each delete-file
 240                                     (find-files "prebuilt" "\\.go$"))
 241                           #t))))
 242     (properties '((timeout . 72000)               ;20 hours
 243                   (max-silent-time . 36000)))     ;10 hours (needed on ARM
 244                                                   ;  when heavily loaded)
 245     (native-search-paths
 246      (list (search-path-specification
 247             (variable "GUILE_LOAD_PATH")
 248             (files '("share/guile/site/2.2")))
 249            (search-path-specification
 250             (variable "GUILE_LOAD_COMPILED_PATH")
 251             (files '("lib/guile/2.2/site-ccache")))))))
 252
 253 (define-deprecated guile-2.2/bug-fix guile-2.2)
 254
 255 (define-public guile-2.2.4
 256   (package/inherit
 257    guile-2.2
 258    (version "2.2.4")
 259    (source (origin
 260              (inherit (package-source guile-2.2))
 261              (uri (string-append "mirror://gnu/guile/guile-" version
 262                                  ".tar.xz"))
 263              (sha256
 264               (base32
 265                "07p3g0v2ba2vlfbfidqzlgbhnzdx46wh2rgc5gszq1mjyx5bks6r"))))))
 266
 267 (define-public guile-3.0
 268   ;; This is the latest Guile stable version.
 269   (package
 270     (inherit guile-2.2)
 271     (name "guile")
 272     (version "3.0.1")
 273     (source (origin
 274               (inherit (package-source guile-2.2))
 275               (uri (string-append "mirror://gnu/guile/guile-"
 276                                   version ".tar.xz"))
 277               (sha256
 278                (base32
 279                 "1jakps3127h8g69ixgb4zwc8v2g29dmwql1vi3pwg30kzp8fm5nn"))
 280               (patches
 281                (append (search-patches "guile-3.0-crash.patch")
 282                        (origin-patches (package-source guile-2.2))))))
 283     (native-search-paths
 284      (list (search-path-specification
 285             (variable "GUILE_LOAD_PATH")
 286             (files '("share/guile/site/3.0")))
 287            (search-path-specification
 288             (variable "GUILE_LOAD_COMPILED_PATH")
 289             (files '("lib/guile/3.0/site-ccache"
 290                      "share/guile/site/3.0")))))))
 291
 292 (define-public guile-next guile-3.0)
 293
 294 (define-public guile-3.0/fixed
 295   ;; A package of Guile that's rarely changed.  It is the one used in the
 296   ;; `base' module, and thus changing it entails a full rebuild.
 297   (package
 298     (inherit guile-3.0)
 299     (properties '((hidden? . #t)            ;people should install 'guile-2.2'
 300                   (timeout . 72000)             ;20 hours
 301                   (max-silent-time . 36000))))) ;10 hours (needed on ARM
 302                                                 ;  when heavily loaded)
 303
 304 (define* (make-guile-readline guile #:optional (name "guile-readline"))
 305   (package
 306     (name name)
 307     (version (package-version guile))
 308     (source (package-source guile))
 309     (build-system gnu-build-system)
 310     (arguments
 311      '(#:configure-flags '("--disable-silent-rules")
 312        #:phases (modify-phases %standard-phases
 313                   (add-before 'build 'chdir
 314                     (lambda* (#:key outputs #:allow-other-keys)
 315                       (invoke "make" "-C" "libguile" "scmconfig.h")
 316                       (invoke "make" "-C" "lib")
 317                       (chdir "guile-readline")
 318
 319                       (substitute* "Makefile"
 320                         (("../libguile/libguile-[[:graph:]]+\\.la")
 321                          ;; Remove dependency on libguile-X.Y.la.
 322                          "")
 323                         (("^READLINE_LIBS = (.*)$" _ libs)
 324                          ;; Link against the provided libguile.
 325                          (string-append "READLINE_LIBS = "
 326                                         "-lguile-$(GUILE_EFFECTIVE_VERSION) "
 327                                         libs "\n"))
 328                         (("\\$\\(top_builddir\\)/meta/build-env")
 329                          ;; Use the provided Guile, not the one from
 330                          ;; $(builddir).
 331                          "")
 332
 333                         ;; Install modules to the 'site' directories.
 334                         (("^moddir = .*$")
 335                          "moddir = $(pkgdatadir)/site/$(GUILE_EFFECTIVE_VERSION)\n")
 336                         (("^ccachedir = .*$")
 337                          "ccachedir = $(pkglibdir)/$(GUILE_EFFECTIVE_VERSION)/site-ccache\n"))
 338
 339                       ;; Load 'guile-readline.so' from the right place.
 340                       (substitute* "ice-9/readline.scm"
 341                         (("load-extension \"guile-readline\"")
 342                          (format #f "load-extension \
 343  (string-append ~s \"/lib/guile/\" (effective-version) \"/extensions/guile-readline\")"
 344                                  (assoc-ref outputs "out"))))
 345                       #t)))))
 346     (home-page (package-home-page guile))
 347     (native-inputs (package-native-inputs guile))
 348     (inputs
 349      `(,@(package-inputs guile)                   ;to placate 'configure'
 350        ,@(package-propagated-inputs guile)
 351        ("guile" ,guile)
 352        ("readline" ,readline)))
 353     (synopsis "Line editing support for GNU Guile")
 354     (description
 355      "This module provides line editing support via the Readline library for
 356 GNU@tie{}Guile.  Use the @code{(ice-9 readline)} module and call its
 357 @code{activate-readline} procedure to enable it.")
 358     (license license:gpl3+)))
 359
 360 (define-public guile-readline
 361   (make-guile-readline guile-3.0))
 362
 363 (define-public guile2.2-readline
 364   (make-guile-readline guile-2.2 "guile2.2-readline"))
 365
 366 (define (guile-variant-package-name prefix)
 367   (lambda (name)
 368     "Return NAME with PREFIX instead of \"guile-\", when applicable."
 369     (if (string-prefix? "guile-" name)
 370         (string-append prefix "-"
 371                        (string-drop name
 372                                     (string-length "guile-")))
 373         name)))
 374
 375 (define package-for-guile-2.0
 376   ;; A procedure that rewrites the dependency tree of the given package to use
 377   ;; GUILE-2.0 instead of GUILE-2.2.
 378   (package-input-rewriting `((,guile-2.2 . ,guile-2.0))
 379                            (guile-variant-package-name "guile2.0")))
 380
 381 (define package-for-guile-2.2
 382   (package-input-rewriting `((,guile-3.0 . ,guile-2.2))
 383                            (guile-variant-package-name "guile2.2")))
 384
 385 (define-syntax define-deprecated-guile3.0-package
 386   (lambda (s)
 387     "Define a deprecated package alias for \"guile3.0-something\"."
 388     (syntax-case s ()
 389       ((_ name)
 390        (and (identifier? #'name)
 391             (string-prefix? "guile3.0-" (symbol->string (syntax->datum
 392                                                          #'name))))
 393        (let ((->guile (lambda (str)
 394                         (let ((base (string-drop str
 395                                                  (string-length "guile3.0-"))))
 396                           (string-append "guile-" base)))))
 397          (with-syntax ((package-name (symbol->string (syntax->datum #'name)))
 398                        (package
 399                          (datum->syntax
 400                           #'name
 401                           (string->symbol
 402                            (->guile (symbol->string (syntax->datum #'name)))))))
 403            #'(begin
 404                (define-deprecated name package
 405                  (deprecated-package package-name package))
 406                (export name))))))))
 407
 408 (define-deprecated-guile3.0-package guile3.0-readline)
 409
 410 (define-public guile-for-guile-emacs
 411   (package (inherit guile-2.2)
 412     (name "guile-for-guile-emacs")
 413     (version "20150510.d8d9a8d")
 414     (source (origin
 415               (method git-fetch)
 416               (uri (git-reference
 417                     (url "git://git.hcoop.net/git/bpt/guile.git")
 418                     (commit "d8d9a8da05ec876acba81a559798eb5eeceb5a17")))
 419               (file-name (string-append name "-" version "-checkout"))
 420               (sha256
 421                (base32
 422                 "00sprsshy16y8pxjy126hr2adqcvvzzz96hjyjwgg8swva1qh6b0"))))
 423     (arguments
 424      `(;; Tests aren't passing for now.
 425        ;; Obviously we should re-enable this!
 426        #:tests? #f
 427        ,@(package-arguments guile-2.2)))
 428     (native-inputs
 429      `(("autoconf" ,autoconf)
 430        ("automake" ,automake)
 431        ("libtool" ,libtool)
 432        ("flex" ,flex)
 433        ("texinfo" ,texinfo)
 434        ("gettext" ,gettext-minimal)
 435        ,@(package-native-inputs guile-2.2)))
 436     ;; Same as in guile-2.0
 437     (native-search-paths
 438      (list (search-path-specification
 439             (variable "GUILE_LOAD_PATH")
 440             (files '("share/guile/site/2.0")))
 441            (search-path-specification
 442             (variable "GUILE_LOAD_COMPILED_PATH")
 443             (files '("lib/guile/2.0/site-ccache"
 444                      "share/guile/site/2.0")))))))
 445
 446 \f
 447 ;;;
 448 ;;; Extensions.
 449 ;;;
 450
 451 (define-public guile-json-1
 452   (package
 453     (name "guile-json")
 454     (version "1.2.0")
 455     (home-page "https://github.com/aconchillo/guile-json")
 456     (source (origin
 457               (method url-fetch)
 458               (uri (string-append "mirror://savannah/guile-json/guile-json-"
 459                                   version ".tar.gz"))
 460               (sha256
 461                (base32
 462                 "15gnb84d7hpazqhskkf3g9z4r6knw54wfj4ch5270kakz1lp70c9"))))
 463     (build-system gnu-build-system)
 464     (native-inputs `(("pkg-config" ,pkg-config)
 465                      ("guile" ,guile-2.2)))
 466     (inputs `(("guile" ,guile-2.2)))
 467     (synopsis "JSON module for Guile")
 468     (description
 469      "Guile-JSON supports parsing and building JSON documents according to the
 470 specification.  These are the main features:
 471
 472 @itemize
 473 @item Strictly complies to @uref{http://json.org, specification}.
 474 @item Build JSON documents programmatically via macros.
 475 @item Unicode support for strings.
 476 @item Allows JSON pretty printing.
 477 @end itemize\n")
 478
 479     ;; Version 1.2.0 switched to GPLv3+ (from LGPLv3+).
 480     (license license:gpl3+)))
 481
 482 ;; Deprecate the 'guile-json' alias to force the use 'guile-json-1' or
 483 ;; 'guile-json-3'.  In the future, we may reuse 'guile-json' as an alias for
 484 ;; 'guile-json-3'.
 485 (define-deprecated guile-json guile-json-1)
 486 (export guile-json)
 487
 488 (define-public guile2.0-json
 489   (package-for-guile-2.0 guile-json-1))
 490
 491 (define-public guile-json-3
 492   ;; This version is incompatible with 1.x; see the 'NEWS' file.
 493   (package
 494     (inherit guile-json-1)
 495     (name "guile-json")
 496     (version "3.2.0")
 497     (source (origin
 498               (method url-fetch)
 499               (uri (string-append "mirror://savannah/guile-json/guile-json-"
 500                                   version ".tar.gz"))
 501               (sha256
 502                (base32
 503                 "14m6b6g2maw0mkvfm4x63rqb54vgbpn1gcqs715ijw4bikfzlqfz"))))
 504     (native-inputs `(("pkg-config" ,pkg-config)
 505                      ("guile" ,guile-3.0)))
 506     (inputs `(("guile" ,guile-3.0)))))
 507
 508 (define-public guile2.2-json
 509   (package-for-guile-2.2 guile-json-3))
 510
 511 (define-public guile3.0-json
 512   (deprecated-package "guile3.0-json" guile-json-3))
 513
 514 ;; There are two guile-gdbm packages, one using the FFI and one with
 515 ;; direct C bindings, hence the verbose name.
 516
 517 (define-public guile-gdbm-ffi
 518   (package
 519     (name "guile-gdbm-ffi")
 520     (version "20120209.fa1d5b6")
 521     (source (origin
 522               (method git-fetch)
 523               (uri (git-reference
 524                     (url "https://github.com/ijp/guile-gdbm.git")
 525                     (commit "fa1d5b6231d0e4d096687b378c025f2148c5f246")))
 526               (file-name (string-append name "-" version "-checkout"))
 527               (patches (search-patches
 528                         "guile-gdbm-ffi-support-gdbm-1.14.patch"))
 529               (sha256
 530                (base32
 531                 "1j8wrsw7v9w6qkl47xz0rdikg50v16nn6kbs3lgzcymjzpa7babj"))))
 532     (build-system guile-build-system)
 533     (arguments
 534      '(#:phases (modify-phases %standard-phases
 535                   (add-after 'unpack 'move-examples
 536                     (lambda* (#:key outputs #:allow-other-keys)
 537                       ;; Move examples where they belong.
 538                       (let* ((out (assoc-ref outputs "out"))
 539                              (doc (string-append out "/share/doc/"
 540                                                  (strip-store-file-name out)
 541                                                  "/examples")))
 542                         (copy-recursively "examples" doc)
 543                         (delete-file-recursively "examples")
 544                         #t)))
 545                   (add-after 'unpack 'set-libgdbm-file-name
 546                     (lambda* (#:key inputs #:allow-other-keys)
 547                       (substitute* "gdbm.scm"
 548                         (("\\(dynamic-link \"libgdbm\"\\)")
 549                          (format #f "(dynamic-link \"~a/lib/libgdbm.so\")"
 550                                  (assoc-ref inputs "gdbm"))))
 551                       #t)))))
 552     (native-inputs
 553      `(("guile" ,guile-3.0)))
 554     (inputs
 555      `(("gdbm" ,gdbm)))
 556     (home-page "https://github.com/ijp/guile-gdbm")
 557     (synopsis "Guile bindings to the GDBM library via Guile's FFI")
 558     (description
 559      "Guile bindings to the GDBM key-value storage system, using
 560 Guile's foreign function interface.")
 561     (license license:gpl3+)))
 562
 563 (define-public guile2.0-gdbm-ffi
 564   (package-for-guile-2.0 guile-gdbm-ffi))
 565
 566 (define-public guile2.2-gdbm-ffi
 567   (package-for-guile-2.2 guile-gdbm-ffi))
 568
 569 (define-deprecated-guile3.0-package guile3.0-gdbm-ffi)
 570
 571 (define-public guile-sqlite3
 572   (package
 573     (name "guile-sqlite3")
 574     (version "0.1.0")
 575     (home-page "https://notabug.org/guile-sqlite3/guile-sqlite3.git")
 576     (source (origin
 577               (method git-fetch)
 578               (uri (git-reference
 579                     (url home-page)
 580                     (commit (string-append "v" version))))
 581               (sha256
 582                (base32
 583                 "1nv8j7wk6b5n4p22szyi8lv8fs31rrzxhzz16gyj8r38c1fyp9qp"))
 584               (file-name (string-append name "-" version "-checkout"))
 585               (patches
 586                (search-patches "guile-sqlite3-fix-cross-compilation.patch"))
 587               (modules '((guix build utils)))
 588               (snippet
 589                '(begin
 590                   ;; Allow builds with Guile 3.0.
 591                   (substitute* "configure.ac"
 592                     (("^GUILE_PKG.*")
 593                      "GUILE_PKG([3.0 2.2 2.0])\n"))
 594                   #t))))
 595     (build-system gnu-build-system)
 596     (native-inputs
 597      `(("autoconf" ,autoconf)
 598        ("automake" ,automake)
 599        ("guile" ,guile-3.0)
 600        ("pkg-config" ,pkg-config)))
 601     (inputs
 602      `(("guile" ,guile-3.0)
 603        ("sqlite" ,sqlite)))
 604     (synopsis "Access SQLite databases from Guile")
 605     (description
 606      "This package provides Guile bindings to the SQLite database system.")
 607     (license license:gpl3+)))
 608
 609 (define-public guile2.0-sqlite3
 610   (package-for-guile-2.0 guile-sqlite3))
 611
 612 (define-public guile2.2-sqlite3
 613   (package-for-guile-2.2 guile-sqlite3))
 614
 615 (define-deprecated-guile3.0-package guile3.0-sqlite3)
 616
 617 (define-public guile-bytestructures
 618   (package
 619     (name "guile-bytestructures")
 620     (version "1.0.7")
 621     (home-page "https://github.com/TaylanUB/scheme-bytestructures")
 622     (source (origin
 623               (method git-fetch)
 624               (uri (git-reference
 625                     (url home-page)
 626                     (commit (string-append "v" version))))
 627               (file-name (git-file-name name version))
 628               (sha256
 629                (base32
 630                 "0q0habjiy3h9cigb7q1br9kz6z212dn2ab31f6dgd3rrmsfn5rvb"))))
 631     (build-system gnu-build-system)
 632     (arguments
 633      `(#:make-flags '("GUILE_AUTO_COMPILE=0")     ;to prevent guild warnings
 634
 635        #:phases (modify-phases %standard-phases
 636                   (add-after 'install 'install-doc
 637                     (lambda* (#:key outputs #:allow-other-keys)
 638                       (let* ((out (assoc-ref outputs "out"))
 639                              (package ,(package-full-name this-package "-"))
 640                              (doc (string-append out "/share/doc/" package)))
 641                         (install-file "README.md" doc)
 642                         #t))))))
 643     (native-inputs
 644      `(("autoconf" ,autoconf)
 645        ("automake" ,automake)
 646        ("pkg-config" ,pkg-config)
 647        ("guile" ,guile-3.0)))
 648     (inputs
 649      `(("guile" ,guile-3.0)))
 650     (synopsis "Structured access to bytevector contents for Guile")
 651     (description
 652      "Guile bytestructures offers a system imitating the type system
 653 of the C programming language, to be used on bytevectors.  C's type
 654 system works on raw memory, and Guile works on bytevectors which are
 655 an abstraction over raw memory.  It's also more powerful than the C
 656 type system, elevating types to first-class status.")
 657     (license license:gpl3+)
 658     (properties '((upstream-name . "bytestructures")))))
 659
 660 (define-public guile2.0-bytestructures
 661   (package-for-guile-2.0 guile-bytestructures))
 662
 663 (define-public guile2.2-bytestructures
 664   (package-for-guile-2.2 guile-bytestructures))
 665
 666 (define-deprecated-guile3.0-package guile3.0-bytestructures)
 667
 668 (define-public guile-git
 669   (package
 670     (name "guile-git")
 671     (version "0.3.0")
 672     (home-page "https://gitlab.com/guile-git/guile-git.git")
 673     (source (origin
 674               (method url-fetch)
 675               (uri (string-append "https://gitlab.com/guile-git/guile-git/uploads/"
 676                                   "4c563d8e7e1ff84396abe8ca7011bcaf/guile-git-"
 677                                   version ".tar.gz"))
 678               (sha256
 679                (base32
 680                 "0c5i3d16hp7gp9rd78vk9zc45js8bphf92m4lbb5gyi4l1yl7kkm"))))
 681     (build-system gnu-build-system)
 682     (native-inputs
 683      `(("pkg-config" ,pkg-config)
 684        ("guile" ,guile-3.0)
 685        ("guile-bytestructures" ,guile-bytestructures)))
 686     (inputs
 687      `(("guile" ,guile-3.0)
 688        ("libgit2" ,libgit2)))
 689     (propagated-inputs
 690      `(("guile-bytestructures" ,guile-bytestructures)))
 691     (synopsis "Guile bindings for libgit2")
 692     (description
 693      "This package provides Guile bindings to libgit2, a library to
 694 manipulate repositories of the Git version control system.")
 695     (license license:gpl3+)))
 696
 697 (define-public guile2.2-git
 698   (package-for-guile-2.2 guile-git))
 699
 700 (define-public guile2.0-git
 701   (let ((base (package-for-guile-2.0 guile-git)))
 702     (package
 703       (inherit base)
 704       ;; Libgit2's Guile test driver requires (ice-9 textual-ports), which is
 705       ;; not in Guile 2.0.  Thus, keep LIBGIT2 as-is here (i.e., built against
 706       ;; Guile 2.2).
 707       (inputs `(("libgit2" ,libgit2)
 708                 ,@(srfi-1:alist-delete "libgit2"
 709                                        (package-inputs base)))))))
 710
 711 (define-deprecated-guile3.0-package guile3.0-git)
 712
 713 ;;; guile.scm ends here
 714