distro: Rename (distro ...) to (distro packages ...).

* distro/base.scm, distro/ld-wrapper.scm: Move to `distro/packages'.
  Adjust LD-WRAPPER-BOOT3 input file name accordingly.
* Makefile.am (MODULES): Adjust accordingly.
* distro.scm (%distro-module-directory): Change to "/distro/packages".
* guix/build-system/gnu.scm (standard-inputs): Change module name
  to (distro packages base).
* tests/packages.scm (test-packages): Likewise.

1 files changed, 0 insertions, 1925 deletions

diff --git a/distro/base.scm b/distro/base.scm
deleted file mode 100644
index bf49d02f20..0000000000
--- a/distro/base.scm
+++ /dev/null
@@ -1,1925 +0,0 @@
-;;; Guix --- Nix package management from Guile.         -*- coding: utf-8 -*-
-;;; Copyright (C) 2012 Ludovic Courtès <ludo@gnu.org>
-;;;
-;;; This file is part of Guix.
-;;;
-;;; 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.
-;;;
-;;; 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 Guix.  If not, see <http://www.gnu.org/licenses/>.
-
-(define-module (distro base)
-  #:use-module (distro)
-  #:use-module (guix packages)
-  #:use-module (guix ftp)
-  #:use-module (guix http)
-  #:use-module (guix build-system gnu)
-  #:use-module (guix build-system trivial)
-  #:use-module (guix utils)
-  #:use-module (srfi srfi-1)
-  #:use-module (srfi srfi-26)
-  #:use-module (ice-9 match))
-
-;;; Commentary:
-;;;
-;;; A Guix-based distribution.
-;;;
-;;; Code:
-
-(define-public libsigsegv
-  (package
-   (name "libsigsegv")
-   (version "2.10")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append
-                  "http://ftp.gnu.org/gnu/libsigsegv/libsigsegv-"
-                  version ".tar.gz"))
-            (sha256
-             (base32 "16hrs8k3nmc7a8jam5j1fpspd6sdpkamskvsdpcw6m29vnis8q44"))))
-   (build-system gnu-build-system)
-   (outputs '("out" "lib"))                   ; separate libdir from the rest
-   (home-page "http://www.gnu.org/software/libsigsegv/")
-   (description "GNU libsigsegv, a library to handle page faults in user mode")
-   (long-description
-"GNU libsigsegv is a library for handling page faults in user mode. A page
-fault occurs when a program tries to access to a region of memory that is
-currently not available. Catching and handling a page fault is a useful
-technique for implementing pageable virtual memory, memory-mapped access to
-persistent databases, generational garbage collectors, stack overflow
-handlers, distributed shared memory, and more.")
-   (license "GPLv2+")))
-
-(define-public gawk
-  (package
-   (name "gawk")
-   (version "4.0.0")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/gawk/gawk-" version
-                                ".tar.bz2"))
-            (sha256
-             (base32 "0sss7rhpvizi2a88h6giv0i7w5h07s2fxkw3s6n1hqvcnhrfgbb0"))))
-   (build-system gnu-build-system)
-   (arguments (case-lambda
-                ((system)
-                 (if (string=? system "i686-cygwin")
-                     '(#:tests? #f)      ; work around test failure on Cygwin
-                     '(#:parallel-tests? #f))) ; test suite fails in parallel
-                ((system cross-system)
-                 '(#:parallel-tests? #f))))
-   (inputs `(("libsigsegv" ,libsigsegv)             ; headers
-             ("libsigsegv/lib" ,libsigsegv "lib"))) ; library
-   (home-page "http://www.gnu.org/software/gawk/")
-   (description "GNU implementation of the Awk programming language")
-   (long-description
-    "Many computer users need to manipulate text files: extract and then
-operate on data from parts of certain lines while discarding the rest, make
-changes in various text files wherever certain patterns appear, and so on.
-To write a program to do these things in a language such as C or Pascal is a
-time-consuming inconvenience that may take many lines of code.  The job is
-easy with awk, especially the GNU implementation: Gawk.
-
-The awk utility interprets a special-purpose programming language that makes
-it possible to handle many data-reformatting jobs with just a few lines of
-code.")
-   (license "GPLv3+")))
-
-(define-public hello
-  (package
-   (name "hello")
-   (version "2.8")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/hello/hello-" version
-                                ".tar.gz"))
-            (sha256
-             (base32 "0wqd8sjmxfskrflaxywc7gqw7sfawrfvdxd9skxawzfgyy0pzdz6"))))
-   (build-system gnu-build-system)
-   (arguments '(#:configure-flags
-                `("--disable-dependency-tracking"
-                  ,(string-append "--with-gawk="  ; for illustration purposes
-                                 (assoc-ref %build-inputs "gawk")))))
-   (inputs `(("gawk" ,gawk)))
-   (description "GNU Hello")
-   (long-description "Yeah...")
-   (home-page "http://www.gnu.org/software/hello/")
-   (license "GPLv3+")))
-
-(define-public grep
-  (package
-   (name "grep")
-   (version "2.14")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/grep/grep-"
-                                version ".tar.xz"))
-            (sha256
-             (base32
-              "1qbjb1l7f9blckc5pqy8jlf6482hpx4awn2acmhyf5mv9wfq03p7"))))
-   (build-system gnu-build-system)
-   (description "GNU implementation of the Unix grep command")
-   (long-description
-    "The grep command searches one or more input files for lines containing a
-match to a specified pattern.  By default, grep prints the matching
-lines.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/grep/")))
-
-(define-public sed
-  (package
-   (name "sed")
-   (version "4.2.1")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/sed/sed-" version
-                                ".tar.bz2"))
-            (sha256
-             (base32
-              "13wlsb4sf5d5a82xjhxqmdvrrn36rmw5f0pl9qyb9zkvldnb7hra"))))
-   (build-system gnu-build-system)
-   (description "GNU sed, a batch stream editor")
-   (long-description
-    "Sed (stream editor) isn't really a true text editor or text processor.
-Instead, it is used to filter text, i.e., it takes text input and performs
-some operation (or set of operations) on it and outputs the modified text.
-Sed is typically used for extracting part of a file using pattern matching or
-substituting multiple occurrences of a string within a file.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/sed/")))
-
-(define-public tar
-  (package
-   (name "tar")
-   (version "1.26")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/tar/tar-"
-                                version ".tar.bz2"))
-            (sha256
-             (base32
-              "0hbdkzmchq9ycr2x1pxqdcgdbaxksh8c6ac0jf75jajhcks6jlss"))))
-   (build-system gnu-build-system)
-   (inputs `(("patch/gets" ,(search-patch "tar-gets-undeclared.patch"))))
-   (arguments
-    `(#:patches (list (assoc-ref %build-inputs "patch/gets"))))
-   (description "GNU implementation of the `tar' archiver")
-   (long-description
-    "The Tar program provides the ability to create tar archives, as well as
-various other kinds of manipulation.  For example, you can use Tar on
-previously created archives to extract files, to store additional files, or
-to update or list files which were already stored.
-
-Initially, tar archives were used to store files conveniently on magnetic
-tape.  The name \"Tar\" comes from this use; it stands for tape archiver.
-Despite the utility's name, Tar can direct its output to available devices,
-files, or other programs (using pipes), it can even access remote devices or
-files (as archives).")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/tar/")))
-
-(define-public perl
-  ;; Yeah, Perl...  It is required early in the bootstrap process by Linux.
-  (package
-    (name "perl")
-    (version "5.16.1")
-    (source (origin
-             (method http-fetch)
-             (uri (string-append "http://www.cpan.org/src/5.0/perl-"
-                                 version ".tar.gz"))
-             (sha256
-              (base32
-               "15qxzba3a50c9nik5ydgyfp62x7h9vxxn12yd1jgl93hb1wj96km"))))
-    (build-system gnu-build-system)
-    (arguments
-     (lambda (system)
-       `(#:tests? #f
-         #:patches (list (assoc-ref %build-inputs "patch/no-sys-dirs"))
-         #:phases
-         (alist-replace
-          'configure
-          (lambda* (#:key inputs outputs #:allow-other-keys)
-            (let ((out  (assoc-ref outputs "out"))
-                  (libc (assoc-ref inputs "libc"))
-                  (pwd  (search-path (search-path-as-string->list
-                                      (getenv "PATH"))
-                                     "pwd")))
-              ;; Use the right path for `pwd'.
-              (substitute* "dist/Cwd/Cwd.pm"
-                (("/bin/pwd") pwd))
-
-              (zero?
-               (system* "/bin/sh" "./Configure"
-                        (string-append "-Dprefix=" out)
-                        (string-append "-Dman1dir=" out "/share/man/man1")
-                        (string-append "-Dman3dir=" out "/share/man/man3")
-                        "-de" "-Dcc=gcc"
-                        "-Uinstallusrbinperl"
-                        "-Dinstallstyle=lib/perl5"
-                        "-Duseshrplib"
-                        (string-append "-Dlocincpth=" libc "/include")
-                        (string-append "-Dloclibpth=" libc "/lib")))))
-          %standard-phases))))
-    (inputs `(("patch/no-sys-dirs" ,(search-patch "perl-no-sys-dirs.patch"))))
-    (description "Implementation of the Perl programming language")
-    (long-description
-     "Perl 5 is a highly capable, feature-rich programming language with over
-24 years of development.")
-    (home-page "http://www.perl.org/")
-    (license "GPLv1+")))                          ; or "Artistic"
-
-(define-public gzip
-  (package
-   (name "gzip")
-   (version "1.5")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/gzip/gzip-"
-                                version ".tar.gz"))
-            (sha256
-             (base32
-              "18rm80kar7n016g8bsyy1a3zk50i2826xdgs874yh64rzj7nxmdm"))))
-   (build-system gnu-build-system)
-   (description "Gzip, the GNU zip compression program")
-   (arguments
-    ;; FIXME: The test suite wants `less', and optionally Perl.
-    '(#:tests? #f))
-   (long-description
-    "gzip (GNU zip) is a popular data compression program written by Jean-loup
-Gailly for the GNU project.  Mark Adler wrote the decompression part.
-
-We developed this program as a replacement for compress because of the Unisys
-and IBM patents covering the LZW algorithm used by compress.  These patents
-made it impossible for us to use compress, and we needed a replacement.  The
-superior compression ratio of gzip is just a bonus.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/gzip/")))
-
-(define-public bzip2
-  (let ((fix-man-dir
-         ;; Move man pages to $out/share/.
-         '(lambda* (#:key outputs #:allow-other-keys)
-            (with-directory-excursion (assoc-ref outputs "out")
-              (mkdir "share")
-              (rename-file "man" "share"))))
-        (build-shared-lib
-         ;; Build a shared library.
-         '(lambda* (#:key inputs #:allow-other-keys)
-            (zero? (system* "make" "-f" "Makefile-libbz2_so"))))
-        (install-shared-lib
-         '(lambda* (#:key outputs #:allow-other-keys)
-            (let* ((out    (assoc-ref outputs "out"))
-                   (libdir (string-append out "/lib")))
-              ;; XXX: mv libbz2.so* $libdir
-              (file-system-fold (const #t)
-                                (lambda (path stat result) ; leaf
-                                  (define base (basename path))
-                                  (when (string-prefix? "libbz2.so" base)
-                                    (format #t "installing `~a' to `~a'~%"
-                                            base libdir)
-                                    (copy-file path
-                                               (string-append libdir "/"
-                                                              base))))
-                                (const #t)        ; down
-                                (const #t)        ; up
-                                (const #t)        ; skip
-                                (lambda (path stat errno result)
-                                  (error "i/o error" path (strerror errno)))
-                                #t
-                                ".")))))
-    (package
-      (name "bzip2")
-      (version "1.0.6")
-      (source (origin
-               (method http-fetch)
-               (uri (string-append "http://www.bzip.org/" version "/bzip2-"
-                                   version ".tar.gz"))
-               (sha256
-                (base32
-                 "1kfrc7f0ja9fdn6j1y6yir6li818npy6217hvr3wzmnmzhs8z152"))))
-      (build-system gnu-build-system)
-      (arguments
-       `(#:modules ((guix build gnu-build-system)
-                    (guix build utils)
-                    (srfi srfi-1)
-                    (ice-9 ftw))
-                   #:phases
-                   (alist-cons-before
-                    'build 'build-shared-lib ,build-shared-lib
-                    (alist-cons-after
-                     'install 'fix-man-dir ,fix-man-dir
-                     (alist-cons-after
-                      'install 'install-shared-lib ,install-shared-lib
-                      (alist-delete 'configure %standard-phases))))
-                   #:make-flags (list (string-append "PREFIX="
-                                                     (assoc-ref %outputs "out")))))
-      (description "high-quality data compression program")
-      (long-description
-       "bzip2 is a freely available, patent free (see below), high-quality data
-compressor.  It typically compresses files to within 10% to 15% of the best
-available techniques (the PPM family of statistical compressors), whilst
-being around twice as fast at compression and six times faster at
-decompression.")
-      (license "BSD-style")
-      (home-page "http://www.bzip.org/"))))
-
-(define-public xz
-  (package
-   (name "xz")
-   (version "5.0.4")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://tukaani.org/xz/xz-" version
-                                ".tar.gz"))
-            (sha256
-             (base32
-              "1dl35ca8fdss9z2d6y234gxh24ixq904xksizrjmjr5dimwhax6n"))))
-   (build-system gnu-build-system)
-   (description
-    "XZ, general-purpose data compression software, successor of LZMA")
-   (long-description
-    "XZ Utils is free general-purpose data compression software with high
-compression ratio.  XZ Utils were written for POSIX-like systems, but also
-work on some not-so-POSIX systems.  XZ Utils are the successor to LZMA Utils.
-
-The core of the XZ Utils compression code is based on LZMA SDK, but it has
-been modified quite a lot to be suitable for XZ Utils.  The primary
-compression algorithm is currently LZMA2, which is used inside the .xz
-container format.  With typical files, XZ Utils create 30 % smaller output
-than gzip and 15 % smaller output than bzip2.")
-   (license '("GPLv2+" "LGPLv2.1+"))              ; bits of both
-   (home-page "http://tukaani.org/xz/")))
-
-(define-public patch
-  (package
-   (name "patch")
-   (version "2.6.1")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/patch/patch-"
-                                version ".tar.xz"))
-            (sha256
-             (base32
-              "18012gxs9wc96izskp1q7bclrwns6rdmkn4jj31c8jbyfz6l5npq"))))
-   (build-system gnu-build-system)
-   (native-inputs '())                      ; FIXME: needs `ed' for the tests
-   (arguments
-    (case-lambda
-      ((system) '(#:tests? #f))
-      ((system cross-system)
-       '(#:configure-flags '("ac_cv_func_strnlen_working=yes")))))
-   (description "GNU Patch, a program to apply differences to files")
-   (long-description
-    "GNU Patch takes a patch file containing a difference listing produced by
-the diff program and applies those differences to one or more original files,
-producing patched versions.")
-   (license "GPLv3+")
-   (home-page "http://savannah.gnu.org/projects/patch/")))
-
-(define-public diffutils
-  (package
-   (name "diffutils")
-   (version "3.2")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/diffutils/diffutils-"
-                                version ".tar.xz"))
-            (sha256
-             (base32
-              "0jci0wv68025xd0s0rq4s5qxpx56dd9d730lka63qpzk1rfvfkxb"))))
-   (build-system gnu-build-system)
-   (inputs `(("patch/gets"
-              ,(search-patch "diffutils-gets-undeclared.patch"))))
-   (arguments `(#:patches (list (assoc-ref %build-inputs "patch/gets"))))
-   (description "Programs to find differences among text files")
-   (long-description
-    "GNU Diffutils is a package of several programs related to finding
-differences between files.
-
-Computer users often find occasion to ask how two files differ. Perhaps one
-file is a newer version of the other file. Or maybe the two files started out
-as identical copies but were changed by different people.
-
-You can use the diff command to show differences between two files, or each
-corresponding file in two directories. diff outputs differences between files
-line by line in any of several formats, selectable by command line
-options. This set of differences is often called a ‘diff’ or ‘patch’. For
-files that are identical, diff normally produces no output; for
-binary (non-text) files, diff normally reports only that they are different.
-
-You can use the cmp command to show the offsets and line numbers where two
-files differ. cmp can also show all the characters that differ between the
-two files, side by side.
-
-You can use the diff3 command to show differences among three files. When two
-people have made independent changes to a common original, diff3 can report
-the differences between the original and the two changed versions, and can
-produce a merged file that contains both persons' changes together with
-warnings about conflicts.
-
-You can use the sdiff command to merge two files interactively.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/diffutils/")))
-
-(define-public findutils
-  (package
-   (name "findutils")
-   (version "4.4.2")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/findutils/findutils-"
-                                version ".tar.gz"))
-            (sha256
-             (base32
-              "0amn0bbwqvsvvsh6drfwz20ydc2czk374lzw5kksbh6bf78k4ks3"))))
-   (build-system gnu-build-system)
-   (native-inputs
-    `(("patch/absolute-paths"
-       ,(search-patch "findutils-absolute-paths.patch"))))
-   (arguments
-    (case-lambda
-      ((system)
-       `(#:patches (list (assoc-ref %build-inputs "patch/absolute-paths"))))
-      ((system cross-system)
-       ;; Work around cross-compilation failure.
-       ;; See <http://savannah.gnu.org/bugs/?27299#comment1>.
-       `(#:configure-flags '("gl_cv_func_wcwidth_works=yes")
-         ,@(arguments cross-system)))))
-   (description "Basic directory searching utilities of the GNU operating
-system")
-   (long-description
-    "The GNU Find Utilities are the basic directory searching utilities of
-the GNU operating system.  These programs are typically used in conjunction
-with other programs to provide modular and powerful directory search and file
-locating capabilities to other commands.
-
-The tools supplied with this package are:
-
-  * find - search for files in a directory hierarchy;
-  * locate - list files in databases that match a pattern;
-  * updatedb - update a file name database;
-  * xargs - build and execute command lines from standard input.
-")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/findutils/")))
-
-(define-public coreutils
-  (package
-   (name "coreutils")
-   (version "8.19")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/coreutils/coreutils-"
-                                version ".tar.xz"))
-            (sha256
-             (base32
-              "1rx9x3fp848w4nny7irdkcpkan9fcx24d99v5dkwgkyq7wc76f5d"))))
-   (build-system gnu-build-system)
-   (inputs `())                      ; TODO: optional deps: SELinux, ACL, GMP
-   (arguments
-    '(;; Perl is missing, and some tests are failing.
-      #:tests? #f))
-   (description
-    "The basic file, shell and text manipulation utilities of the GNU
-operating system")
-   (long-description
-    "The GNU Core Utilities are the basic file, shell and text manipulation
-utilities of the GNU operating system.  These are the core utilities which
-are expected to exist on every operating system.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/coreutils/")))
-
-(define-public m4
-  (package
-   (name "m4")
-   (version "1.4.16")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/m4/m4-"
-                                version ".tar.bz2"))
-            (sha256
-             (base32
-              "035r7ma272j2cwni2961jp22k6bn3n9xwn3b3qbcn2yrvlghql22"))))
-   (build-system gnu-build-system)
-   (arguments (case-lambda
-                ((system)
-                 ;; XXX: Disable tests on those platforms with know issues.
-                 `(#:tests? ,(not (member system
-                                          '("x86_64-darwin"
-                                            "i686-cygwin"
-                                            "i686-sunos")))
-                   #:patches (list (assoc-ref %build-inputs "patch/s_isdir")
-                                   (assoc-ref %build-inputs
-                                              "patch/readlink-EINVAL")
-                                   (assoc-ref %build-inputs "patch/gets"))))
-                ((system cross-system)
-                 `(#:patches (list (assoc-ref %build-inputs "patch/s_isdir")
-                                   (assoc-ref %build-inputs
-                                              "patch/readlink-EINVAL")
-                                   (assoc-ref %build-inputs "patch/gets"))))))
-   (inputs `(("patch/s_isdir" ,(search-patch "m4-s_isdir.patch"))
-             ("patch/readlink-EINVAL"
-              ,(search-patch "m4-readlink-EINVAL.patch"))
-             ("patch/gets" ,(search-patch "m4-gets-undeclared.patch"))))
-   (description "GNU M4, a macro processor")
-   (long-description
-    "GNU M4 is an implementation of the traditional Unix macro processor.  It
-is mostly SVR4 compatible although it has some extensions (for example,
-handling more than 9 positional parameters to macros).  GNU M4 also has
-built-in functions for including files, running shell commands, doing
-arithmetic, etc.
-
-GNU M4 is a macro processor in the sense that it copies its input to the
-output expanding macros as it goes.  Macros are either builtin or
-user-defined and can take any number of arguments.  Besides just doing macro
-expansion, m4 has builtin functions for including named files, running UNIX
-commands, doing integer arithmetic, manipulating text in various ways,
-recursion etc...  m4 can be used either as a front-end to a compiler or as a
-macro processor in its own right.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/m4/")))
-
-(define-public gnu-make
-  (package
-   (name "make")
-   (version "3.82")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/make/make-" version
-                                ".tar.bz2"))
-            (sha256
-             (base32
-              "0ri98385hsd7li6rh4l5afcq92v8l2lgiaz85wgcfh4w2wzsghg2"))))
-   (build-system gnu-build-system)
-   (native-inputs
-    `(("patch/impure-dirs" ,(search-patch "make-impure-dirs.patch"))))
-   (arguments `(#:patches (list (assoc-ref %build-inputs
-                                           "patch/impure-dirs"))))
-   (description "GNU Make, a program controlling the generation of non-source
-files from sources")
-   (long-description
-    "Make is a tool which controls the generation of executables and other
-non-source files of a program from the program's source files.
-
-Make gets its knowledge of how to build your program from a file called the
-makefile, which lists each of the non-source files and how to compute it from
-other files. When you write a program, you should write a makefile for it, so
-that it is possible to use Make to build and install the program.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/make/")))
-
-(define-public gmp
-  (package
-   (name "gmp")
-   (version "5.0.5")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/gmp/gmp-" version
-                                ".tar.bz2"))
-            (sha256
-             (base32
-              "1jfymbr90mpn0zw5sg001llqnvf2462y77vgjknrmfs1rjn8ln0z"))))
-   (build-system gnu-build-system)
-   (native-inputs `(("m4" ,m4)))
-   (arguments `(#:configure-flags
-                '(;; Build a "fat binary", with routines for several
-                  ;; sub-architectures.
-                  "--enable-fat"
-                  "--enable-cxx")))
-   (description "GMP, the GNU multiple precision arithmetic library")
-   (long-description
-    "GMP is a free library for arbitrary precision arithmetic, operating on
-signed integers, rational numbers, and floating point numbers.  There is no
-practical limit to the precision except the ones implied by the available
-memory in the machine GMP runs on.  GMP has a rich set of functions, and the
-functions have a regular interface.
-
-The main target applications for GMP are cryptography applications and
-research, Internet security applications, algebra systems, computational
-algebra research, etc.
-
-GMP is carefully designed to be as fast as possible, both for small operands
-and for huge operands.  The speed is achieved by using fullwords as the basic
-arithmetic type, by using fast algorithms, with highly optimised assembly
-code for the most common inner loops for a lot of CPUs, and by a general
-emphasis on speed.
-
-GMP is faster than any other bignum library.  The advantage for GMP increases
-with the operand sizes for many operations, since GMP uses asymptotically
-faster algorithms.")
-   (license "LGPLv3+")
-   (home-page "http://gmplib.org/")))
-
-(define-public mpfr
-  (package
-   (name "mpfr")
-   (version "3.1.1")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/mpfr/mpfr-" version
-                                ".tar.xz"))
-            (sha256 (base32
-                     "0ym1ylcq803n52qrggxqmkz66gbn8ncc3ybawal31v5y5p1srma9"))))
-   (build-system gnu-build-system)
-   (inputs `(("gmp" ,gmp)))
-   (description "GNU MPFR, a library for multiple-precision floating-point
-arithmetic")
-   (long-description
-    "The GNU MPFR library is a C library for multiple-precision
-floating-point computations with correct rounding.  MPFR is based on the GMP
-multiple-precision library.
-
-The main goal of MPFR is to provide a library for multiple-precision
-floating-point computation which is both efficient and has a well-defined
-semantics.  It copies the good ideas from the ANSI/IEEE-754 standard for
-double-precision floating-point arithmetic (53-bit mantissa).")
-   (license "LGPLv3+")
-   (home-page "http://www.mpfr.org/")))
-
-(define-public mpc
-  (package
-   (name "mpc")
-   (version "1.0")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append
-                  "http://www.multiprecision.org/mpc/download/mpc-"
-                  version ".tar.gz"))
-            (sha256 (base32
-                     "00rxjmkpqnv6zzcyw9aa5w6rzaav32ys87km25zgfcv9i32km5cw"))))
-   (build-system gnu-build-system)
-   (inputs `(("gmp" ,gmp)
-             ("mpfr" ,mpfr)))
-   (description "GNU MPC, a library for multiprecision complex arithmetic
-with exact rounding")
-   (long-description
-    "GNU MPC is a C library for the arithmetic of complex numbers with
-arbitrarily high precision and correct rounding of the result.  It is built
-upon and follows the same principles as GNU MPFR.")
-   (license "LGPLv3+")
-   (home-page "http://mpc.multiprecision.org/")))
-
-(define-public binutils
-  (package
-   (name "binutils")
-   (version "2.22")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/binutils/binutils-"
-                                version ".tar.bz2"))
-            (sha256
-             (base32
-              "1a9w66v5dwvbnawshjwqcgz7km6kw6ihkzp6sswv9ycc3knzhykc"))))
-   (build-system gnu-build-system)
-
-   ;; TODO: Add dependency on zlib + those for Gold.
-   (native-inputs
-    `(("patch/new-dtags" ,(search-patch "binutils-ld-new-dtags.patch"))))
-   (arguments
-    `(#:patches (list (assoc-ref %build-inputs "patch/new-dtags"))
-
-      ;; Add `-static-libgcc' to not retain a dependency on GCC when
-      ;; bootstrapping.
-      #:configure-flags '("LDFLAGS=-static-libgcc")))
-
-   (description "GNU Binutils, tools for manipulating binaries (linker,
-assembler, etc.)")
-   (long-description
-    "The GNU Binutils are a collection of binary tools.  The main ones are
-`ld' (the GNU linker) and `as' (the GNU assembler).  They also include the
-BFD (Binary File Descriptor) library, `gprof', `nm', `strip', etc.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/binutils/")))
-
-(define (glibc-dynamic-linker system)
-  "Return the name of Glibc's dynamic linker for SYSTEM."
-  (if (string=? system "x86_64-linux")
-      "ld-linux-x86-64.so.2"
-      (error "dynamic linker name not known for this system" system)))
-
-(define-public gcc-4.7
-  (let ((stripped? #t))                         ; TODO: make this a parameter
-    (package
-     (name "gcc")
-     (version "4.7.2")
-     (source (origin
-              (method http-fetch)
-              (uri (string-append "http://ftp.gnu.org/gnu/gcc/gcc-"
-                                  version "/gcc-" version ".tar.bz2"))
-              (sha256
-               (base32
-                "115h03hil99ljig8lkrq4qk426awmzh0g99wrrggxf8g07bq74la"))))
-     (build-system gnu-build-system)
-     (inputs `(("gmp" ,gmp)
-               ("mpfr" ,mpfr)
-               ("mpc" ,mpc)))           ; TODO: libelf, ppl, cloog, zlib, etc.
-     (arguments
-      `(#:out-of-source? #t
-        #:strip-binaries? ,stripped?
-        #:configure-flags
-        `("--enable-plugin"
-          "--enable-languages=c,c++"
-          "--disable-multilib"
-          ,(let ((libc (assoc-ref %build-inputs "libc")))
-             (if libc
-                 (string-append "--with-native-system-header-dir=" libc
-                                "/include")
-                 "--without-headers")))
-        #:make-flags
-        (let ((libc (assoc-ref %build-inputs "libc")))
-          `(,@(if libc
-                  (list (string-append "LDFLAGS_FOR_BUILD="
-                                       "-L" libc "/lib "
-                                       "-Wl,-dynamic-linker "
-                                       "-Wl," libc
-                                       "/lib/ld-linux-x86-64.so.2"))
-                  '())
-            ,(string-append "BOOT_CFLAGS=-O2 "
-                            ,(if stripped? "-g0" "-g"))))
-
-        #:tests? #f
-        #:phases
-        (alist-cons-before
-         'configure 'pre-configure
-         (lambda* (#:key inputs outputs #:allow-other-keys)
-           (let ((out  (assoc-ref outputs "out"))
-                 (libc (assoc-ref inputs "libc")))
-             (when libc
-               ;; The following is not performed for `--without-headers'
-               ;; cross-compiler builds.
-
-               ;; Fix the dynamic linker's file name.
-               (substitute* "gcc/config/i386/linux64.h"
-                 (("#define GLIBC_DYNAMIC_LINKER([^ ]*).*$" _ suffix)
-                  (format #f "#define GLIBC_DYNAMIC_LINKER~a \"~a\"~%"
-                          suffix
-                          (string-append libc "/lib/ld-linux-x86-64.so.2"))))
-
-               ;; Tell where to find libstdc++, libc, and `?crt*.o', except
-               ;; `crt{begin,end}.o', which come with GCC.
-
-               ;; XXX: For crt*.o, use `STANDARD_STARTFILE_PREFIX' instead?  See
-               ;; <http://www.linuxfromscratch.org/lfs/view/stable/chapter05/gcc-pass1.html>.
-               (substitute* ("gcc/config/gnu-user.h"
-                             "gcc/config/i386/gnu-user.h"
-                             "gcc/config/i386/gnu-user64.h")
-                 (("#define LIB_SPEC (.*)$" _ suffix)
-                  (format #f "#define LIB_SPEC \"-L~a/lib -rpath=~a/lib \
--rpath=~a/lib64 -rpath=~a/lib \" ~a~%"
-                          libc libc out out suffix))
-                 (("([^ ]*)crt([^\\.])\\.o" _ prefix suffix)
-                  (string-append libc "/lib/" prefix "crt" suffix ".o"))))
-
-             ;; Don't retain a dependency on the build-time sed.
-             (substitute* "fixincludes/fixincl.x"
-               (("static char const sed_cmd_z\\[\\] =.*;")
-                "static char const sed_cmd_z[] = \"sed\";"))))
-
-         (alist-cons-after
-          'configure 'post-configure
-          (lambda _
-            ;; Don't store configure flags, to avoid retaining references to
-            ;; build-time dependencies---e.g., `--with-ppl=/nix/store/xxx'.
-            (substitute* "Makefile"
-              (("^TOPLEVEL_CONFIGURE_ARGUMENTS=(.*)$" _ rest)
-               "TOPLEVEL_CONFIGURE_ARGUMENTS=\n")))
-          (alist-replace 'install
-                         (lambda* (#:key outputs #:allow-other-keys)
-                           (zero?
-                            (system* "make"
-                                     ,(if stripped?
-                                          "install-strip"
-                                          "install"))))
-                         %standard-phases)))))
-
-     (properties `((gcc-libc . ,(assoc-ref inputs "libc"))))
-     (description "The GNU Compiler Collection")
-     (long-description
-      "The GNU Compiler Collection includes compiler front ends for C, C++,
-Objective-C, Fortran, OpenMP for C/C++/Fortran, Java, and Ada, as well as
-libraries for these languages (libstdc++, libgcj, libgomp,...).
-
-GCC development is a part of the GNU Project, aiming to improve the compiler
-used in the GNU system including the GNU/Linux variant.")
-     (license "GPLv3+")
-     (home-page "http://gcc.gnu.org/"))))
-
-(define-public ncurses
-  (let ((post-install-phase
-         '(lambda* (#:key outputs #:allow-other-keys)
-            (let ((out (assoc-ref outputs "out")))
-              ;; When building a wide-character (Unicode) build, create backward
-              ;; compatibility links from the the "normal" libraries to the
-              ;; wide-character libraries (e.g. libncurses.so to libncursesw.so).
-              (with-directory-excursion (string-append out "/lib")
-                (for-each (lambda (lib)
-                            (define libw.a
-                              (string-append "lib" lib "w.a"))
-                            (define lib.a
-                              (string-append "lib" lib ".a"))
-                            (define libw.so.x
-                              (string-append "lib" lib "w.so.5"))
-                            (define lib.so.x
-                              (string-append "lib" lib ".so.5"))
-                            (define lib.so
-                              (string-append "lib" lib ".so"))
-
-                            (when (file-exists? libw.a)
-                              (format #t "creating symlinks for `lib~a'~%" lib)
-                              (symlink libw.a lib.a)
-                              (symlink libw.so.x lib.so.x)
-                              (false-if-exception (delete-file lib.so))
-                              (call-with-output-file lib.so
-                                (lambda (p)
-                                  (format p "INPUT (-l~aw)~%" lib)))))
-                          '("curses" "ncurses" "form" "panel" "menu")))))))
-    (package
-     (name "ncurses")
-     (version "5.9")
-     (source (origin
-              (method http-fetch)
-              (uri (string-append "http://ftp.gnu.org/gnu/ncurses/ncurses-"
-                                  version ".tar.gz"))
-              (sha256
-               (base32
-                "0fsn7xis81za62afan0vvm38bvgzg5wfmv1m86flqcj0nj7jjilh"))))
-     (build-system gnu-build-system)
-     (arguments
-      (case-lambda
-        ((system)
-         `(#:configure-flags
-           `("--with-shared" "--without-debug" "--enable-widec"
-
-             ;; By default headers land in an `ncursesw' subdir, which is not
-             ;; what users expect.
-             ,(string-append "--includedir=" (assoc-ref %outputs "out")
-                             "/include")
-
-             ;; C++ bindings fail to build on
-             ;; `i386-pc-solaris2.11' with GCC 3.4.3:
-             ;; <http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=6395191>.
-             ,,@(if (string=? system "i686-solaris")
-                    '("--without-cxx-binding")
-                    '()))
-           #:tests? #f                            ; no "check" target
-           #:phases (alist-cons-after 'install 'post-install
-                                      ,post-install-phase
-                                      %standard-phases)))
-        ((system cross-system)
-         (arguments cross-system))))
-     (self-native-input? #t)
-     (description
-      "GNU Ncurses, a free software emulation of curses in SVR4 and more")
-     (long-description
-      "The Ncurses (new curses) library is a free software emulation of curses
-in System V Release 4.0, and more.  It uses Terminfo format, supports pads
-and color and multiple highlights and forms characters and function-key
-mapping, and has all the other SYSV-curses enhancements over BSD Curses.
-
-The ncurses code was developed under GNU/Linux.  It has been in use for some
-time with OpenBSD as the system curses library, and on FreeBSD and NetBSD as
-an external package.  It should port easily to any ANSI/POSIX-conforming
-UNIX.  It has even been ported to OS/2 Warp!")
-     (license "X11")
-     (home-page "http://www.gnu.org/software/ncurses/"))))
-
-(define-public readline
-  (package
-   (name "readline")
-   (version "6.2")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/readline/readline-"
-                                version ".tar.gz"))
-            (sha256
-             (base32
-              "10ckm2bd2rkxhvdmj7nmbsylmihw0abwcsnxf8y27305183rd9kr"))))
-   (build-system gnu-build-system)
-   (propagated-inputs `(("ncurses" ,ncurses)))
-   (inputs `(("patch/link-ncurses"
-              ,(search-patch "readline-link-ncurses.patch"))))
-   (arguments `(#:patches (list (assoc-ref %build-inputs
-                                           "patch/link-ncurses"))
-                #:patch-flags '("-p0")
-                #:configure-flags
-                (list (string-append "LDFLAGS=-Wl,-rpath -Wl,"
-                                     (assoc-ref %build-inputs "ncurses")
-                                     "/lib"))))
-   (description "GNU Readline, a library for interactive line editing")
-   (long-description
-    "The GNU Readline library provides a set of functions for use by
-applications that allow users to edit command lines as they are typed in.
-Both Emacs and vi editing modes are available.  The Readline library includes
-additional functions to maintain a list of previously-entered command lines,
-to recall and perhaps reedit those lines, and perform csh-like history
-expansion on previous commands.
-
-The history facilites are also placed into a separate library, the History
-library, as part of the build process.  The History library may be used
-without Readline in applications which desire its capabilities.")
-   (license "GPLv3+")
-   (home-page "http://savannah.gnu.org/projects/readline/")))
-
-(define-public bash
-  (let ((cppflags (string-join '("-DSYS_BASHRC='\"/etc/bashrc\"'"
-                                 "-DSYS_BASH_LOGOUT='\"/etc/bash_logout\"'"
-                                 "-DDEFAULT_PATH_VALUE='\"/no-such-path\"'"
-                                 "-DSTANDARD_UTILS_PATH='\"/no-such-path\"'"
-                                 "-DNON_INTERACTIVE_LOGIN_SHELLS"
-                                 "-DSSH_SOURCE_BASHRC")
-                               " ")))
-    (package
-     (name "bash")
-     (version "4.2")
-     (source (origin
-              (method http-fetch)
-              (uri (string-append
-                    "http://ftp.gnu.org/gnu/bash/bash-" version ".tar.gz"))
-              (sha256
-               (base32
-                "1n5kbblp5ykbz5q8aq88lsif2z0gnvddg9babk33024wxiwi2ym2"))))
-     (build-system gnu-build-system)
-     (inputs `(("readline" ,readline)
-               ("ncurses" ,ncurses)))             ; TODO: add texinfo
-     (arguments
-      `(#:configure-flags `("--with-installed-readline"
-                            ,,(string-append "CPPFLAGS=" cppflags)
-                            ,(string-append
-                              "LDFLAGS=-Wl,-rpath -Wl,"
-                              (assoc-ref %build-inputs "readline")
-                              "/lib"
-                              " -Wl,-rpath -Wl,"
-                              (assoc-ref %build-inputs "ncurses")
-                              "/lib"))
-
-        ;; XXX: The tests have a lot of hard-coded paths, so disable them
-        ;; for now.
-        #:tests? #f
-
-        #:phases
-        (alist-cons-after 'install 'post-install
-                          (lambda* (#:key outputs #:allow-other-keys)
-                            ;; Add a `bash' -> `sh' link.
-                            (let ((out (assoc-ref outputs "out")))
-                              (with-directory-excursion
-                                  (string-append out "/bin")
-                                (symlink "bash" "sh"))))
-                          %standard-phases)))
-     (description "GNU Bourne-Again Shell")
-     (long-description
-      "Bash is the shell, or command language interpreter, that will appear in
-the GNU operating system.  Bash is an sh-compatible shell that incorporates
-useful features from the Korn shell (ksh) and C shell (csh).  It is intended
-to conform to the IEEE POSIX P1003.2/ISO 9945.2 Shell and Tools standard.  It
-offers functional improvements over sh for both programming and interactive
-use.  In addition, most sh scripts can be run by Bash without
-modification.")
-     (license "GPLv3+")
-     (home-page "http://www.gnu.org/software/bash/"))))
-
-(define-public libtool
-  (package
-   (name "libtool")
-   (version "2.4.2")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/libtool/libtool-"
-                                version ".tar.gz"))
-            (sha256
-             (base32
-              "0649qfpzkswgcj9vqkkr9rn4nlcx80faxpyqscy2k1x9c94f93dk"))))
-   (build-system gnu-build-system)
-   (native-inputs `(("m4" ,m4)
-                    ("perl" ,perl)))
-   (arguments
-    ;; TODO: Use `TESTSUITEFLAGS=-jN' for tests.
-    `(#:patches (list (assoc-ref %build-inputs "patch/skip-tests"))))
-   (inputs `(("patch/skip-tests"
-              ,(search-patch "libtool-skip-tests.patch"))))
-   (description "GNU Libtool, a generic library support script")
-   (long-description
-    "GNU libtool is a generic library support script.  Libtool hides the
-complexity of using shared libraries behind a consistent, portable interface.
-
-To use libtool, add the new generic library building commands to your
-Makefile, Makefile.in, or Makefile.am.  See the documentation for
-details.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/libtool/")))
-
-(define-public libunistring
-  (package
-   (name "libunistring")
-   (version "0.9.3")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append
-                  "http://ftp.gnu.org/gnu/libunistring/libunistring-"
-                  version ".tar.gz"))
-            (sha256
-             (base32
-              "18q620269xzpw39dwvr9zpilnl2dkw5z5kz3mxaadnpv4k3kw3b1"))))
-   (propagated-inputs '())                  ; FIXME: add libiconv when !glibc
-   (build-system gnu-build-system)
-   (description "GNU Libunistring, a Unicode string library")
-   (long-description
-    "This library provides functions for manipulating Unicode strings and for
-manipulating C strings according to the Unicode standard.
-
-GNU libunistring is for you if your application involves non-trivial text
-processing, such as upper/lower case conversions, line breaking, operations
-on words, or more advanced analysis of text.  Text provided by the user can,
-in general, contain characters of all kinds of scripts.  The text processing
-functions provided by this library handle all scripts and all languages.
-
-libunistring is for you if your application already uses the ISO C / POSIX
-<ctype.h>, <wctype.h> functions and the text it operates on is provided by
-the user and can be in any language.
-
-libunistring is also for you if your application uses Unicode strings as
-internal in-memory representation.")
-   (home-page "http://www.gnu.org/software/libunistring/")
-   (license "LGPLv3+")))
-
-(define-public recutils
-  (package
-   (name "recutils")
-   (version "1.5")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/recutils/recutils-"
-                                version ".tar.gz"))
-            (sha256
-             (base32
-              "1v2xzwwwhc5j5kmvg4sv6baxjpsfqh8ln7ilv4mgb1408rs7xmky"))))
-   (build-system gnu-build-system)
-   (inputs `(("curl" ,(nixpkgs-derivation* "curl"))
-             ("emacs" ,(nixpkgs-derivation* "emacs"))
-             ("check" ,(nixpkgs-derivation* "check"))
-             ("bc" ,(nixpkgs-derivation* "bc"))
-             ("patch/gets"
-              ,(search-patch "diffutils-gets-undeclared.patch"))))
-   (arguments `(#:patches (list (assoc-ref %build-inputs "patch/gets"))))
-   (description "GNU recutils, tools and libraries to access human-editable,
-text-based databases")
-   (long-description
-    "GNU recutils is a set of tools and libraries to access human-editable,
-text-based databases called recfiles.  The data is stored as a sequence of
-records, each record containing an arbitrary number of named fields.")
-   (license "GPLv3+")
-   (home-page "http://www.gnu.org/software/recutils/")))
-
-(define-public guile-1.8
-  (package
-   (name "guile")
-   (version "1.8.8")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/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-loader-search-path
-                           (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")))))
-                           %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)
-
-   (description "GNU Guile 1.8, an embeddable Scheme interpreter")
-   (long-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 "LGPLv2+")))
-
-(define-public libffi
-  (let ((post-install-phase
-         ;; Install headers in the right place.
-         '(lambda* (#:key outputs #:allow-other-keys)
-            (define out (assoc-ref outputs "out"))
-            (mkdir (string-append out "/include"))
-            (with-directory-excursion
-                (string-append out "/lib/libffi-3.0.9/include")
-              (for-each (lambda (h)
-                          (format #t "moving `~a' to includedir~%" h)
-                          (rename-file h (string-append out "/include/" h)))
-                        (scandir "."
-                                 (lambda (x)
-                                   (not (member x '("." ".."))))))))))
-   (package
-    (name "libffi")
-    (version "3.0.9")
-    (source (origin
-             (method ftp-fetch)
-             (uri
-              (string-append "ftp://sourceware.org/pub/libffi/"
-                             name "-" version ".tar.gz"))
-             (sha256
-              (base32
-               "0ln4jbpb6clcsdpb9niqk0frgx4k0xki96wiv067ig0q4cajb7aq"))))
-    (build-system gnu-build-system)
-    (arguments `(#:modules ((guix build utils) (guix build gnu-build-system)
-                            (ice-9 ftw) (srfi srfi-26))
-                 #:phases (alist-cons-after 'install 'post-install
-                                            ,post-install-phase
-                                            %standard-phases)))
-    (description "libffi, a foreign function call interface library")
-    (long-description
-     "The libffi library provides a portable, high level programming interface
-to various calling conventions.  This allows a programmer to call any
-function specified by a call interface description at run-time.
-
-FFI stands for Foreign Function Interface.  A foreign function interface is
-the popular name for the interface that allows code written in one language
-to call code written in another language.  The libffi library really only
-provides the lowest, machine dependent layer of a fully featured foreign
-function interface.  A layer must exist above libffi that handles type
-conversions for values passed between the two languages.")
-    (home-page "http://sources.redhat.com/libffi/")
-
-    ;; See <http://github.com/atgreen/libffi/blob/master/LICENSE>.
-    (license "free, non-copyleft"))))
-
-(define-public guile-2.0
-  (package
-   (name "guile")
-   (version "2.0.6")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/guile/guile-" version
-                                ".tar.xz"))
-            (sha256
-             (base32
-              "000ng5qsq3cl1k35jvzvhwxj92wx4q87745n2fppkd4irh58vv5l"))))
-   (build-system gnu-build-system)
-   (native-inputs `(("pkgconfig" ,(nixpkgs-derivation* "pkgconfig"))))
-   (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" ,(nixpkgs-derivation* "boehmgc"))
-      ("gmp" ,gmp)))
-
-   (self-native-input? #t)
-
-   (description "GNU Guile 2.0, an embeddable Scheme implementation")
-   (long-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 "LGPLv3+")))
-
-(define-public linux-headers
-  (let* ((version* "3.3.5")
-         (build-phase
-          '(lambda* (#:key outputs #:allow-other-keys)
-             (setenv "ARCH" "x86_64")       ; XXX
-             (and (zero? (system* "make" "defconfig"))
-                  (zero? (system* "make" "mrproper" "headers_check")))))
-         (install-phase
-          `(lambda* (#:key outputs #:allow-other-keys)
-             (let ((out (assoc-ref outputs "out")))
-               (and (zero? (system* "make"
-                                    (string-append "INSTALL_HDR_PATH=" out)
-                                    "headers_install"))
-                    (mkdir (string-append out "/include/config"))
-                    (call-with-output-file
-                        (string-append out
-                                       "/include/config/kernel.release")
-                      (lambda (p)
-                        (format p "~a-default~%" ,version*))))))))
-   (package
-    (name "linux-headers")
-    (version version*)
-    (source (origin                               ; TODO: use Linux-Libre
-             (method http-fetch)
-             (uri (string-append
-                   "http://www.kernel.org/pub/linux/kernel/v3.x/linux-"
-                   version ".tar.xz"))
-             (sha256
-              (base32
-               "0i74jn47f6vs5kcvk8abvz3k08z32c9bbqw0sdjkdxwvr4jbczpv"))))
-    (build-system gnu-build-system)
-    (native-inputs `(("perl" ,perl)))
-    (arguments
-     `(#:modules ((guix build gnu-build-system)
-                  (guix build utils)
-                  (srfi srfi-1))
-       #:phases (alist-replace
-                 'build ,build-phase
-                 (alist-replace
-                  'install ,install-phase
-                  (alist-delete 'configure %standard-phases)))
-       #:tests? #f))
-    (description "Linux kernel headers")
-    (long-description "Headers of the Linux kernel.")
-    (license "GPLv2")
-    (home-page "http://kernel.org/"))))
-
-(define-public glibc
-  (package
-   (name "glibc")
-   (version "2.16.0")
-   (source (origin
-            (method http-fetch)
-            (uri (string-append "http://ftp.gnu.org/gnu/glibc/glibc-"
-                                version ".tar.xz"))
-            (sha256
-             (base32
-              "092rdm49zh6l1pqkxbcpcaawgsgzxhpf1s7wf5wi5dvc5am3dp0y"))))
-   (build-system gnu-build-system)
-
-   ;; Glibc's <limits.h> refers to <linux/limit.h>, for instance, so glibc
-   ;; users should automatically pull Linux headers as well.
-   (propagated-inputs `(("linux-headers" ,linux-headers)))
-
-   (arguments
-    `(#:out-of-source? #t
-      #:configure-flags
-      (list "--enable-add-ons"
-            "--sysconfdir=/etc"
-            "--localedir=/var/run/current-system/sw/lib/locale" ; XXX
-            (string-append "--with-headers="
-                           (assoc-ref %build-inputs "linux-headers")
-                           "/include")
-
-            ;; The default is to assume a 2.4 Linux interface, but we'll
-            ;; always use something newer.  See "kernel-features.h" in the
-            ;; GNU libc for details.
-            "--enable-kernel=2.6.30"
-
-            ;; XXX: Work around "undefined reference to `__stack_chk_guard'".
-            "libc_cv_ssp=no")
-      #:tests? #f                                 ; XXX
-      #:phases (alist-cons-before
-                'configure 'pre-configure
-                (lambda* (#:key outputs #:allow-other-keys)
-                  (let ((out (assoc-ref outputs "out")))
-                    ;; Use `pwd', not `/bin/pwd'.
-                    (substitute* "configure"
-                      (("/bin/pwd") "pwd"))
-
-                    ;; Install the rpc data base file under `$out/etc/rpc'.
-                    ;; FIXME: Use installFlags = [ "sysconfdir=$(out)/etc" ];
-                    (substitute* "sunrpc/Makefile"
-                      (("^\\$\\(inst_sysconfdir\\)/rpc(.*)$" _ suffix)
-                       (string-append out "/etc/rpc" suffix "\n"))
-                      (("^install-others =.*$")
-                       (string-append "install-others = " out "/etc/rpc\n")))
-
-                    (substitute* "Makeconfig"
-                      ;; According to
-                      ;; <http://www.linuxfromscratch.org/lfs/view/stable/chapter05/glibc.html>,
-                      ;; linking against libgcc_s is not needed with GCC
-                      ;; 4.7.1.
-                      ((" -lgcc_s") ""))))
-                %standard-phases)))
-   (description "The GNU C Library")
-   (long-description
-    "Any Unix-like operating system needs a C library: the library which
-defines the \"system calls\" and other basic facilities such as open, malloc,
-printf, exit...
-
-The GNU C library is used as the C library in the GNU system and most systems
-with the Linux kernel.")
-   (license "LGPLv2+")
-   (home-page "http://www.gnu.org/software/libc/")))
-
-
-;;;
-;;; Bootstrap packages.
-;;;
-
-(define %bootstrap-inputs
-  (compile-time-value
-   `(("libc" ,(nixpkgs-derivation "glibc"))
-     ,@(map (lambda (name)
-              (list name (nixpkgs-derivation name)))
-            '("gnutar" "gzip" "bzip2" "xz" "patch"
-              "coreutils" "gnused" "gnugrep" "bash"
-              "gawk"                                ; used by `config.status'
-              "gcc" "binutils")))))
-
-(define-syntax substitute-keyword-arguments
-  (syntax-rules ()
-    "Return a new list of arguments where the value for keyword arg KW is
-replaced by EXP.  EXP is evaluated in a context where VAR is boud to the
-previous value of the keyword argument."
-    ((_ original-args ((kw var) exp) ...)
-     (let loop ((args    original-args)
-                (before '()))
-       (match args
-         ((kw var rest (... ...))
-          (loop rest (cons* exp kw before)))
-         ...
-         ((x rest (... ...))
-          (loop rest (cons x before)))
-         (()
-          (reverse before)))))))
-
-(define gnu-make-boot0
-  (package (inherit gnu-make)
-    (name "make-boot0")
-    (location (source-properties->location (current-source-location)))
-    (arguments `(#:implicit-inputs? #f
-                 #:tests? #f                      ; cannot run "make check"
-                 #:phases
-                 (alist-replace
-                  'build (lambda _
-                           (zero? (system* "./build.sh")))
-                  (alist-replace
-                   'install (lambda* (#:key outputs #:allow-other-keys)
-                              (let* ((out (assoc-ref outputs "out"))
-                                     (bin (string-append out "/bin")))
-                                (mkdir out)
-                                (mkdir bin)
-                                (copy-file "make"
-                                           (string-append bin "/make"))))
-                   %standard-phases))))
-    (inputs %bootstrap-inputs)))
-
-(define diffutils-boot0
-  (let ((p (package-with-explicit-inputs diffutils
-                                         `(("make" ,gnu-make-boot0)
-                                           ,@%bootstrap-inputs))))
-    (package (inherit p)
-      (location (source-properties->location (current-source-location)))
-      (arguments `(#:tests? #f               ; the test suite needs diffutils
-                   ,@(package-arguments p))))))
-
-(define findutils-boot0
-  (package-with-explicit-inputs findutils
-                                `(("make" ,gnu-make-boot0)
-                                  ("diffutils" ,diffutils-boot0) ; for tests
-                                  ,@%bootstrap-inputs)
-                                (current-source-location)))
-
-
-(define %boot0-inputs
-  `(("make" ,gnu-make-boot0)
-    ("diffutils" ,diffutils-boot0)
-    ("findutils" ,findutils-boot0)
-    ,@%bootstrap-inputs))
-
-(define* (nix-system->gnu-triplet system #:optional (vendor "unknown"))
-  "Return an a guess of the GNU triplet corresponding to Nix system
-identifier SYSTEM."
-  (let* ((dash (string-index system #\-))
-         (arch (substring system 0 dash))
-         (os   (substring system (+ 1 dash))))
-    (string-append arch
-                   "-" vendor "-"
-                   (if (string=? os "linux")
-                       "linux-gnu"
-                       os))))
-
-(define boot-triplet
-  ;; Return the triplet used to create the cross toolchain needed in the
-  ;; first bootstrapping stage.
-  (cut nix-system->gnu-triplet <> "guix"))
-
-;; Following Linux From Scratch, build a cross-toolchain in stage 0.  That
-;; toolchain actually targets the same OS and arch, but it has the advantage
-;; of being independent of the libc and tools in %BOOTSTRAP-INPUTS, since
-;; GCC-BOOT0 (below) is built without any reference to the target libc.
-
-(define binutils-boot0
-  (package (inherit binutils)
-    (name "binutils-cross-boot0")
-    (arguments
-     (lambda (system)
-       `(#:implicit-inputs? #f
-         ,@(substitute-keyword-arguments (package-arguments binutils)
-             ((#:configure-flags cf)
-              `(list ,(string-append "--target=" (boot-triplet system))))))))
-    (inputs %boot0-inputs)))
-
-(define gcc-boot0
-  (package (inherit gcc-4.7)
-    (name "gcc-cross-boot0")
-    (arguments
-     (lambda (system)
-       `(#:implicit-inputs? #f
-         #:modules ((guix build gnu-build-system)
-                    (guix build utils)
-                    (ice-9 regex)
-                    (srfi srfi-1)
-                    (srfi srfi-26))
-         ,@(substitute-keyword-arguments (package-arguments gcc-4.7)
-             ((#:configure-flags flags)
-              `(append (list ,(string-append "--target="
-                                             (boot-triplet system))
-
-                             ;; No libc yet.
-                             "--without-headers"
-
-                             ;; Disable features not needed at this stage.
-                             "--disable-shared"
-                             "--enable-languages=c"
-                             "--disable-libmudflap"
-                             "--disable-libgomp"
-                             "--disable-libssp"
-                             "--disable-libquadmath"
-                             "--disable-decimal-float")
-                       (remove (cut string-match "--enable-languages.*" <>)
-                               ,flags)))
-             ((#:phases phases)
-              `(alist-cons-after
-                'unpack 'unpack-gmp&co
-                (lambda* (#:key inputs #:allow-other-keys)
-                  (let ((gmp  (assoc-ref %build-inputs "gmp-source"))
-                        (mpfr (assoc-ref %build-inputs "mpfr-source"))
-                        (mpc  (assoc-ref %build-inputs "mpc-source")))
-
-                    ;; To reduce the set of pre-built bootstrap inputs, build
-                    ;; GMP & co. from GCC.
-                    (for-each (lambda (source)
-                                (or (zero? (system* "tar" "xvf" source))
-                                    (error "failed to unpack tarball"
-                                           source)))
-                              (list gmp mpfr mpc))
-
-                    ;; Create symlinks like `gmp' -> `gmp-5.0.5'.
-                    ,@(map (lambda (lib)
-                             `(symlink ,(package-full-name lib)
-                                       ,(package-name lib)))
-                           (list gmp mpfr mpc))
-
-                    ;; MPFR headers/lib are found under $(MPFR)/src, but
-                    ;; `configure' wrongfully tells MPC too look under
-                    ;; $(MPFR), so fix that.
-                    (substitute* "configure"
-                      (("extra_mpc_mpfr_configure_flags(.+)--with-mpfr-include=([^/]+)/mpfr(.*)--with-mpfr-lib=([^ ]+)/mpfr"
-                        _ equals include middle lib)
-                       (string-append "extra_mpc_mpfr_configure_flags" equals
-                                      "--with-mpfr-include=" include
-                                      "/mpfr/src" middle
-                                      "--with-mpfr-lib=" lib
-                                      "/mpfr/src"))
-                      (("gmpinc='-I([^ ]+)/mpfr -I([^ ]+)/mpfr" _ a b)
-                       (string-append "gmpinc='-I" a "/mpfr/src "
-                                      "-I" b "/mpfr/src"))
-                      (("gmplibs='-L([^ ]+)/mpfr" _ a)
-                       (string-append "gmplibs='-L" a "/mpfr/src")))))
-                (alist-cons-after
-                 'install 'symlink-libgcc_eh
-                 (lambda* (#:key outputs #:allow-other-keys)
-                   (let ((out (assoc-ref outputs "out")))
-                     ;; Glibc wants to link against libgcc_eh, so provide
-                     ;; it.
-                     (with-directory-excursion
-                         (string-append out "/lib/gcc/"
-                                        ,(boot-triplet system)
-                                        "/" ,(package-version gcc-4.7))
-                       (symlink "libgcc.a" "libgcc_eh.a"))))
-                 ,phases)))))))
-
-    (inputs `(("gmp-source" ,(package-source gmp))
-              ("mpfr-source" ,(package-source mpfr))
-              ("mpc-source" ,(package-source mpc))
-              ("binutils-cross" ,binutils-boot0)
-
-              ;; Call it differently so that the builder can check whether
-              ;; the "libc" input is #f.
-              ("libc-native" ,@(assoc-ref %boot0-inputs "libc"))
-              ,@(alist-delete "libc" %boot0-inputs)))))
-
-(define linux-headers-boot0
-  (package (inherit linux-headers)
-    (arguments `(#:implicit-inputs? #f
-                 ,@(package-arguments linux-headers)))
-    (native-inputs
-     (let ((perl (package-with-explicit-inputs perl
-                                               %boot0-inputs
-                                               (current-source-location))))
-       `(("perl" ,perl)
-         ,@%boot0-inputs)))))
-
-(define %boot1-inputs
-  ;; 2nd stage inputs.
-  `(("gcc" ,gcc-boot0)
-    ("binutils-cross" ,binutils-boot0)
-
-    ;; Keep "binutils" here because the cross-gcc invokes `as', not the
-    ;; cross-`as'.
-    ,@%boot0-inputs))
-
-(define-public glibc-final
-  ;; The final libc, "cross-built".  If everything went well, the resulting
-  ;; store path has no dependencies.
-  (package (inherit glibc)
-    (arguments
-     (lambda (system)
-      `(#:implicit-inputs? #f
-
-        ;; Leave /bin/sh as the interpreter for `ldd', `sotruss', etc. to
-        ;; avoid keeping a reference to the bootstrap Bash.
-        #:patch-shebangs? #f
-        ,@(substitute-keyword-arguments (package-arguments glibc)
-            ((#:configure-flags flags)
-             `(append (list ,(string-append "--host=" (boot-triplet system))
-                            ,(string-append "--build="
-                                            (nix-system->gnu-triplet system))
-                            "BASH_SHELL=/bin/sh"
-
-                            ;; cross-rpcgen fails to build, because it gets
-                            ;; built with the cross-compiler instead of the
-                            ;; native compiler.  See also
-                            ;; <http://sourceware.org/ml/libc-alpha/2012-03/msg00325.html>.
-                            "--disable-obsolete-rpc")
-                     ,flags))))))
-    (propagated-inputs `(("linux-headers" ,linux-headers-boot0)))
-    (inputs `(;; A native GCC is needed to build `cross-rpcgen'.
-              ("native-gcc" ,@(assoc-ref %boot0-inputs "gcc"))
-              ,@%boot1-inputs))))
-
-(define gcc-boot0-wrapped
-  ;; Make the cross-tools GCC-BOOT0 and BINUTILS-BOOT0 available under the
-  ;; non-cross names.
-  (package (inherit gcc-4.7)
-    (name (string-append (package-name gcc-boot0) "-wrapped"))
-    (build-system trivial-build-system)
-    (arguments
-     (lambda (system)
-      `(#:modules ((guix build utils))
-        #:builder (begin
-                    (use-modules (guix build utils))
-
-                    (let* ((binutils (assoc-ref %build-inputs "binutils"))
-                           (gcc      (assoc-ref %build-inputs "gcc"))
-                           (libc     (assoc-ref %build-inputs "libc"))
-                           (out      (assoc-ref %outputs "out"))
-                           (bindir   (string-append out "/bin"))
-                           (triplet  ,(boot-triplet system)))
-                      (mkdir out) (mkdir bindir)
-                      (with-directory-excursion bindir
-                        (for-each (lambda (tool)
-                                    (symlink (string-append binutils "/bin/"
-                                                            triplet "-" tool)
-                                             tool))
-                                  '("ar" "ranlib"))
-
-                        ;; GCC-BOOT0 is a libc-less cross-compiler, so it
-                        ;; needs to be told where to find the crt files and
-                        ;; the dynamic linker.
-                        (call-with-output-file "gcc"
-                          (lambda (p)
-                            (format p "#!/bin/sh
-exec ~a/bin/~a-gcc -B~a/lib -Wl,-dynamic-linker -Wl,~a/lib/~a \"$@\"~%"
-                                    gcc triplet
-                                    libc libc
-                                    ,(glibc-dynamic-linker system))))
-
-                        (chmod "gcc" #o555)))))))
-    (native-inputs
-     `(("binutils" ,binutils-boot0)
-       ("gcc" ,gcc-boot0)
-       ("libc" ,glibc-final)))
-    (inputs '())))
-
-(define %boot2-inputs
-  ;; 3rd stage inputs.
-  `(("libc" ,glibc-final)
-    ("gcc" ,gcc-boot0-wrapped)
-    ,@(fold alist-delete %boot1-inputs '("libc" "gcc"))))
-
-(define binutils-final
-  (package (inherit binutils)
-    (arguments
-     (lambda (system)
-       `(#:implicit-inputs? #f
-         ,@(package-arguments binutils))))
-    (inputs %boot2-inputs)))
-
-(define-public gcc-final
-  ;; The final GCC.
-  (package (inherit gcc-boot0)
-    (name "gcc")
-    (arguments
-     (lambda (system)
-       `(#:implicit-inputs? #f
-
-         ;; Build again GMP & co. within GCC's build process, because it's hard
-         ;; to do outside (because GCC-BOOT0 is a cross-compiler, and thus
-         ;; doesn't honor $LIBRARY_PATH, which breaks `gnu-build-system'.)
-         ,@(substitute-keyword-arguments ((package-arguments gcc-boot0) system)
-             ((#:configure-flags boot-flags)
-              (let loop ((args (package-arguments gcc-4.7)))
-                (match args
-                  ((#:configure-flags normal-flags _ ...)
-                   normal-flags)
-                  ((_ rest ...)
-                   (loop rest)))))
-             ((#:phases phases)
-              `(alist-delete 'symlink-libgcc_eh ,phases))))))
-
-    (inputs `(("gmp-source" ,(package-source gmp))
-              ("mpfr-source" ,(package-source mpfr))
-              ("mpc-source" ,(package-source mpc))
-              ("binutils" ,binutils-final)
-              ,@%boot2-inputs))))
-
-(define ld-wrapper-boot3
-  ;; A linker wrapper that uses the bootstrap Guile.
-  (package
-    (name "ld-wrapper-boot3")
-    (version "0")
-    (source #f)
-    (build-system trivial-build-system)
-    (inputs `(("binutils" ,binutils-final)
-              ("guile"   ,(nixpkgs-derivation* "guile"))
-              ("wrapper" ,(search-path %load-path "distro/ld-wrapper.scm"))))
-    (arguments
-     `(#:modules ((guix build utils))
-       #:builder (begin
-                   (use-modules (guix build utils)
-                                (system base compile))
-
-                   (let* ((out (assoc-ref %outputs "out"))
-                          (bin (string-append out "/bin"))
-                          (ld  (string-append bin "/ld"))
-                          (go  (string-append bin "/ld.go")))
-
-                     (setvbuf (current-output-port) _IOLBF)
-                     (format #t "building ~s/bin/ld wrapper in ~s~%"
-                             (assoc-ref %build-inputs "binutils")
-                             out)
-
-                     (mkdir out) (mkdir bin)
-                     (copy-file (assoc-ref %build-inputs "wrapper") ld)
-                     (substitute* ld
-                       (("@GUILE@")
-                        (string-append (assoc-ref %build-inputs "guile")
-                                       "/bin/guile"))
-                       (("@LD@")
-                        (string-append (assoc-ref %build-inputs "binutils")
-                                       "/bin/ld")))
-                     (chmod ld #o555)
-                     (compile-file ld #:output-file go)))))
-    (description "The linker wrapper")
-    (long-description
-     "The linker wrapper (or `ld-wrapper') wraps the linker to add any
-missing `-rpath' flags, and to detect any misuse of libraries outside of the
-store.")
-    (home-page #f)
-    (license "GPLv3+")))
-
-(define %boot3-inputs
-  ;; 4th stage inputs.
-  `(("gcc" ,gcc-final)
-    ("ld-wrapper" ,ld-wrapper-boot3)
-    ,@(alist-delete "gcc" %boot2-inputs)))
-
-(define-public bash-final
-  (package-with-explicit-inputs bash %boot3-inputs
-                                (current-source-location)))
-
-(define-public guile-final
-  (package-with-explicit-inputs guile-2.0
-                                `(("bash" ,bash-final)
-                                  ,@(alist-delete "bash" %boot3-inputs))
-                                (current-source-location)))
-
-(define-public ld-wrapper
-  ;; The final `ld' wrapper, which uses the final Guile.
-  (package (inherit ld-wrapper-boot3)
-    (name "ld-wrapper")
-    (inputs `(("guile" ,guile-final)
-              ,@(alist-delete "guile" (package-inputs ld-wrapper-boot3))))))
-
-(define-public %final-inputs
-  ;; Final derivations used as implicit inputs by `gnu-build-system'.
-  ;; FIXME: Build bash before the others, otherwise patch-shebangs uses it in
-  ;; bzip2, for instance.
-  (let ((finalize (cut package-with-explicit-inputs <> %boot3-inputs
-                       (current-source-location))))
-    `(,@(map (match-lambda
-              ((name package)
-               (list name (finalize package))))
-             `(("tar" ,tar)
-               ("gzip" ,gzip)
-               ("bzip2" ,bzip2)
-               ("xz" ,xz)
-               ("diffutils" ,diffutils)
-               ("patch" ,patch)
-               ("coreutils" ,coreutils)
-               ("sed" ,sed)
-               ("grep" ,grep)
-               ("findutils" ,findutils)
-               ("gawk" ,gawk)
-               ("make" ,gnu-make)))
-      ("bash" ,bash-final)
-      ("ld-wrapper" ,ld-wrapper)
-      ("binutils" ,binutils-final)
-      ("gcc" ,gcc-final)
-      ("libc" ,glibc-final))))
-
-
-;;;
-;;; Apps & libs --- TODO: move to separate module.
-;;;
-
-(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 http-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" ,(nixpkgs-derivation* "pkgconfig"))
-                    ("gperf" ,(nixpkgs-derivation* "gperf"))))
-   (inputs `(("guile" ,guile)))
-   (description "Guile-Reader, a simple framework for building readers for
-GNU Guile")
-   (long-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 "GPLv3+")))
-
-(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 lout
-  ;; This one is a bit tricky, because it doesn't follow the GNU Build System
-  ;; rules.  Instead, it has a makefile that has to be patched to set the
-  ;; prefix, etc., and it has no makefile rules to build its doc.
-  (let ((configure-phase
-         '(lambda* (#:key outputs #:allow-other-keys)
-            (let ((out (assoc-ref outputs "out"))
-                  (doc (assoc-ref outputs "doc")))
-              (substitute* "makefile"
-                (("^PREFIX[[:blank:]]*=.*$")
-                 (string-append "PREFIX = " out "\n"))
-                (("^LOUTLIBDIR[[:blank:]]*=.*$")
-                 (string-append "LOUTLIBDIR = " out "/lib/lout\n"))
-                (("^LOUTDOCDIR[[:blank:]]*=.*$")
-                 (string-append "LOUTDOCDIR = " doc "/doc/lout\n"))
-                (("^MANDIR[[:blank:]]*=.*$")
-                 (string-append "MANDIR = " out "/man\n")))
-              (mkdir out)
-              (mkdir (string-append out "/bin"))  ; TODO: use `mkdir-p'
-              (mkdir (string-append out "/lib"))
-              (mkdir (string-append out "/man"))
-              (mkdir doc)
-              (mkdir (string-append doc "/doc"))
-              (mkdir (string-append doc "/doc/lout")))))
-        (install-man-phase
-         '(lambda* (#:key outputs #:allow-other-keys)
-            (zero? (system* "make" "installman"))))
-        (doc-phase
-         '(lambda* (#:key outputs #:allow-other-keys)
-            (define out
-              (assoc-ref outputs "doc"))
-
-            (setenv "PATH"
-                    (string-append (assoc-ref outputs "out")
-                                   "/bin:" (getenv "PATH")))
-            (chdir "doc")
-            (every (lambda (doc)
-                     (format #t "doc: building `~a'...~%" doc)
-                     (with-directory-excursion doc
-                       (let ((file (string-append out "/doc/lout/"
-                                                  doc ".ps")))
-                         (and (or (file-exists? "outfile.ps")
-                                  (zero? (system* "lout" "-r4" "-o"
-                                                  "outfile.ps" "all")))
-                              (begin
-                                (copy-file "outfile.ps" file)
-                                #t)
-                              (zero? (system* "ps2pdf"
-                                              "-dPDFSETTINGS=/prepress"
-                                              "-sPAPERSIZE=a4"
-                                              file
-                                              (string-append out "/doc/lout/"
-                                                             doc ".pdf")))))))
-                   '("design" "expert" "slides" "user")))))
-   (package
-    (name "lout")
-    (version "3.39")
-    (source (origin
-             (method http-fetch)
-             ;; FIXME: `http-get' doesn't follow redirects, hence the URL.
-             (uri (string-append
-                   "http://download-mirror.savannah.gnu.org/releases/lout/lout-"
-                   version ".tar.gz"))
-             (sha256
-              (base32
-               "12gkyqrn0kaa8xq7sc7v3wm407pz2fxg9ngc75aybhi5z825b9vq"))))
-    (build-system gnu-build-system)               ; actually, just a makefile
-    (outputs '("out" "doc"))
-    (inputs `(("ghostscript" ,(nixpkgs-derivation* "ghostscript"))))
-    (arguments `(#:modules ((guix build utils)
-                            (guix build gnu-build-system)
-                            (srfi srfi-1))        ; we need SRFI-1
-                 #:tests? #f                      ; no "check" target
-
-                 ;; Customize the build phases.
-                 #:phases (alist-replace
-                           'configure ,configure-phase
-
-                           (alist-cons-after
-                            'install 'install-man-pages
-                            ,install-man-phase
-
-                            (alist-cons-after
-                             'install 'install-doc
-                             ,doc-phase
-                             %standard-phases)))))
-    (description "Lout, a document layout system similar in style to LaTeX")
-    (long-description
-"The Lout document formatting system is now reads a high-level description of
-a document similar in style to LaTeX and produces a PostScript or plain text
-output file.
-
-Lout offers an unprecedented range of advanced features, including optimal
-paragraph and page breaking, automatic hyphenation, PostScript EPS file
-inclusion and generation, equation formatting, tables, diagrams, rotation and
-scaling, sorted indexes, bibliographic databases, running headers and
-odd-even pages, automatic cross referencing, multilingual documents including
-hyphenation (most European languages are supported), formatting of computer
-programs, and much more, all ready to use.  Furthermore, Lout is easily
-extended with definitions which are very much easier to write than troff of
-TeX macros because Lout is a high-level, purely functional language, the
-outcome of an eight-year research project that went back to the
-beginning.")
-    (license "GPLv3+")
-    (home-page "http://savannah.nongnu.org/projects/lout/"))))
-
-;;; Local Variables:
-;;; eval: (put 'lambda* 'scheme-indent-function 1)
-;;; eval: (put 'substitute* 'scheme-indent-function 1)
-;;; eval: (put 'with-directory-excursion 'scheme-indent-function 1)
-;;; eval: (put 'package 'scheme-indent-function 1)
-;;; eval: (put 'substitute-keyword-arguments 'scheme-indent-function 1)
-;;; End: