[jackhill/guix/guix.git] / gnu / packages / guile.scm

;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2012, 2013 Ludovic Courtès <ludo@gnu.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages guile)
  #:use-module (guix licenses)
  #:use-module (gnu packages)
  #:use-module (gnu packages bdw-gc)
  #:use-module (gnu packages gawk)
  #:use-module (gnu packages gperf)
  #:use-module (gnu packages libffi)
  #:use-module (gnu packages autotools)
  #:use-module (gnu packages libunistring)
  #:use-module (gnu packages m4)
  #:use-module (gnu packages multiprecision)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages readline)
  #:use-module (gnu packages ncurses)
  #:use-module (gnu packages ed)
  #:use-module (gnu packages which)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix build-system gnu))

;;; Commentary:
;;;
;;; GNU Guile, and modules and extensions.
;;;
;;; Code:

(define-public guile-1.8
  (package
   (name "guile")
   (version "1.8.8")
   (source (origin
            (method url-fetch)
            (uri (string-append "mirror://gnu/guile/guile-" version
                                ".tar.gz"))
            (sha256
             (base32
              "0l200a0v7h8bh0cwz6v7hc13ds39cgqsmfrks55b1rbj5vniyiy3"))))
   (build-system gnu-build-system)
   (arguments '(#:configure-flags '("--disable-error-on-warning")
                #:patches (list (assoc-ref %build-inputs "patch/snarf"))

                ;; Insert a phase before `configure' to patch things up.
                #:phases (alist-cons-before
                           'configure
                           'patch-stuff
                           (lambda* (#:key outputs #:allow-other-keys)
                             ;; Add a call to `lt_dladdsearchdir' so that
                             ;; `libguile-readline.so' & co. are in the
                             ;; loader's search path.
                             (substitute* "libguile/dynl.c"
                               (("lt_dlinit.*$" match)
                                (format #f
                                        "  ~a~%  lt_dladdsearchdir(\"~a/lib\");~%"
                                        match
                                        (assoc-ref outputs "out"))))

                             ;; The usual /bin/sh...
                             (substitute* "ice-9/popen.scm"
                               (("/bin/sh") (which "sh"))))
                           %standard-phases)))
   (inputs `(("patch/snarf" ,(search-patch "guile-1.8-cpp-4.5.patch"))
             ("gawk" ,gawk)
             ("readline" ,readline)))

   ;; Since `guile-1.8.pc' has "Libs: ... -lgmp -lltdl", these must be
   ;; propagated.
   (propagated-inputs `(("gmp" ,gmp)
                        ("libtool" ,libtool)))

   ;; When cross-compiling, a native version of Guile itself is needed.
   (self-native-input? #t)

   (synopsis "GNU Guile 1.8, an embeddable Scheme interpreter")
   (description
"GNU Guile 1.8 is an interpreter for the Scheme programming language,
packaged as a library that can be embedded into programs to make them
extensible.  It supports many SRFIs.")
   (home-page "http://www.gnu.org/software/guile/")
   (license lgpl2.0+)))

(define-public guile-2.0
  (package
   (name "guile")
   (version "2.0.7")
   (source (origin
            (method url-fetch)
            (uri (string-append "mirror://gnu/guile/guile-" version
                                ".tar.xz"))
            (sha256
             (base32
              "0f53pxkia4v17n0avwqlcjpy0n89hkazm2xsa6p84lv8k6k8y9vg"))))
   (build-system gnu-build-system)
   (native-inputs `(("pkgconfig" ,pkg-config)))
   (inputs `(("libffi" ,libffi)
             ("readline" ,readline)))

   (propagated-inputs
    `( ;; These ones aren't normally needed here, but since `libguile-2.0.la'
       ;; reads `-lltdl -lunistring', adding them here will add the needed
       ;; `-L' flags.  As for why the `.la' file lacks the `-L' flags, see
       ;; <http://thread.gmane.org/gmane.comp.lib.gnulib.bugs/18903>.
      ("libunistring" ,libunistring)
      ("libtool" ,libtool)

      ;; The headers and/or `guile-2.0.pc' refer to these packages, so they
      ;; must be propagated.
      ("bdw-gc" ,libgc)
      ("gmp" ,gmp)))

   (self-native-input? #t)

   (arguments
    '(#:phases (alist-cons-before
                'configure 'pre-configure
                (lambda* (#:key inputs #:allow-other-keys)
                  (let ((bash (assoc-ref inputs "bash")))
                    (substitute* "module/ice-9/popen.scm"
                      (("/bin/sh")
                       (string-append bash "/bin/bash")))))
                %standard-phases)))

   (synopsis "GNU Guile 2.0, an embeddable Scheme implementation")
   (description
"GNU Guile is an implementation of the Scheme programming language, with
support for many SRFIs, packaged for use in a wide variety of environments.
In addition to implementing the R5RS Scheme standard and a large subset of
R6RS, Guile includes a module system, full access to POSIX system calls,
networking support, multiple threads, dynamic linking, a foreign function
call interface, and powerful string processing.")
   (home-page "http://www.gnu.org/software/guile/")
   (license lgpl3+)))

(define-public guile-2.0/fixed
  ;; A package of Guile 2.0 that's rarely changed.  It is the one used
  ;; in the `base' module, and thus changing it entails a full rebuild.
  guile-2.0)

\f
;;;
;;; Extensions.
;;;

(define (guile-reader guile)
  "Build Guile-Reader against GUILE, a package of some version of Guile 1.8
or 2.0."
  (package
   (name (string-append "guile-reader-for-guile_" (package-version guile)))
   (version "0.6")
   (source  (origin
             (method url-fetch)
             (uri (string-append
                   "http://download-mirror.savannah.gnu.org/releases/guile-reader/guile-reader-"
                   version ".tar.gz"))
             (sha256
              (base32
               "1svlyk5pm4fsdp2g7n6qffdl6fdggxnlicj0jn9s4lxd63gzxy1n"))))
   (build-system gnu-build-system)
   (native-inputs `(("pkgconfig" ,pkg-config)
                    ("gperf" ,gperf)))
   (inputs `(("guile" ,guile)))
   (synopsis "Guile-Reader, a simple framework for building readers for
GNU Guile")
   (description
"Guile-Reader is a simple framework for building readers for GNU Guile.

The idea is to make it easy to build procedures that extend Guile’s read
procedure. Readers supporting various syntax variants can easily be written,
possibly by re-using existing “token readers” of a standard Scheme
readers. For example, it is used to implement Skribilo’s R5RS-derived
document syntax.

Guile-Reader’s approach is similar to Common Lisp’s “read table”, but
hopefully more powerful and flexible (for instance, one may instantiate as
many readers as needed).")
   (home-page "http://www.nongnu.org/guile-reader/")
   (license gpl3+)))

(define-public guile-reader/guile-1.8
  ;; Guile-Reader built against Guile 1.8.
  (guile-reader guile-1.8))

(define-public guile-reader/guile-2.0
  ;; Guile-Reader built against Guile 2.0.
  (guile-reader guile-2.0))

(define-public guile-ncurses
  (package
    (name "guile-ncurses")
    (version "1.3")
    (source (origin
             (method url-fetch)
             (uri (string-append "mirror://gnu/guile-ncurses/guile-ncurses-"
                                 version ".tar.gz"))
             (sha256
              (base32
               "0chvfjrlmg99db98ra9vzwjmbypqx7d4ssm8q0kvzi0n0p9irszi"))))
    (build-system gnu-build-system)
    (inputs `(("ncurses" ,ncurses)
              ("guile" ,guile-2.0)))
    (arguments
     '(#:configure-flags (list (string-append "--with-guilesitedir="
                                              (assoc-ref %outputs "out")
                                              "/share/guile/site"))
       #:phases (alist-cons-after
                 'install 'post-install
                 (lambda* (#:key outputs #:allow-other-keys)
                   (let* ((out   (assoc-ref outputs "out"))
                          (dir   (string-append out "/share/guile/site/"))
                          (files (find-files dir ".scm")))
                    (substitute* files
                      (("\"libguile-ncurses\"")
                       (format #f "\"~a/lib/libguile-ncurses\""
                               out)))))
                 %standard-phases)))
    (home-page "http://www.gnu.org/software/guile-ncurses/")
    (synopsis
     "GNU Guile-Ncurses, Scheme interface to the NCurses libraries")
    (description
     "GNU Guile-Ncurses is a library for the Guile Scheme interpreter that
provides functions for creating text user interfaces.  The text user interface
functionality is built on the ncurses libraries: curses, form, panel, and
menu.")
    (license lgpl3+)))

(define-public mcron
  (package
    (name "mcron")
    (version "1.0.6")
    (source (origin
             (method url-fetch)
             (uri (string-append "mirror://gnu/mcron/mcron-"
                                 version ".tar.gz"))
             (sha256
              (base32
               "0yvrfzzdy2m7fbqkr61fw01wd9r2jpnbyabxhcsfivgxywknl0fy"))))
    (build-system gnu-build-system)
    (arguments
     '(#:patches (list (assoc-ref %build-inputs "patch/install"))))
    (inputs
     `(("ed" ,ed) ("which" ,which) ("guile" ,guile-1.8)
       ("patch/install" ,(search-patch "mcron-install.patch"))))
    (home-page "http://www.gnu.org/software/mcron/")
    (synopsis
     "GNU mcron, a flexible implementation of `cron' in Guile")
    (description
     "The GNU package mcron (Mellor's cron) is a 100% compatible replacement
for Vixie cron.  It is written in pure Guile, and allows configuration files
to be written in scheme (as well as Vixie's original format) for infinite
flexibility in specifying when jobs should be run.  Mcron was written by Dale
Mellor.")
    (license gpl3+)))

;;; guile.scm ends here
Commit	Line	Data
233e7676	1	;;; GNU Guix --- Functional package management for GNU
ef02e1e9	2	;;; Copyright © 2012, 2013 Ludovic Courtès <ludo@gnu.org>
1722d680	3	;;;
233e7676	4	;;; This file is part of GNU Guix.
1722d680	5	;;;
233e7676	6	;;; GNU Guix is free software; you can redistribute it and/or modify it
1722d680 LC	7	;;; under the terms of the GNU General Public License as published by
	8	;;; the Free Software Foundation; either version 3 of the License, or (at
	9	;;; your option) any later version.
	10	;;;
233e7676	11	;;; GNU Guix is distributed in the hope that it will be useful, but
1722d680 LC	12	;;; WITHOUT ANY WARRANTY; without even the implied warranty of
	13	;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	;;; GNU General Public License for more details.
	15	;;;
	16	;;; You should have received a copy of the GNU General Public License
233e7676	17	;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
1722d680	18
1ffa7090	19	(define-module (gnu packages guile)
4a44e743	20	#:use-module (guix licenses)
59a43334	21	#:use-module (gnu packages)
1ffa7090 LC	22	#:use-module (gnu packages bdw-gc)
	23	#:use-module (gnu packages gawk)
	24	#:use-module (gnu packages gperf)
	25	#:use-module (gnu packages libffi)
	26	#:use-module (gnu packages autotools)
	27	#:use-module (gnu packages libunistring)
	28	#:use-module (gnu packages m4)
	29	#:use-module (gnu packages multiprecision)
	30	#:use-module (gnu packages pkg-config)
	31	#:use-module (gnu packages readline)
ef02e1e9	32	#:use-module (gnu packages ncurses)
87d836b2 LC	33	#:use-module (gnu packages ed)
87d836b2 LC	34	#:use-module (gnu packages which)
1722d680	35	#:use-module (guix packages)
87f5d366	36	#:use-module (guix download)
1722d680 LC	37	#:use-module (guix build-system gnu))
	38
	39	;;; Commentary:
	40	;;;
c44899a2	41	;;; GNU Guile, and modules and extensions.
1722d680 LC	42	;;;
	43	;;; Code:
	44
c44899a2 LC	45	(define-public guile-1.8
	46	(package
	47	(name "guile")
	48	(version "1.8.8")
	49	(source (origin
87f5d366	50	(method url-fetch)
0db342a5	51	(uri (string-append "mirror://gnu/guile/guile-" version
c44899a2 LC	52	".tar.gz"))
	53	(sha256
	54	(base32
	55	"0l200a0v7h8bh0cwz6v7hc13ds39cgqsmfrks55b1rbj5vniyiy3"))))
	56	(build-system gnu-build-system)
	57	(arguments '(#:configure-flags '("--disable-error-on-warning")
	58	#:patches (list (assoc-ref %build-inputs "patch/snarf"))
	59
	60	;; Insert a phase before `configure' to patch things up.
	61	#:phases (alist-cons-before
	62	'configure
2f4fbe1c	63	'patch-stuff
c44899a2 LC	64	(lambda* (#:key outputs #:allow-other-keys)
	65	;; Add a call to `lt_dladdsearchdir' so that
	66	;; `libguile-readline.so' & co. are in the
	67	;; loader's search path.
	68	(substitute* "libguile/dynl.c"
2f4fbe1c LC	69	(("lt_dlinit.*$" match)
	70	(format #f
	71	" ~a~% lt_dladdsearchdir(\"~a/lib\");~%"
	72	match
	73	(assoc-ref outputs "out"))))
	74
	75	;; The usual /bin/sh...
	76	(substitute* "ice-9/popen.scm"
	77	(("/bin/sh") (which "sh"))))
c44899a2 LC	78	%standard-phases)))
	79	(inputs `(("patch/snarf" ,(search-patch "guile-1.8-cpp-4.5.patch"))
	80	("gawk" ,gawk)
	81	("readline" ,readline)))
	82
	83	;; Since `guile-1.8.pc' has "Libs: ... -lgmp -lltdl", these must be
	84	;; propagated.
	85	(propagated-inputs `(("gmp" ,gmp)
	86	("libtool" ,libtool)))
	87
	88	;; When cross-compiling, a native version of Guile itself is needed.
	89	(self-native-input? #t)
	90
	91	(synopsis "GNU Guile 1.8, an embeddable Scheme interpreter")
	92	(description
	93	"GNU Guile 1.8 is an interpreter for the Scheme programming language,
	94	packaged as a library that can be embedded into programs to make them
	95	extensible. It supports many SRFIs.")
	96	(home-page "http://www.gnu.org/software/guile/")
4a44e743	97	(license lgpl2.0+)))
c44899a2 LC	98
	99	(define-public guile-2.0
	100	(package
	101	(name "guile")
3af4e053	102	(version "2.0.7")
c44899a2	103	(source (origin
87f5d366	104	(method url-fetch)
0db342a5	105	(uri (string-append "mirror://gnu/guile/guile-" version
c44899a2 LC	106	".tar.xz"))
	107	(sha256
	108	(base32
3af4e053	109	"0f53pxkia4v17n0avwqlcjpy0n89hkazm2xsa6p84lv8k6k8y9vg"))))
c44899a2 LC	110	(build-system gnu-build-system)
	111	(native-inputs `(("pkgconfig" ,pkg-config)))
	112	(inputs `(("libffi" ,libffi)
	113	("readline" ,readline)))
	114
	115	(propagated-inputs
	116	`( ;; These ones aren't normally needed here, but since `libguile-2.0.la'
	117	;; reads `-lltdl -lunistring', adding them here will add the needed
	118	;; `-L' flags. As for why the `.la' file lacks the `-L' flags, see
	119	;; <http://thread.gmane.org/gmane.comp.lib.gnulib.bugs/18903>.
	120	("libunistring" ,libunistring)
	121	("libtool" ,libtool)
	122
	123	;; The headers and/or `guile-2.0.pc' refer to these packages, so they
	124	;; must be propagated.
	125	("bdw-gc" ,libgc)
	126	("gmp" ,gmp)))
	127
	128	(self-native-input? #t)
	129
8ffaa93b LC	130	(arguments
	131	'(#:phases (alist-cons-before
	132	'configure 'pre-configure
	133	(lambda* (#:key inputs #:allow-other-keys)
	134	(let ((bash (assoc-ref inputs "bash")))
	135	(substitute* "module/ice-9/popen.scm"
	136	(("/bin/sh")
	137	(string-append bash "/bin/bash")))))
	138	%standard-phases)))
	139
c44899a2 LC	140	(synopsis "GNU Guile 2.0, an embeddable Scheme implementation")
	141	(description
	142	"GNU Guile is an implementation of the Scheme programming language, with
	143	support for many SRFIs, packaged for use in a wide variety of environments.
	144	In addition to implementing the R5RS Scheme standard and a large subset of
	145	R6RS, Guile includes a module system, full access to POSIX system calls,
	146	networking support, multiple threads, dynamic linking, a foreign function
	147	call interface, and powerful string processing.")
	148	(home-page "http://www.gnu.org/software/guile/")
4a44e743	149	(license lgpl3+)))
c44899a2	150
fa29b199 LC	151	(define-public guile-2.0/fixed
	152	;; A package of Guile 2.0 that's rarely changed. It is the one used
	153	;; in the `base' module, and thus changing it entails a full rebuild.
325285d5	154	guile-2.0)
fa29b199	155
c44899a2 LC	156	\f
	157	;;;
	158	;;; Extensions.
	159	;;;
	160
1722d680 LC	161	(define (guile-reader guile)
	162	"Build Guile-Reader against GUILE, a package of some version of Guile 1.8
	163	or 2.0."
	164	(package
fd80c705	165	(name (string-append "guile-reader-for-guile_" (package-version guile)))
1722d680 LC	166	(version "0.6")
1722d680 LC	167	(source (origin
87f5d366	168	(method url-fetch)
1722d680 LC	169	(uri (string-append
	170	"http://download-mirror.savannah.gnu.org/releases/guile-reader/guile-reader-"
	171	version ".tar.gz"))
	172	(sha256
	173	(base32
	174	"1svlyk5pm4fsdp2g7n6qffdl6fdggxnlicj0jn9s4lxd63gzxy1n"))))
	175	(build-system gnu-build-system)
cb0d69ed	176	(native-inputs `(("pkgconfig" ,pkg-config)
1627f7f7	177	("gperf" ,gperf)))
1722d680	178	(inputs `(("guile" ,guile)))
d45122f5	179	(synopsis "Guile-Reader, a simple framework for building readers for
1722d680	180	GNU Guile")
d45122f5	181	(description
1722d680 LC	182	"Guile-Reader is a simple framework for building readers for GNU Guile.
	183
	184	The idea is to make it easy to build procedures that extend Guile’s read
	185	procedure. Readers supporting various syntax variants can easily be written,
	186	possibly by re-using existing “token readers” of a standard Scheme
	187	readers. For example, it is used to implement Skribilo’s R5RS-derived
	188	document syntax.
	189
	190	Guile-Reader’s approach is similar to Common Lisp’s “read table”, but
	191	hopefully more powerful and flexible (for instance, one may instantiate as
	192	many readers as needed).")
	193	(home-page "http://www.nongnu.org/guile-reader/")
4a44e743	194	(license gpl3+)))
1722d680 LC	195
	196	(define-public guile-reader/guile-1.8
	197	;; Guile-Reader built against Guile 1.8.
	198	(guile-reader guile-1.8))
	199
	200	(define-public guile-reader/guile-2.0
	201	;; Guile-Reader built against Guile 2.0.
	202	(guile-reader guile-2.0))
	203
ef02e1e9 LC	204	(define-public guile-ncurses
	205	(package
	206	(name "guile-ncurses")
	207	(version "1.3")
	208	(source (origin
	209	(method url-fetch)
	210	(uri (string-append "mirror://gnu/guile-ncurses/guile-ncurses-"
	211	version ".tar.gz"))
	212	(sha256
	213	(base32
	214	"0chvfjrlmg99db98ra9vzwjmbypqx7d4ssm8q0kvzi0n0p9irszi"))))
	215	(build-system gnu-build-system)
	216	(inputs `(("ncurses" ,ncurses)
	217	("guile" ,guile-2.0)))
	218	(arguments
	219	'(#:configure-flags (list (string-append "--with-guilesitedir="
	220	(assoc-ref %outputs "out")
	221	"/share/guile/site"))
	222	#:phases (alist-cons-after
	223	'install 'post-install
	224	(lambda* (#:key outputs #:allow-other-keys)
	225	(let* ((out (assoc-ref outputs "out"))
	226	(dir (string-append out "/share/guile/site/"))
	227	(files (find-files dir ".scm")))
	228	(substitute* files
	229	(("\"libguile-ncurses\"")
	230	(format #f "\"~a/lib/libguile-ncurses\""
	231	out)))))
	232	%standard-phases)))
	233	(home-page "http://www.gnu.org/software/guile-ncurses/")
	234	(synopsis
	235	"GNU Guile-Ncurses, Scheme interface to the NCurses libraries")
	236	(description
	237	"GNU Guile-Ncurses is a library for the Guile Scheme interpreter that
	238	provides functions for creating text user interfaces. The text user interface
	239	functionality is built on the ncurses libraries: curses, form, panel, and
	240	menu.")
	241	(license lgpl3+)))
	242
87d836b2 LC	243	(define-public mcron
	244	(package
	245	(name "mcron")
	246	(version "1.0.6")
	247	(source (origin
	248	(method url-fetch)
	249	(uri (string-append "mirror://gnu/mcron/mcron-"
	250	version ".tar.gz"))
	251	(sha256
	252	(base32
	253	"0yvrfzzdy2m7fbqkr61fw01wd9r2jpnbyabxhcsfivgxywknl0fy"))))
	254	(build-system gnu-build-system)
	255	(arguments
	256	'(#:patches (list (assoc-ref %build-inputs "patch/install"))))
	257	(inputs
	258	`(("ed" ,ed) ("which" ,which) ("guile" ,guile-1.8)
	259	("patch/install" ,(search-patch "mcron-install.patch"))))
	260	(home-page "http://www.gnu.org/software/mcron/")
	261	(synopsis
	262	"GNU mcron, a flexible implementation of `cron' in Guile")
	263	(description
	264	"The GNU package mcron (Mellor's cron) is a 100% compatible replacement
	265	for Vixie cron. It is written in pure Guile, and allows configuration files
	266	to be written in scheme (as well as Vixie's original format) for infinite
	267	flexibility in specifying when jobs should be run. Mcron was written by Dale
	268	Mellor.")
	269	(license gpl3+)))
	270
1722d680	271	;;; guile.scm ends here