nixo
/
guix-devel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' into core-updates 

Conflicts:
	gnu/packages/base.scm
This commit is contained in:
Mark H Weaver 2014-08-28 14:22:15 -04:00
parent 83291101c3 dd16424466
commit c00a9fbfef
39 changed files with 1008 additions and 808 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README
View File

@ -70,7 +70,7 @@ To do so:
Guix does the high-level preparation of a /derivation/. A derivation is Guix does the high-level preparation of a /derivation/. A derivation is
the promise of a build; it is stored as a text file under the promise of a build; it is stored as a text file under
=/nix/store/xxx.drv=. The (guix derivations) module provides the =/gnu/store/xxx.drv=. The (guix derivations) module provides the
`derivation' primitive, as well as higher-level wrappers such as `derivation' primitive, as well as higher-level wrappers such as
`build-expression->derivation'. `build-expression->derivation'.

2
build-aux/check-final-inputs-self-contained.scm
View File

@ -24,7 +24,7 @@
(guix packages) (guix packages)
(guix derivations) (guix derivations)
(guix ui) (guix ui)
(gnu packages base) (gnu packages commencement)
(ice-9 match) (ice-9 match)
(srfi srfi-1) (srfi srfi-1)
(srfi srfi-26)) (srfi srfi-26))

1
build-aux/hydra/gnu-system.scm
View File

@ -53,6 +53,7 @@
(gnu packages compression) (gnu packages compression)
(gnu packages multiprecision) (gnu packages multiprecision)
(gnu packages make-bootstrap) (gnu packages make-bootstrap)
(gnu packages commencement)
(gnu system) (gnu system)
(gnu system vm) (gnu system vm)
(gnu system install) (gnu system install)

6
doc/guix.texi
View File

@ -4131,9 +4131,9 @@ the GNU Build System: Guile, Bash, Coreutils, etc.
And voilà! At this point we have the complete set of build tools that And voilà! At this point we have the complete set of build tools that
the GNU Build System expects. These are in the @code{%final-inputs} the GNU Build System expects. These are in the @code{%final-inputs}
variables of the @code{(gnu packages base)} module, and are implicitly variable of the @code{(gnu packages commencement)} module, and are
used by any package that uses @code{gnu-build-system} (@pxref{Defining implicitly used by any package that uses @code{gnu-build-system}
Packages}). (@pxref{Defining Packages}).
@unnumberedsubsec Building the Bootstrap Binaries @unnumberedsubsec Building the Bootstrap Binaries

4
gnu-system.am
View File

@ -54,6 +54,7 @@ GNU_SYSTEM_MODULES = \
gnu/packages/cflow.scm \ gnu/packages/cflow.scm \
gnu/packages/check.scm \ gnu/packages/check.scm \
gnu/packages/cmake.scm \ gnu/packages/cmake.scm \
gnu/packages/commencement.scm \
gnu/packages/compression.scm \ gnu/packages/compression.scm \
gnu/packages/complexity.scm \ gnu/packages/complexity.scm \
gnu/packages/conkeror.scm \ gnu/packages/conkeror.scm \
@ -233,9 +234,10 @@ GNU_SYSTEM_MODULES = \
gnu/packages/time.scm \ gnu/packages/time.scm \
gnu/packages/tmux.scm \ gnu/packages/tmux.scm \
gnu/packages/tor.scm \ gnu/packages/tor.scm \
gnu/packages/uucp.scm \ gnu/packages/unclutter.scm \
gnu/packages/unrtf.scm \ gnu/packages/unrtf.scm \
gnu/packages/upnp.scm \ gnu/packages/upnp.scm \
gnu/packages/uucp.scm \
gnu/packages/valgrind.scm \ gnu/packages/valgrind.scm \
gnu/packages/version-control.scm \ gnu/packages/version-control.scm \
gnu/packages/video.scm \ gnu/packages/video.scm \

732
gnu/packages/base.scm
View File

@ -25,12 +25,6 @@
#:use-module (gnu packages) #:use-module (gnu packages)
#:use-module (gnu packages acl) #:use-module (gnu packages acl)
#:use-module (gnu packages bash) #:use-module (gnu packages bash)
#:use-module (gnu packages bootstrap)
#:use-module (gnu packages compression)
#:use-module (gnu packages gcc)
#:use-module (gnu packages ed)
#:use-module (gnu packages file)
#:use-module (gnu packages gawk)
#:use-module (gnu packages guile) #:use-module (gnu packages guile)
#:use-module (gnu packages multiprecision) #:use-module (gnu packages multiprecision)
#:use-module (gnu packages perl) #:use-module (gnu packages perl)
@ -39,13 +33,7 @@
#:use-module (gnu packages pkg-config) #:use-module (gnu packages pkg-config)
#:use-module (guix packages) #:use-module (guix packages)
#:use-module (guix download) #:use-module (guix download)
#:use-module (guix build-system gnu) #: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 vlist)
#:use-module (ice-9 match))
;;; Commentary: ;;; Commentary:
;;; ;;;
@ -578,718 +566,10 @@ reflect changes made by political bodies to time zone boundaries, UTC offsets,
and daylight-saving rules.") and daylight-saving rules.")
(license public-domain))) (license public-domain)))
(define-public (canonical-package package)
;;; ;; Avoid circular dependency by lazily resolving 'commencement'.
;;; Bootstrap packages. (let* ((iface (resolve-interface '(gnu packages commencement)))
;;; (proc (module-ref iface 'canonical-package)))
(proc package)))
(define gnu-make-boot0
(package-with-bootstrap-guile
(package (inherit gnu-make)
(name "make-boot0")
(location (source-properties->location (current-source-location)))
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:tests? #f ; cannot run "make check"
,@(substitute-keyword-arguments (package-arguments gnu-make)
((#:phases phases)
`(alist-replace
'build (lambda _
;; Don't attempt to build 'guile.c' since we don't
;; have Guile here.
(substitute* "build.sh"
(("guile\\.\\$\\{OBJEXT\\}") ""))
(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-p bin)
(copy-file "make"
(string-append bin "/make"))))
,phases))))))
(native-inputs '()) ; no need for 'pkg-config'
(inputs %bootstrap-inputs))))
(define diffutils-boot0
(package-with-bootstrap-guile
(let ((p (package-with-explicit-inputs diffutils
`(("make" ,gnu-make-boot0)
,@%bootstrap-inputs)
#:guile %bootstrap-guile)))
(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-bootstrap-guile
(package-with-explicit-inputs findutils
`(("make" ,gnu-make-boot0)
("diffutils" ,diffutils-boot0) ; for tests
,@%bootstrap-inputs)
(current-source-location)
#:guile %bootstrap-guile)))
(define file-boot0
(package-with-bootstrap-guile
(package-with-explicit-inputs file
`(("make" ,gnu-make-boot0)
,@%bootstrap-inputs)
(current-source-location)
#:guile %bootstrap-guile)))
(define %boot0-inputs
`(("make" ,gnu-make-boot0)
("diffutils" ,diffutils-boot0)
("findutils" ,findutils-boot0)
("file" ,file-boot0)
,@%bootstrap-inputs))
(define* (nix-system->gnu-triplet
#:optional (system (%current-system)) (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 #:optional (system (%current-system)))
;; Return the triplet used to create the cross toolchain needed in the
;; first bootstrapping stage.
(nix-system->gnu-triplet system "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-with-bootstrap-guile
(package (inherit binutils)
(name "binutils-cross-boot0")
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
,@(substitute-keyword-arguments (package-arguments binutils)
((#:configure-flags cf)
`(cons ,(string-append "--target=" (boot-triplet))
,cf)))))
(inputs %boot0-inputs))))
(define gcc-boot0
(package-with-bootstrap-guile
(package (inherit gcc-4.8)
(name "gcc-cross-boot0")
(arguments
`(#:guile ,%bootstrap-guile
#: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.8)
((#:configure-flags flags)
`(append (list ,(string-append "--target=" (boot-triplet))
;; No libc yet.
"--without-headers"
;; Disable features not needed at this stage.
"--disable-shared"
"--enable-languages=c,c++"
;; libstdc++ cannot be built at this stage
;; ("Link tests are not allowed after
;; GCC_NO_EXECUTABLES.").
"--disable-libstdc++-v3"
"--disable-threads"
"--disable-libmudflap"
"--disable-libatomic"
"--disable-libsanitizer"
"--disable-libitm"
"--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-x.y.z'.
,@(map (lambda (lib)
;; Drop trailing letters, as gmp-6.0.0a unpacks
;; into gmp-6.0.0.
`(symlink ,(string-trim-right
(package-full-name lib)
char-set:letter)
,(package-name lib)))
(list gmp mpfr mpc))))
(alist-cons-after
'install 'symlink-libgcc_eh
(lambda* (#:key outputs #:allow-other-keys)
(let ((out (assoc-ref outputs "lib")))
;; Glibc wants to link against libgcc_eh, so provide
;; it.
(with-directory-excursion
(string-append out "/lib/gcc/"
,(boot-triplet)
"/" ,(package-version gcc-4.8))
(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)))
;; No need for Texinfo at this stage.
(native-inputs (alist-delete "texinfo"
(package-native-inputs gcc-4.8))))))
(define perl-boot0
(package-with-bootstrap-guile
(package-with-explicit-inputs perl
%boot0-inputs
(current-source-location)
#:guile %bootstrap-guile)))
(define (linux-libre-headers-boot0)
"Return Linux-Libre header files for the bootstrap environment."
;; Note: this is wrapped in a thunk to nicely handle circular dependencies
;; between (gnu packages linux) and this module.
(package-with-bootstrap-guile
(package (inherit linux-libre-headers)
(arguments `(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
,@(package-arguments linux-libre-headers)))
(native-inputs
`(("perl" ,perl-boot0)
,@%boot0-inputs)))))
(define texinfo-boot0
;; Texinfo used to build libc's manual.
;; We build without ncurses because it fails to build at this stage, and
;; because we don't need the stand-alone Info reader.
;; Also, use %BOOT0-INPUTS to avoid building Perl once more.
(let ((texinfo (package (inherit texinfo)
(inputs (alist-delete "ncurses" (package-inputs texinfo))))))
(package-with-bootstrap-guile
(package-with-explicit-inputs texinfo %boot0-inputs
(current-source-location)
#:guile %bootstrap-guile))))
(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 glibc-final-with-bootstrap-bash
;; The final libc, "cross-built". If everything went well, the resulting
;; store path has no dependencies. Actually, the really-final libc is
;; built just below; the only difference is that this one uses the
;; bootstrap Bash.
(package-with-bootstrap-guile
(package (inherit glibc)
(name "glibc-intermediate")
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
,@(substitute-keyword-arguments (package-arguments glibc)
((#:configure-flags flags)
`(append (list ,(string-append "--host=" (boot-triplet))
,(string-append "--build="
(nix-system->gnu-triplet))
;; Build Sun/ONC RPC support. In particular,
;; install rpc/*.h.
"--enable-obsolete-rpc")
,flags))
((#:phases phases)
`(alist-cons-before
'configure 'pre-configure
(lambda* (#:key inputs #:allow-other-keys)
;; Don't clobber CPATH with the bootstrap libc.
(setenv "NATIVE_CPATH" (getenv "CPATH"))
(unsetenv "CPATH")
;; 'rpcgen' needs native libc headers to be built.
(substitute* "sunrpc/Makefile"
(("sunrpc-CPPFLAGS =.*" all)
(string-append "CPATH = $(NATIVE_CPATH)\n"
"export CPATH\n"
all "\n"))))
,phases)))))
(propagated-inputs `(("linux-headers" ,(linux-libre-headers-boot0))))
(native-inputs
`(("texinfo" ,texinfo-boot0)
("perl" ,perl-boot0)))
(inputs
`(;; The boot inputs. That includes the bootstrap libc. We don't want
;; it in $CPATH, hence the 'pre-configure' phase above.
,@%boot1-inputs
;; A native GCC is needed to build `cross-rpcgen'.
("native-gcc" ,@(assoc-ref %boot0-inputs "gcc"))
;; Here, we use the bootstrap Bash, which is not satisfactory
;; because we don't want to depend on bootstrap tools.
("static-bash" ,@(assoc-ref %boot0-inputs "bash")))))))
(define (cross-gcc-wrapper gcc binutils glibc bash)
"Return a wrapper for the pseudo-cross toolchain GCC/BINUTILS/GLIBC
that makes it available under the native tool names."
(package (inherit gcc-4.8)
(name (string-append (package-name gcc) "-wrapped"))
(source #f)
(build-system trivial-build-system)
(outputs '("out"))
(arguments
`(#:guile ,%bootstrap-guile
#: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"))
(bash (assoc-ref %build-inputs "bash"))
(out (assoc-ref %outputs "out"))
(bindir (string-append out "/bin"))
(triplet ,(boot-triplet)))
(define (wrap-program program)
;; 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 program
(lambda (p)
(format p "#!~a/bin/bash
exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
bash
gcc triplet program
libc libc
,(glibc-dynamic-linker))))
(chmod program #o555))
(mkdir-p bindir)
(with-directory-excursion bindir
(for-each (lambda (tool)
(symlink (string-append binutils "/bin/"
triplet "-" tool)
tool))
'("ar" "ranlib"))
(for-each wrap-program '("gcc" "g++")))))))
(native-inputs
`(("binutils" ,binutils)
("gcc" ,gcc)
("libc" ,glibc)
("bash" ,bash)))
(inputs '())))
(define static-bash-for-glibc
;; A statically-linked Bash to be embedded in GLIBC-FINAL, for use by
;; system(3) & co.
(let* ((gcc (cross-gcc-wrapper gcc-boot0 binutils-boot0
glibc-final-with-bootstrap-bash
(car (assoc-ref %boot1-inputs "bash"))))
(bash (package (inherit bash-light)
(arguments
`(#:guile ,%bootstrap-guile
,@(package-arguments bash-light))))))
(package-with-bootstrap-guile
(package-with-explicit-inputs (static-package bash)
`(("gcc" ,gcc)
("libc" ,glibc-final-with-bootstrap-bash)
,@(fold alist-delete %boot1-inputs
'("gcc" "libc")))
(current-source-location)))))
(define-public glibc-final
;; The final glibc, which embeds the statically-linked Bash built above.
(package (inherit glibc-final-with-bootstrap-bash)
(name "glibc")
(inputs `(("static-bash" ,static-bash-for-glibc)
,@(alist-delete
"static-bash"
(package-inputs glibc-final-with-bootstrap-bash))))
;; The final libc only refers to itself, but the 'debug' output contains
;; references to GCC-BOOT0 and to the Linux headers. XXX: Would be great
;; if 'allowed-references' were per-output.
(arguments
`(#:allowed-references
,(cons* `(,gcc-boot0 "lib") (linux-libre-headers-boot0)
(package-outputs glibc-final-with-bootstrap-bash))
,@(package-arguments glibc-final-with-bootstrap-bash)))))
(define gcc-boot0-wrapped
;; Make the cross-tools GCC-BOOT0 and BINUTILS-BOOT0 available under the
;; non-cross names.
(cross-gcc-wrapper gcc-boot0 binutils-boot0 glibc-final
(car (assoc-ref %boot1-inputs "bash"))))
(define %boot2-inputs
;; 3rd stage inputs.
`(("libc" ,glibc-final)
("gcc" ,gcc-boot0-wrapped)
,@(fold alist-delete %boot1-inputs '("libc" "gcc"))))
(define binutils-final
(package-with-bootstrap-guile
(package (inherit binutils)
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:allowed-references ("out" ,glibc-final)
,@(package-arguments binutils)))
(inputs %boot2-inputs))))
(define libstdc++
;; Intermediate libstdc++ that will allow us to build the final GCC
;; (remember that GCC-BOOT0 cannot build libstdc++.)
(package-with-bootstrap-guile
(package (inherit gcc-4.8)
(name "libstdc++")
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:out-of-source? #t
#:phases (alist-cons-before
'configure 'chdir
(lambda _
(chdir "libstdc++-v3"))
%standard-phases)
#:configure-flags `("--disable-shared"
"--disable-libstdcxx-threads"
"--disable-libstdcxx-pch"
,(string-append "--with-gxx-include-dir="
(assoc-ref %outputs "out")
"/include"
;; "/include/c++/"
;; ,(package-version gcc-4.8)
))))
(outputs '("out"))
(inputs %boot2-inputs)
(native-inputs '())
(propagated-inputs '())
(synopsis "GNU C++ standard library (intermediate)"))))
(define-public gcc-final
;; The final GCC.
(package (inherit gcc-boot0)
(name "gcc")
(location (source-properties->location (current-source-location)))
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:allowed-references ("out" "lib" ,glibc-final)
;; 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)
((#:configure-flags boot-flags)
(let loop ((args (package-arguments gcc-4.8)))
(match args
((#:configure-flags normal-flags _ ...)
normal-flags)
((_ rest ...)
(loop rest)))))
((#:make-flags flags)
;; Since $LIBRARY_PATH and $CPATH are not honored, add the
;; relevant flags.
`(cons (string-append "CPPFLAGS=-I"
(assoc-ref %build-inputs "libstdc++")
"/include")
(map (lambda (flag)
(if (string-prefix? "LDFLAGS=" flag)
(string-append flag " -L"
(assoc-ref %build-inputs "libstdc++")
"/lib")
flag))
,flags)))
((#:phases phases)
`(alist-delete 'symlink-libgcc_eh ,phases)))))
;; This time we want Texinfo, so we get the manual.
(native-inputs `(("texinfo" ,texinfo-boot0)
,@(package-native-inputs gcc-boot0)))
(inputs `(("gmp-source" ,(package-source gmp))
("mpfr-source" ,(package-source mpfr))
("mpc-source" ,(package-source mpc))
("binutils" ,binutils-final)
("libstdc++" ,libstdc++)
,@%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" ,%bootstrap-guile)
("bash" ,@(assoc-ref %boot2-inputs "bash"))
("wrapper" ,(search-path %load-path
"gnu/packages/ld-wrapper.scm"))))
(arguments
`(#:guile ,%bootstrap-guile
#: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-p bin)
(copy-file (assoc-ref %build-inputs "wrapper") ld)
(substitute* ld
(("@GUILE@")
(string-append (assoc-ref %build-inputs "guile")
"/bin/guile"))
(("@BASH@")
(string-append (assoc-ref %build-inputs "bash")
"/bin/bash"))
(("@LD@")
(string-append (assoc-ref %build-inputs "binutils")
"/bin/ld")))
(chmod ld #o555)
(compile-file ld #:output-file go)))))
(synopsis "The linker wrapper")
(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 gpl3+)))
(define %boot3-inputs
;; 4th stage inputs.
`(("gcc" ,gcc-final)
("ld-wrapper" ,ld-wrapper-boot3)
,@(alist-delete "gcc" %boot2-inputs)))
(define bash-final
;; Link with `-static-libgcc' to make sure we don't retain a reference
;; to the bootstrap GCC.
(package-with-bootstrap-guile
(package-with-explicit-inputs (static-libgcc-package bash)
%boot3-inputs
(current-source-location)
#:guile %bootstrap-guile)))
(define %boot4-inputs
;; Now use the final Bash.
`(("bash" ,bash-final)
,@(alist-delete "bash" %boot3-inputs)))
(define-public guile-final
(package-with-bootstrap-guile
(package-with-explicit-inputs guile-2.0/fixed
%boot4-inputs
(current-source-location)
#:guile %bootstrap-guile)))
(define gnu-make-final
;; The final GNU Make, which uses the final Guile.
(package-with-bootstrap-guile
(package-with-explicit-inputs gnu-make
`(("guile" ,guile-final)
,@%boot4-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)
("bash" ,bash-final)
,@(fold alist-delete (package-inputs ld-wrapper-boot3)
'("guile" "bash"))))))
(define coreutils-final
;; The final Coreutils. Treat them specially because some packages, such as
;; Findutils, keep a reference to the Coreutils they were built with.
(package-with-bootstrap-guile
(package-with-explicit-inputs coreutils
%boot4-inputs
(current-source-location)
;; Use the final Guile, linked against the
;; final libc with working iconv, so that
;; 'substitute*' works well when touching
;; test files in Gettext.
#:guile guile-final)))
(define grep-final
;; The final grep. Gzip holds a reference to it (via zgrep), so it must be
;; built before gzip.
(package-with-bootstrap-guile
(package-with-explicit-inputs grep
%boot4-inputs
(current-source-location)
#:guile guile-final)))
(define %boot5-inputs
;; Now use the final Coreutils.
`(("coreutils" ,coreutils-final)
("grep" ,grep-final)
,@%boot4-inputs))
(define-public %final-inputs
;; Final derivations used as implicit inputs by 'gnu-build-system'. We
;; still use 'package-with-bootstrap-guile' so that the bootstrap tools are
;; used for origins that have patches, thereby avoiding circular
;; dependencies.
(let ((finalize (compose package-with-bootstrap-guile
(cut package-with-explicit-inputs <> %boot5-inputs
(current-source-location)))))
`(,@(map (match-lambda
((name package)
(list name (finalize package))))
`(("tar" ,tar)
("gzip" ,gzip)
("bzip2" ,bzip2)
("xz" ,xz)
("file" ,file)
("diffutils" ,diffutils)
("patch" ,patch)
("sed" ,sed)
("findutils" ,findutils)
("gawk" ,gawk)))
("grep" ,grep-final)
("coreutils" ,coreutils-final)
("make" ,gnu-make-final)
("bash" ,bash-final)
("ld-wrapper" ,ld-wrapper)
("binutils" ,binutils-final)
("gcc" ,gcc-final)
("libc" ,glibc-final))))
(define-public canonical-package
(let ((name->package (fold (lambda (input result)
(match input
((_ package)
(vhash-cons (package-full-name package)
package result))))
vlist-null
`(("guile" ,guile-final)
,@%final-inputs))))
(lambda (package)
"Return the 'canonical' variant of PACKAGE---i.e., if PACKAGE is one of
the implicit inputs of 'gnu-build-system', return that one, otherwise return
PACKAGE.
The goal is to avoid duplication in cases like GUILE-FINAL vs. GUILE-2.0,
COREUTILS-FINAL vs. COREUTILS, etc."
;; XXX: This doesn't handle dependencies of the final inputs, such as
;; libunistring, GMP, etc.
(match (vhash-assoc (package-full-name package) name->package)
((_ . canon)
;; In general we want CANON, except if we're cross-compiling: CANON
;; uses explicit inputs, so it is "anchored" in the bootstrapped
;; process, with dependencies on things that cannot be
;; cross-compiled.
(if (%current-target-system)
package
canon))
(_ package)))))
;;;
;;; GCC toolchain.
;;;
(define (gcc-toolchain gcc)
"Return a complete toolchain for GCC."
(package
(name "gcc-toolchain")
(version (package-version gcc))
(source #f)
(build-system trivial-build-system)
(arguments
'(#:modules ((guix build union))
#:builder (begin
(use-modules (ice-9 match)
(guix build union))
(match %build-inputs
(((names . directories) ...)
(union-build (assoc-ref %outputs "out")
directories)))
(union-build (assoc-ref %outputs "debug")
(list (assoc-ref %build-inputs
"libc-debug"))))))
(license (package-license gcc))
(synopsis "Complete GCC tool chain for C/C++ development")
(description
"This package provides a complete GCC tool chain for C/C++ development to
be installed in user profiles. This includes GCC, as well as libc (headers
and binaries, plus debugging symbols in the 'debug' output), and Binutils.")
(home-page "http://gcc.gnu.org/")
(outputs '("out" "debug"))
;; The main raison d'être of this "meta-package" is (1) to conveniently
;; install everything that we need, and (2) to make sure ld-wrapper comes
;; before Binutils' ld in the user's profile.
(inputs `(("gcc" ,gcc)
("ld-wrapper" ,(car (assoc-ref %final-inputs "ld-wrapper")))
("binutils" ,binutils-final)
("libc" ,glibc-final)
("libc-debug" ,glibc-final "debug")))))
(define-public gcc-toolchain-4.8
(gcc-toolchain gcc-final))
(define-public gcc-toolchain-4.9
(gcc-toolchain gcc-4.9))
;;; base.scm ends here ;;; base.scm ends here

13
gnu/packages/bison.scm
View File

@ -51,3 +51,16 @@ deterministic or generalized LR parser from an annotated, context-free
grammar. It is versatile enough to have many applications, from parsers for grammar. It is versatile enough to have many applications, from parsers for
simple tools through complex programming languages.") simple tools through complex programming languages.")
(license gpl3+))) (license gpl3+)))
(define-public bison-2.7
(package (inherit bison)
(version "2.7")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://gnu/bison/bison-"
version ".tar.xz"))
(sha256
(base32
"1zd77ilmpv5mi3kr55jrj6ncqlcnyhpianhrwzak2q28cv2cbn23"))))))

771
gnu/packages/commencement.scm Normal file
View File

@ -0,0 +1,771 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2012, 2013, 2014 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2014 Andreas Enge <andreas@enge.fr>
;;; Copyright © 2012 Nikita Karetnikov <nikita@karetnikov.org>
;;; Copyright © 2014 Mark H Weaver <mhw@netris.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 commencement)
#:use-module ((guix licenses)
#:select (gpl3+ lgpl2.0+ public-domain))
#:use-module (gnu packages bootstrap)
#:use-module (gnu packages base)
#:use-module (gnu packages bash)
#:use-module (gnu packages gcc)
#:use-module (gnu packages ed)
#:use-module (gnu packages file)
#:use-module (gnu packages gawk)
#:use-module (gnu packages guile)
#:use-module (gnu packages multiprecision)
#:use-module (gnu packages compression)
#:use-module (gnu packages perl)
#:use-module (gnu packages linux)
#:use-module (gnu packages texinfo)
#:use-module (gnu packages pkg-config)
#:use-module (guix packages)
#:use-module (guix download)
#: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 vlist)
#:use-module (ice-9 match))
;;; Commentary:
;;;
;;; This is the commencement, this is where things start. Before the
;;; commencement, of course, there's the 'bootstrap' module, which provides us
;;; with the initial binaries. This module uses those bootstrap binaries to
;;; actually build up the whole tool chain that make up the implicit inputs of
;;; 'gnu-build-system'.
;;;
;;; To avoid circular dependencies, this module should not be imported
;;; directly from anywhere.
;;;
;;; Code:
(define gnu-make-boot0
(package-with-bootstrap-guile
(package (inherit gnu-make)
(name "make-boot0")
(location (source-properties->location (current-source-location)))
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:tests? #f ; cannot run "make check"
,@(substitute-keyword-arguments (package-arguments gnu-make)
((#:phases phases)
`(alist-replace
'build (lambda _
;; Don't attempt to build 'guile.c' since we don't
;; have Guile here.
(substitute* "build.sh"
(("guile\\.\\$\\{OBJEXT\\}") ""))
(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-p bin)
(copy-file "make"
(string-append bin "/make"))))
,phases))))))
(native-inputs '()) ; no need for 'pkg-config'
(inputs %bootstrap-inputs))))
(define diffutils-boot0
(package-with-bootstrap-guile
(let ((p (package-with-explicit-inputs diffutils
`(("make" ,gnu-make-boot0)
,@%bootstrap-inputs)
#:guile %bootstrap-guile)))
(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-bootstrap-guile
(package-with-explicit-inputs findutils
`(("make" ,gnu-make-boot0)
("diffutils" ,diffutils-boot0) ; for tests
,@%bootstrap-inputs)
(current-source-location)
#:guile %bootstrap-guile)))
(define file-boot0
(package-with-bootstrap-guile
(package-with-explicit-inputs file
`(("make" ,gnu-make-boot0)
,@%bootstrap-inputs)
(current-source-location)
#:guile %bootstrap-guile)))
(define %boot0-inputs
`(("make" ,gnu-make-boot0)
("diffutils" ,diffutils-boot0)
("findutils" ,findutils-boot0)
("file" ,file-boot0)
,@%bootstrap-inputs))
(define* (nix-system->gnu-triplet
#:optional (system (%current-system)) (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 #:optional (system (%current-system)))
;; Return the triplet used to create the cross toolchain needed in the
;; first bootstrapping stage.
(nix-system->gnu-triplet system "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-with-bootstrap-guile
(package (inherit binutils)
(name "binutils-cross-boot0")
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
,@(substitute-keyword-arguments (package-arguments binutils)
((#:configure-flags cf)
`(cons ,(string-append "--target=" (boot-triplet))
,cf)))))
(inputs %boot0-inputs))))
(define gcc-boot0
(package-with-bootstrap-guile
(package (inherit gcc-4.8)
(name "gcc-cross-boot0")
(arguments
`(#:guile ,%bootstrap-guile
#: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.8)
((#:configure-flags flags)
`(append (list ,(string-append "--target=" (boot-triplet))
;; No libc yet.
"--without-headers"
;; Disable features not needed at this stage.
"--disable-shared"
"--enable-languages=c,c++"
;; libstdc++ cannot be built at this stage
;; ("Link tests are not allowed after
;; GCC_NO_EXECUTABLES.").
"--disable-libstdc++-v3"
"--disable-threads"
"--disable-libmudflap"
"--disable-libatomic"
"--disable-libsanitizer"
"--disable-libitm"
"--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-x.y.z'.
,@(map (lambda (lib)
;; Drop trailing letters, as gmp-6.0.0a unpacks
;; into gmp-6.0.0.
`(symlink ,(string-trim-right
(package-full-name lib)
char-set:letter)
,(package-name lib)))
(list gmp mpfr mpc))))
(alist-cons-after
'install 'symlink-libgcc_eh
(lambda* (#:key outputs #:allow-other-keys)
(let ((out (assoc-ref outputs "lib")))
;; Glibc wants to link against libgcc_eh, so provide
;; it.
(with-directory-excursion
(string-append out "/lib/gcc/"
,(boot-triplet)
"/" ,(package-version gcc-4.8))
(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)))
;; No need for Texinfo at this stage.
(native-inputs (alist-delete "texinfo"
(package-native-inputs gcc-4.8))))))
(define perl-boot0
(package-with-bootstrap-guile
(package-with-explicit-inputs perl
%boot0-inputs
(current-source-location)
#:guile %bootstrap-guile)))
(define (linux-libre-headers-boot0)
"Return Linux-Libre header files for the bootstrap environment."
;; Note: this is wrapped in a thunk to nicely handle circular dependencies
;; between (gnu packages linux) and this module.
(package-with-bootstrap-guile
(package (inherit linux-libre-headers)
(arguments `(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
,@(package-arguments linux-libre-headers)))
(native-inputs
`(("perl" ,perl-boot0)
,@%boot0-inputs)))))
(define texinfo-boot0
;; Texinfo used to build libc's manual.
;; We build without ncurses because it fails to build at this stage, and
;; because we don't need the stand-alone Info reader.
;; Also, use %BOOT0-INPUTS to avoid building Perl once more.
(let ((texinfo (package (inherit texinfo)
(inputs (alist-delete "ncurses" (package-inputs texinfo))))))
(package-with-bootstrap-guile
(package-with-explicit-inputs texinfo %boot0-inputs
(current-source-location)
#:guile %bootstrap-guile))))
(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 glibc-final-with-bootstrap-bash
;; The final libc, "cross-built". If everything went well, the resulting
;; store path has no dependencies. Actually, the really-final libc is
;; built just below; the only difference is that this one uses the
;; bootstrap Bash.
(package-with-bootstrap-guile
(package (inherit glibc)
(name "glibc-intermediate")
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
,@(substitute-keyword-arguments (package-arguments glibc)
((#:configure-flags flags)
`(append (list ,(string-append "--host=" (boot-triplet))
,(string-append "--build="
(nix-system->gnu-triplet))
;; Build Sun/ONC RPC support. In particular,
;; install rpc/*.h.
"--enable-obsolete-rpc")
,flags))
((#:phases phases)
`(alist-cons-before
'configure 'pre-configure
(lambda* (#:key inputs #:allow-other-keys)
;; Don't clobber CPATH with the bootstrap libc.
(setenv "NATIVE_CPATH" (getenv "CPATH"))
(unsetenv "CPATH")
;; 'rpcgen' needs native libc headers to be built.
(substitute* "sunrpc/Makefile"
(("sunrpc-CPPFLAGS =.*" all)
(string-append "CPATH = $(NATIVE_CPATH)\n"
"export CPATH\n"
all "\n"))))
,phases)))))
(propagated-inputs `(("linux-headers" ,(linux-libre-headers-boot0))))
(native-inputs
`(("texinfo" ,texinfo-boot0)
("perl" ,perl-boot0)))
(inputs
`(;; The boot inputs. That includes the bootstrap libc. We don't want
;; it in $CPATH, hence the 'pre-configure' phase above.
,@%boot1-inputs
;; A native GCC is needed to build `cross-rpcgen'.
("native-gcc" ,@(assoc-ref %boot0-inputs "gcc"))
;; Here, we use the bootstrap Bash, which is not satisfactory
;; because we don't want to depend on bootstrap tools.
("static-bash" ,@(assoc-ref %boot0-inputs "bash")))))))
(define (cross-gcc-wrapper gcc binutils glibc bash)
"Return a wrapper for the pseudo-cross toolchain GCC/BINUTILS/GLIBC
that makes it available under the native tool names."
(package (inherit gcc-4.8)
(name (string-append (package-name gcc) "-wrapped"))
(source #f)
(build-system trivial-build-system)
(outputs '("out"))
(arguments
`(#:guile ,%bootstrap-guile
#: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"))
(bash (assoc-ref %build-inputs "bash"))
(out (assoc-ref %outputs "out"))
(bindir (string-append out "/bin"))
(triplet ,(boot-triplet)))
(define (wrap-program program)
;; 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 program
(lambda (p)
(format p "#!~a/bin/bash
exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
bash
gcc triplet program
libc libc
,(glibc-dynamic-linker))))
(chmod program #o555))
(mkdir-p bindir)
(with-directory-excursion bindir
(for-each (lambda (tool)
(symlink (string-append binutils "/bin/"
triplet "-" tool)
tool))
'("ar" "ranlib"))
(for-each wrap-program '("gcc" "g++")))))))
(native-inputs
`(("binutils" ,binutils)
("gcc" ,gcc)
("libc" ,glibc)
("bash" ,bash)))
(inputs '())))
(define static-bash-for-glibc
;; A statically-linked Bash to be embedded in GLIBC-FINAL, for use by
;; system(3) & co.
(let* ((gcc (cross-gcc-wrapper gcc-boot0 binutils-boot0
glibc-final-with-bootstrap-bash
(car (assoc-ref %boot1-inputs "bash"))))
(bash (package (inherit bash-light)
(arguments
`(#:guile ,%bootstrap-guile
,@(package-arguments bash-light))))))
(package-with-bootstrap-guile
(package-with-explicit-inputs (static-package bash)
`(("gcc" ,gcc)
("libc" ,glibc-final-with-bootstrap-bash)
,@(fold alist-delete %boot1-inputs
'("gcc" "libc")))
(current-source-location)))))
(define-public glibc-final
;; The final glibc, which embeds the statically-linked Bash built above.
(package (inherit glibc-final-with-bootstrap-bash)
(name "glibc")
(inputs `(("static-bash" ,static-bash-for-glibc)
,@(alist-delete
"static-bash"
(package-inputs glibc-final-with-bootstrap-bash))))
;; The final libc only refers to itself, but the 'debug' output contains
;; references to GCC-BOOT0 and to the Linux headers. XXX: Would be great
;; if 'allowed-references' were per-output.
(arguments
`(#:allowed-references
,(cons* `(,gcc-boot0 "lib") (linux-libre-headers-boot0)
(package-outputs glibc-final-with-bootstrap-bash))
,@(package-arguments glibc-final-with-bootstrap-bash)))))
(define gcc-boot0-wrapped
;; Make the cross-tools GCC-BOOT0 and BINUTILS-BOOT0 available under the
;; non-cross names.
(cross-gcc-wrapper gcc-boot0 binutils-boot0 glibc-final
(car (assoc-ref %boot1-inputs "bash"))))
(define %boot2-inputs
;; 3rd stage inputs.
`(("libc" ,glibc-final)
("gcc" ,gcc-boot0-wrapped)
,@(fold alist-delete %boot1-inputs '("libc" "gcc"))))
(define binutils-final
(package-with-bootstrap-guile
(package (inherit binutils)
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:allowed-references ("out" ,glibc-final)
,@(package-arguments binutils)))
(inputs %boot2-inputs))))
(define libstdc++
;; Intermediate libstdc++ that will allow us to build the final GCC
;; (remember that GCC-BOOT0 cannot build libstdc++.)
(package-with-bootstrap-guile
(package (inherit gcc-4.8)
(name "libstdc++")
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:out-of-source? #t
#:phases (alist-cons-before
'configure 'chdir
(lambda _
(chdir "libstdc++-v3"))
%standard-phases)
#:configure-flags `("--disable-shared"
"--disable-libstdcxx-threads"
"--disable-libstdcxx-pch"
,(string-append "--with-gxx-include-dir="
(assoc-ref %outputs "out")
"/include"
;; "/include/c++/"
;; ,(package-version gcc-4.8)
))))
(outputs '("out"))
(inputs %boot2-inputs)
(native-inputs '())
(propagated-inputs '())
(synopsis "GNU C++ standard library (intermediate)"))))
(define-public gcc-final
;; The final GCC.
(package (inherit gcc-boot0)
(name "gcc")
(location (source-properties->location (current-source-location)))
(arguments
`(#:guile ,%bootstrap-guile
#:implicit-inputs? #f
#:allowed-references ("out" "lib" ,glibc-final)
;; 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)
((#:configure-flags boot-flags)
(let loop ((args (package-arguments gcc-4.8)))
(match args
((#:configure-flags normal-flags _ ...)
normal-flags)
((_ rest ...)
(loop rest)))))
((#:make-flags flags)
;; Since $LIBRARY_PATH and $CPATH are not honored, add the
;; relevant flags.
`(cons (string-append "CPPFLAGS=-I"
(assoc-ref %build-inputs "libstdc++")
"/include")
(map (lambda (flag)
(if (string-prefix? "LDFLAGS=" flag)
(string-append flag " -L"
(assoc-ref %build-inputs "libstdc++")
"/lib")
flag))
,flags)))
((#:phases phases)
`(alist-delete 'symlink-libgcc_eh ,phases)))))
;; This time we want Texinfo, so we get the manual.
(native-inputs `(("texinfo" ,texinfo-boot0)
,@(package-native-inputs gcc-boot0)))
(inputs `(("gmp-source" ,(package-source gmp))
("mpfr-source" ,(package-source mpfr))
("mpc-source" ,(package-source mpc))
("binutils" ,binutils-final)
("libstdc++" ,libstdc++)
,@%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" ,%bootstrap-guile)
("bash" ,@(assoc-ref %boot2-inputs "bash"))
("wrapper" ,(search-path %load-path
"gnu/packages/ld-wrapper.scm"))))
(arguments
`(#:guile ,%bootstrap-guile
#: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-p bin)
(copy-file (assoc-ref %build-inputs "wrapper") ld)
(substitute* ld
(("@GUILE@")
(string-append (assoc-ref %build-inputs "guile")
"/bin/guile"))
(("@BASH@")
(string-append (assoc-ref %build-inputs "bash")
"/bin/bash"))
(("@LD@")
(string-append (assoc-ref %build-inputs "binutils")
"/bin/ld")))
(chmod ld #o555)
(compile-file ld #:output-file go)))))
(synopsis "The linker wrapper")
(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 gpl3+)))
(define %boot3-inputs
;; 4th stage inputs.
`(("gcc" ,gcc-final)
("ld-wrapper" ,ld-wrapper-boot3)
,@(alist-delete "gcc" %boot2-inputs)))
(define bash-final
;; Link with `-static-libgcc' to make sure we don't retain a reference
;; to the bootstrap GCC.
(package-with-bootstrap-guile
(package-with-explicit-inputs (static-libgcc-package bash)
%boot3-inputs
(current-source-location)
#:guile %bootstrap-guile)))
(define %boot4-inputs
;; Now use the final Bash.
`(("bash" ,bash-final)
,@(alist-delete "bash" %boot3-inputs)))
(define-public guile-final
(package-with-bootstrap-guile
(package-with-explicit-inputs guile-2.0/fixed
%boot4-inputs
(current-source-location)
#:guile %bootstrap-guile)))
(define gnu-make-final
;; The final GNU Make, which uses the final Guile.
(package-with-bootstrap-guile
(package-with-explicit-inputs gnu-make
`(("guile" ,guile-final)
,@%boot4-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)
("bash" ,bash-final)
,@(fold alist-delete (package-inputs ld-wrapper-boot3)
'("guile" "bash"))))))
(define coreutils-final
;; The final Coreutils. Treat them specially because some packages, such as
;; Findutils, keep a reference to the Coreutils they were built with.
(package-with-bootstrap-guile
(package-with-explicit-inputs coreutils
%boot4-inputs
(current-source-location)
;; Use the final Guile, linked against the
;; final libc with working iconv, so that
;; 'substitute*' works well when touching
;; test files in Gettext.
#:guile guile-final)))
(define grep-final
;; The final grep. Gzip holds a reference to it (via zgrep), so it must be
;; built before gzip.
(package-with-bootstrap-guile
(package-with-explicit-inputs grep
%boot4-inputs
(current-source-location)
#:guile guile-final)))
(define %boot5-inputs
;; Now use the final Coreutils.
`(("coreutils" ,coreutils-final)
("grep" ,grep-final)
,@%boot4-inputs))
(define-public %final-inputs
;; Final derivations used as implicit inputs by 'gnu-build-system'. We
;; still use 'package-with-bootstrap-guile' so that the bootstrap tools are
;; used for origins that have patches, thereby avoiding circular
;; dependencies.
(let ((finalize (compose package-with-bootstrap-guile
(cut package-with-explicit-inputs <> %boot5-inputs
(current-source-location)))))
`(,@(map (match-lambda
((name package)
(list name (finalize package))))
`(("tar" ,tar)
("gzip" ,gzip)
("bzip2" ,bzip2)
("xz" ,xz)
("file" ,file)
("diffutils" ,diffutils)
("patch" ,patch)
("sed" ,sed)
("findutils" ,findutils)
("gawk" ,gawk)))
("grep" ,grep-final)
("coreutils" ,coreutils-final)
("make" ,gnu-make-final)
("bash" ,bash-final)
("ld-wrapper" ,ld-wrapper)
("binutils" ,binutils-final)
("gcc" ,gcc-final)
("libc" ,glibc-final))))
(define-public canonical-package
(let ((name->package (fold (lambda (input result)
(match input
((_ package)
(vhash-cons (package-full-name package)
package result))))
vlist-null
`(("guile" ,guile-final)
,@%final-inputs))))
(lambda (package)
"Return the 'canonical' variant of PACKAGE---i.e., if PACKAGE is one of
the implicit inputs of 'gnu-build-system', return that one, otherwise return
PACKAGE.
The goal is to avoid duplication in cases like GUILE-FINAL vs. GUILE-2.0,
COREUTILS-FINAL vs. COREUTILS, etc."
;; XXX: This doesn't handle dependencies of the final inputs, such as
;; libunistring, GMP, etc.
(match (vhash-assoc (package-full-name package) name->package)
((_ . canon)
;; In general we want CANON, except if we're cross-compiling: CANON
;; uses explicit inputs, so it is "anchored" in the bootstrapped
;; process, with dependencies on things that cannot be
;; cross-compiled.
(if (%current-target-system)
package
canon))
(_ package)))))
;;;
;;; GCC toolchain.
;;;
(define (gcc-toolchain gcc)
"Return a complete toolchain for GCC."
(package
(name "gcc-toolchain")
(version (package-version gcc))
(source #f)
(build-system trivial-build-system)
(arguments
'(#:modules ((guix build union))
#:builder (begin
(use-modules (ice-9 match)
(guix build union))
(match %build-inputs
(((names . directories) ...)
(union-build (assoc-ref %outputs "out")
directories)))
(union-build (assoc-ref %outputs "debug")
(list (assoc-ref %build-inputs
"libc-debug"))))))
(license (package-license gcc))
(synopsis "Complete GCC tool chain for C/C++ development")
(description
"This package provides a complete GCC tool chain for C/C++ development to
be installed in user profiles. This includes GCC, as well as libc (headers
and binaries, plus debugging symbols in the 'debug' output), and Binutils.")
(home-page "http://gcc.gnu.org/")
(outputs '("out" "debug"))
;; The main raison d'être of this "meta-package" is (1) to conveniently
;; install everything that we need, and (2) to make sure ld-wrapper comes
;; before Binutils' ld in the user's profile.
(inputs `(("gcc" ,gcc)
("ld-wrapper" ,(car (assoc-ref %final-inputs "ld-wrapper")))
("binutils" ,binutils-final)
("libc" ,glibc-final)
("libc-debug" ,glibc-final "debug")))))
(define-public gcc-toolchain-4.8
(gcc-toolchain gcc-final))
(define-public gcc-toolchain-4.9
(gcc-toolchain gcc-4.9))
;;; commencement.scm ends here

1
gnu/packages/cross-base.scm
View File

@ -21,6 +21,7 @@
#:use-module (gnu packages) #:use-module (gnu packages)
#:use-module (gnu packages gcc) #:use-module (gnu packages gcc)
#:use-module (gnu packages base) #:use-module (gnu packages base)
#:use-module (gnu packages commencement)
#:use-module (gnu packages linux) #:use-module (gnu packages linux)
#:use-module (guix packages) #:use-module (guix packages)
#:use-module (guix download) #:use-module (guix download)

4
gnu/packages/gtk.scm
View File

@ -466,8 +466,10 @@ application suites.")
(inputs (inputs
`(("guile-lib" ,guile-lib) `(("guile-lib" ,guile-lib)
("expat" ,expat) ("expat" ,expat)
("cairo" ,cairo)
("guile" ,guile-2.0))) ("guile" ,guile-2.0)))
(propagated-inputs
;; The .pc file refers to 'cairo'.
`(("cairo" ,cairo)))
(native-inputs (native-inputs
`(("pkg-config" ,pkg-config))) `(("pkg-config" ,pkg-config)))
(home-page "http://www.nongnu.org/guile-cairo/") (home-page "http://www.nongnu.org/guile-cairo/")

32
gnu/packages/guile.scm
View File

@ -34,6 +34,7 @@
#:use-module (gnu packages ncurses) #:use-module (gnu packages ncurses)
#:use-module (gnu packages ed) #:use-module (gnu packages ed)
#:use-module (gnu packages which) #:use-module (gnu packages which)
#:use-module (gnu packages gtk)
#:use-module (guix packages) #:use-module (guix packages)
#:use-module (guix download) #:use-module (guix download)
#:use-module (guix build-system gnu) #:use-module (guix build-system gnu)
@ -355,4 +356,35 @@ http:://json.org specification. These are the main features:
- Allows JSON pretty printing.") - Allows JSON pretty printing.")
(license lgpl3+))) (license lgpl3+)))
(define-public guile-charting
(package
(name "guile-charting")
(version "0.1.1")
(source (origin
(method url-fetch)
(uri (string-append "http://wingolog.org/pub/guile-charting/"
"guile-charting-" version ".tar.gz"))
(sha256
(base32
"1l8xcqq4cp67jzxnmf07ivsgq23mfmi00zz1s8bnv2zkb0ab9475"))
(modules '((guix build utils)))
(snippet
;; Remove dependency from guile-charting.texi to
;; guile-chartingscmfiles to avoid rebuild the doc (which is
;; unnecessary and fails with "failed to match any pattern in
;; form define-macro-with-docs" as of Guile 2.0.11.)
'(substitute* "doc/Makefile.in"
(("^(.+):(.*) \\$\\(doc\\)scmfiles(.*$)" _ target dep1 dep2)
(string-append target ":" dep1 " " dep2 "\n"))))))
(build-system gnu-build-system)
(native-inputs `(("pkg-config" ,pkg-config)))
(inputs `(("guile" ,guile-2.0)
("guile-cairo" ,guile-cairo)))
(home-page "http://wingolog.org/software/guile-charting/")
(synopsis "Create charts and graphs in Guile")
(description
"Guile-Charting is a Guile Scheme library to create bar charts and graphs
using the Cairo drawing library.")
(license lgpl2.1+)))
;;; guile.scm ends here ;;; guile.scm ends here

1
gnu/packages/make-bootstrap.scm
View File

@ -23,6 +23,7 @@
#:use-module (guix build-system trivial) #:use-module (guix build-system trivial)
#:use-module (guix build-system gnu) #:use-module (guix build-system gnu)
#:use-module ((gnu packages) #:select (search-patch)) #:use-module ((gnu packages) #:select (search-patch))
#:use-module ((gnu packages commencement) #:select (%final-inputs))
#:use-module (gnu packages base) #:use-module (gnu packages base)
#:use-module (gnu packages cross-base) #:use-module (gnu packages cross-base)
#:use-module (gnu packages bash) #:use-module (gnu packages bash)

20
gnu/packages/perl.scm
View File

@ -121,3 +121,23 @@ matching a regular expression.")
"This package provides the 'IO::Pty' and 'IO::Tty' Perl interfaces to "This package provides the 'IO::Pty' and 'IO::Tty' Perl interfaces to
pseudo ttys.") pseudo ttys.")
(license (package-license perl)))) (license (package-license perl))))
(define-public perl-archive-zip
(package
(name "perl-archive-zip")
(version "1.30")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/A/AD/ADAMK/Archive-Zip-"
version ".tar.gz"))
(sha256
(base32
"0633zah5z9njiqnvy3vh42fjymncmil1jdfb7d18w8xpfzzp5d7q"))))
(build-system perl-build-system)
(synopsis "Perl API to zip files")
(description "The Archive::Zip module allows a Perl program to create,
manipulate, read, and write Zip archive files.")
(home-page "http://search.cpan.org/~phred/Archive-Zip-1.37/lib/Archive/Zip.pm")
(license (package-license perl))))

69
gnu/packages/unclutter.scm Normal file
View File

@ -0,0 +1,69 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014 Alex Kost <alezost@gmail.com>
;;;
;;; 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 unclutter)
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix build-system gnu)
#:use-module (guix licenses)
#:use-module (gnu packages xorg))
(define-public unclutter
(package
(name "unclutter")
(version "8")
(source (origin
(method url-fetch)
(uri (string-append
"http://ftp.x.org/contrib/utilities/unclutter-"
version ".tar.Z"))
(sha256
(base32
"0ahrr5z6wxqqfyihm112hnq0859zlxisrb3y5232zav58j6sfmdq"))))
(build-system gnu-build-system)
(arguments
'(#:tests? #f ; no check target
#:phases (alist-delete
'configure
(alist-replace
'install
(lambda* (#:key inputs outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(bin (string-append out "/bin"))
(man1 (string-append out "/share/man/man1")))
(mkdir-p bin)
(mkdir-p man1)
(zero?
(system* "make" "install" "install.man"
(string-append "BINDIR=" bin)
(string-append "MANDIR=" man1)))))
%standard-phases))))
(inputs `(("libx11" ,libx11)))
(home-page "http://ftp.x.org/contrib/utilities/")
(synopsis "Hide idle mouse cursor")
(description
"Unclutter is a program which runs permanently in the background of an
X11 session. It checks on the X11 pointer (cursor) position every few
seconds, and when it finds it has not moved (and no buttons are pressed
on the mouse, and the cursor is not in the root window) it creates a
small sub-window as a child of the window the cursor is in. The new
window installs a cursor of size 1x1 but a mask of all 0, i.e. an
invisible cursor. This allows you to see all the text in an xterm or
xedit, for example. The human factors crowd would agree it should make
things less distracting.")
(license public-domain)))

29
gnu/packages/web.scm
View File

@ -24,8 +24,9 @@
#:use-module (guix packages) #:use-module (guix packages)
#:use-module (guix download) #:use-module (guix download)
#:use-module (guix git-download) #:use-module (guix git-download)
#:use-module (guix build-system perl)
#:use-module (guix build-system gnu) #:use-module (guix build-system gnu)
#:use-module (guix build-system perl)
#:use-module (guix build-system cmake)
#:use-module (gnu packages apr) #:use-module (gnu packages apr)
#:use-module (gnu packages asciidoc) #:use-module (gnu packages asciidoc)
#:use-module (gnu packages docbook) #:use-module (gnu packages docbook)
@ -110,7 +111,7 @@ parse JSON formatted strings back into the C representation of JSON objects.")
(define-public libwebsockets (define-public libwebsockets
(package (package
(name "libwebsockets") (name "libwebsockets")
(version "1.2") (version "1.3")
(source (origin (source (origin
;; The project does not publish tarballs, so we have to take ;; The project does not publish tarballs, so we have to take
;; things from Git. ;; things from Git.
@ -118,29 +119,19 @@ parse JSON formatted strings back into the C representation of JSON objects.")
(uri (git-reference (uri (git-reference
(url "git://git.libwebsockets.org/libwebsockets") (url "git://git.libwebsockets.org/libwebsockets")
(commit (string-append "v" version (commit (string-append "v" version
"-chrome26-firefox18")))) "-chrome37-firefox30"))))
(sha256 (sha256
(base32 (base32
"1293hbz8qj4p27m1qjf8dn97r10xjyiwdpq491m87zi025s558cl")) "12fqh2d2098mgf0ls19p9lzibpsqhv7mc5rn1yvrbfnazmcr40g4"))
(file-name (string-append name "-" version)))) (file-name (string-append name "-" version))))
;; The package has both CMake and GNU build systems, but the latter is (build-system cmake-build-system)
;; apparently better supported (CMake-generated makefiles lack an
;; 'install' target, for instance.)
(build-system gnu-build-system)
(arguments (arguments
'(#:phases (alist-cons-before ;; XXX: The thing lacks a 'make test' target, because CMakeLists.txt
'configure 'bootstrap ;; doesn't use 'add_test', and it's unclear how to run the test suite.
(lambda _ '(#:tests? #f))
(chmod "libwebsockets-api-doc.html" #o666)
(zero? (system* "./autogen.sh")))
%standard-phases)))
(native-inputs `(("autoconf" ,autoconf) (native-inputs `(("perl" ,perl))) ; to build the HTML doc
("automake" ,automake)
("libtool" ,libtool "bin")
("perl" ,perl))) ; to build the HTML doc
(inputs `(("zlib" ,zlib) (inputs `(("zlib" ,zlib)
("openssl" ,openssl))) ("openssl" ,openssl)))
(synopsis "WebSockets library written in C") (synopsis "WebSockets library written in C")

4
gnu/services/base.scm
View File

@ -27,7 +27,7 @@
#:use-module ((gnu packages linux) #:use-module ((gnu packages linux)
#:select (udev kbd e2fsprogs)) #:select (udev kbd e2fsprogs))
#:use-module ((gnu packages base) #:use-module ((gnu packages base)
#:select (glibc-final)) #:select (canonical-package glibc))
#:use-module (gnu packages package-management) #:use-module (gnu packages package-management)
#:use-module ((guix build linux-initrd) #:use-module ((guix build linux-initrd)
#:select (mount-flags->bit-mask)) #:select (mount-flags->bit-mask))
@ -324,7 +324,7 @@ the ``message of the day''."
#:allow-empty-passwords? allow-empty-passwords? #:allow-empty-passwords? allow-empty-passwords?
#:motd motd))))))) #:motd motd)))))))
(define* (nscd-service #:key (glibc glibc-final)) (define* (nscd-service #:key (glibc (canonical-package glibc)))
"Return a service that runs libc's name service cache daemon (nscd)." "Return a service that runs libc's name service cache daemon (nscd)."
(with-monad %store-monad (with-monad %store-monad
(return (service (return (service

7
gnu/services/xorg.scm
View File

@ -19,7 +19,8 @@
(define-module (gnu services xorg) (define-module (gnu services xorg)
#:use-module (gnu services) #:use-module (gnu services)
#:use-module (gnu system linux) ; 'pam-service' #:use-module (gnu system linux) ; 'pam-service'
#:use-module ((gnu packages base) #:select (guile-final)) #:use-module ((gnu packages base) #:select (canonical-package))
#:use-module (gnu packages guile)
#:use-module (gnu packages xorg) #:use-module (gnu packages xorg)
#:use-module (gnu packages gl) #:use-module (gnu packages gl)
#:use-module (gnu packages slim) #:use-module (gnu packages slim)
@ -40,7 +41,7 @@
;;; Code: ;;; Code:
(define* (xorg-start-command #:key (define* (xorg-start-command #:key
(guile guile-final) (guile (canonical-package guile-2.0))
(xorg-server xorg-server)) (xorg-server xorg-server))
"Return a derivation that builds a GUILE script to start the X server from "Return a derivation that builds a GUILE script to start the X server from
XORG-SERVER. Usually the X server is started by a login manager." XORG-SERVER. Usually the X server is started by a login manager."
@ -89,7 +90,7 @@ EndSection
(gexp->script "start-xorg" script))) (gexp->script "start-xorg" script)))
(define* (xinitrc #:key (define* (xinitrc #:key
(guile guile-final) (guile (canonical-package guile-2.0))
(ratpoison ratpoison) (ratpoison ratpoison)
(windowmaker windowmaker)) (windowmaker windowmaker))
"Return a system-wide xinitrc script that starts the specified X session." "Return a system-wide xinitrc script that starts the specified X session."

5
gnu/system.scm
View File

@ -26,6 +26,7 @@
#:use-module (guix profiles) #:use-module (guix profiles)
#:use-module (gnu packages base) #:use-module (gnu packages base)
#:use-module (gnu packages bash) #:use-module (gnu packages bash)
#:use-module (gnu packages guile)
#:use-module (gnu packages which) #:use-module (gnu packages which)
#:use-module (gnu packages admin) #:use-module (gnu packages admin)
#:use-module (gnu packages linux) #:use-module (gnu packages linux)
@ -198,7 +199,7 @@ explicitly appear in OS."
;; Default set of packages globally visible. It should include anything ;; Default set of packages globally visible. It should include anything
;; required for basic administrator tasks. ;; required for basic administrator tasks.
(cons* procps psmisc which less zile nano (cons* procps psmisc which less zile nano
guile-final (@ (gnu packages admin) dmd) guix (@ (gnu packages admin) dmd) guix
lsof ;for Guix's 'list-runtime-roots' lsof ;for Guix's 'list-runtime-roots'
util-linux inetutils isc-dhcp util-linux inetutils isc-dhcp
net-tools ; XXX: remove when Inetutils suffices net-tools ; XXX: remove when Inetutils suffices
@ -212,7 +213,7 @@ explicitly appear in OS."
;; The packages below are also in %FINAL-INPUTS, so take them from ;; The packages below are also in %FINAL-INPUTS, so take them from
;; there to avoid duplication. ;; there to avoid duplication.
(map canonical-package (map canonical-package
(list bash coreutils findutils grep sed)))) (list guile-2.0 bash coreutils findutils grep sed))))
(define %default-issue (define %default-issue
;; Default contents for /etc/issue. ;; Default contents for /etc/issue.

10
gnu/system/vm.scm
View File

@ -25,9 +25,9 @@
#:use-module (guix monads) #:use-module (guix monads)
#:use-module ((guix build vm) #:use-module ((guix build vm)
#:select (qemu-command)) #:select (qemu-command))
#:use-module ((gnu packages base) #:use-module (gnu packages base)
#:select (%final-inputs))
#:use-module (gnu packages guile) #:use-module (gnu packages guile)
#:use-module (gnu packages gawk)
#:use-module (gnu packages bash) #:use-module (gnu packages bash)
#:use-module (gnu packages less) #:use-module (gnu packages less)
#:use-module (gnu packages qemu) #:use-module (gnu packages qemu)
@ -152,7 +152,7 @@ made available under the /xchg CIFS share."
(cons #$compiled (cons #$compiled
%load-compiled-path)) %load-compiled-path))
(primitive-load #$user-builder)))) (primitive-load #$user-builder))))
(coreutils -> (car (assoc-ref %final-inputs "coreutils"))) (coreutils -> (canonical-package coreutils))
(initrd (if initrd ; use the default initrd? (initrd (if initrd ; use the default initrd?
(return initrd) (return initrd)
(base-initrd %linux-vm-file-systems (base-initrd %linux-vm-file-systems
@ -227,8 +227,8 @@ the image."
(let ((inputs (let ((inputs
'#$(append (list qemu parted grub e2fsprogs util-linux) '#$(append (list qemu parted grub e2fsprogs util-linux)
(map (compose car (cut assoc-ref %final-inputs <>)) (map canonical-package
'("sed" "grep" "coreutils" "findutils" "gawk")) (list sed grep coreutils findutils gawk))
(if register-closures? (list guix) '()))) (if register-closures? (list guix) '())))
;; This variable is unused but allows us to add INPUTS-TO-COPY ;; This variable is unused but allows us to add INPUTS-TO-COPY

4
guix/build-system/cmake.scm
View File

@ -1,5 +1,5 @@
;;; GNU Guix --- Functional package management for GNU ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2013, 2014 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2013 Cyril Roelandt <tipecaml@gmail.com> ;;; Copyright © 2013 Cyril Roelandt <tipecaml@gmail.com>
;;; ;;;
;;; This file is part of GNU Guix. ;;; This file is part of GNU Guix.
@ -99,7 +99,7 @@ provides a 'CMakeLists.txt' file as its build system."
((and (? string?) (? derivation-path?)) ((and (? string?) (? derivation-path?))
guile) guile)
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))

11
guix/build-system/gnu.scm
View File

@ -209,8 +209,8 @@ listed in REFS."
"Return the list of (NAME PACKAGE OUTPUT) or (NAME PACKAGE) tuples of "Return the list of (NAME PACKAGE OUTPUT) or (NAME PACKAGE) tuples of
standard packages used as implicit inputs of the GNU build system." standard packages used as implicit inputs of the GNU build system."
;; Resolve (gnu packages base) lazily to hide circular dependency. ;; Resolve (gnu packages commencement) lazily to hide circular dependency.
(let ((distro (resolve-module '(gnu packages base)))) (let ((distro (resolve-module '(gnu packages commencement))))
(module-ref distro '%final-inputs))) (module-ref distro '%final-inputs)))
(define* (inputs-search-paths inputs (define* (inputs-search-paths inputs
@ -268,7 +268,8 @@ System: GCC, GNU Make, Bash, Coreutils, etc."
(out-of-source? #f) (out-of-source? #f)
(tests? #t) (tests? #t)
(test-target "check") (test-target "check")
(parallel-build? #t) (parallel-tests? #t) (parallel-build? #t)
(parallel-tests? #t)
(patch-shebangs? #t) (patch-shebangs? #t)
(strip-binaries? #t) (strip-binaries? #t)
(strip-flags ''("--strip-debug")) (strip-flags ''("--strip-debug"))
@ -346,7 +347,7 @@ are allowed to refer to."
;; ((and (? string?) (? derivation-path?)) ;; ((and (? string?) (? derivation-path?))
;; guile) ;; guile)
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))
@ -532,7 +533,7 @@ platform."
;; ((and (? string?) (? derivation-path?)) ;; ((and (? string?) (? derivation-path?))
;; guile) ;; guile)
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))

8
guix/build-system/perl.scm
View File

@ -1,5 +1,5 @@
;;; GNU Guix --- Functional package management for GNU ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2013, 2014 Ludovic Courtès <ludo@gnu.org>
;;; ;;;
;;; This file is part of GNU Guix. ;;; This file is part of GNU Guix.
;;; ;;;
@ -47,6 +47,8 @@
(perl (default-perl)) (perl (default-perl))
(search-paths '()) (search-paths '())
(tests? #t) (tests? #t)
(parallel-build? #t)
(parallel-tests? #t)
(make-maker-flags ''()) (make-maker-flags ''())
(phases '(@ (guix build perl-build-system) (phases '(@ (guix build perl-build-system)
%standard-phases)) %standard-phases))
@ -79,6 +81,8 @@ provides a `Makefile.PL' file as its build system."
#:system ,system #:system ,system
#:test-target "test" #:test-target "test"
#:tests? ,tests? #:tests? ,tests?
#:parallel-build? ,parallel-build?
#:parallel-tests? ,parallel-tests?
#:outputs %outputs #:outputs %outputs
#:inputs %build-inputs))) #:inputs %build-inputs)))
@ -89,7 +93,7 @@ provides a `Makefile.PL' file as its build system."
((and (? string?) (? derivation-path?)) ((and (? string?) (? derivation-path?))
guile) guile)
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))

4
guix/build-system/python.scm
View File

@ -1,5 +1,5 @@
;;; GNU Guix --- Functional package management for GNU ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2013, 2014 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2013 Andreas Enge <andreas@enge.fr> ;;; Copyright © 2013 Andreas Enge <andreas@enge.fr>
;;; Copyright © 2013 Nikita Karetnikov <nikita@karetnikov.org> ;;; Copyright © 2013 Nikita Karetnikov <nikita@karetnikov.org>
;;; ;;;
@ -141,7 +141,7 @@ provides a 'setup.py' file as its build system."
((and (? string?) (? derivation-path?)) ((and (? string?) (? derivation-path?))
guile) guile)
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))

4
guix/build-system/trivial.scm
View File

@ -1,5 +1,5 @@
;;; GNU Guix --- Functional package management for GNU ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2012, 2013 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2012, 2013, 2014 Ludovic Courtès <ludo@gnu.org>
;;; ;;;
;;; This file is part of GNU Guix. ;;; This file is part of GNU Guix.
;;; ;;;
@ -32,7 +32,7 @@
((and (? string?) (? derivation-path?)) ((and (? string?) (? derivation-path?))
guile) guile)
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))

9
guix/build/linux-initrd.scm
View File

@ -229,8 +229,11 @@ the following:
• 'any', in which case SPEC can be anything. • 'any', in which case SPEC can be anything.
" "
(define max-trials (define max-trials
;; Number of times we retry partition label resolution. ;; Number of times we retry partition label resolution, 1 second per
7) ;; trial. Note: somebody reported a delay of 16 seconds (!) before their
;; USB key would be detected by the kernel, so we must wait for at least
;; this long.
20)
(define canonical-title (define canonical-title
;; The realm of canonicalization. ;; The realm of canonicalization.
@ -254,6 +257,8 @@ the following:
(if (> count max-trials) (if (> count max-trials)
(error "failed to resolve partition label" spec) (error "failed to resolve partition label" spec)
(begin (begin
(format #t "waiting for partition '~a' to appear...~%"
spec)
(sleep 1) (sleep 1)
(loop (+ 1 count)))))))) (loop (+ 1 count))))))))
;; TODO: Add support for UUIDs. ;; TODO: Add support for UUIDs.

4
guix/download.scm
View File

@ -205,8 +205,8 @@ must be a list of symbol/URL-list pairs."
(define guile-for-build (define guile-for-build
(package-derivation store (package-derivation store
(or guile (or guile
(let ((distro (let ((distro (resolve-interface
(resolve-interface '(gnu packages base)))) '(gnu packages commencement))))
(module-ref distro 'guile-final))) (module-ref distro 'guile-final)))
system)) system))

2
guix/gexp.scm
View File

@ -429,7 +429,7 @@ package/derivation references."
(define (default-guile) (define (default-guile)
;; Lazily resolve 'guile-final'. This module must not refer to (gnu …) ;; Lazily resolve 'guile-final'. This module must not refer to (gnu …)
;; modules directly, to avoid circular dependencies, hence this hack. ;; modules directly, to avoid circular dependencies, hence this hack.
(module-ref (resolve-interface '(gnu packages base)) (module-ref (resolve-interface '(gnu packages commencement))
'guile-final)) 'guile-final))
(define* (gexp->script name exp (define* (gexp->script name exp

2
guix/git-download.scm
View File

@ -65,7 +65,7 @@ type HASH-ALGO (a symbol). Use NAME as the file name, or a generic name if
((? package?) ((? package?)
(package-derivation store guile system)) (package-derivation store guile system))
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))

2
guix/monads.scm
View File

@ -444,7 +444,7 @@ connection."
(define (default-guile) (define (default-guile)
;; Lazily resolve 'guile-final'. This module must not refer to (gnu …) ;; Lazily resolve 'guile-final'. This module must not refer to (gnu …)
;; modules directly, to avoid circular dependencies, hence this hack. ;; modules directly, to avoid circular dependencies, hence this hack.
(module-ref (resolve-interface '(gnu packages base)) (module-ref (resolve-interface '(gnu packages commencement))
'guile-final)) 'guile-final))
(parameterize ((%guile-for-build (or guile-for-build (parameterize ((%guile-for-build (or guile-for-build

2
guix/packages.scm
View File

@ -291,7 +291,7 @@ corresponds to the arguments expected by `set-path-environment-variable'."
(define (default-guile) (define (default-guile)
"Return the default Guile package for SYSTEM." "Return the default Guile package for SYSTEM."
(let ((distro (resolve-interface '(gnu packages base)))) (let ((distro (resolve-interface '(gnu packages commencement))))
(module-ref distro 'guile-final))) (module-ref distro 'guile-final)))
(define* (patch-and-repack store source patches (define* (patch-and-repack store source patches

10
guix/profiles.scm
View File

@ -376,10 +376,11 @@ or
(define (info-dir-file manifest) (define (info-dir-file manifest)
"Return a derivation that builds the 'dir' file for all the entries of "Return a derivation that builds the 'dir' file for all the entries of
MANIFEST." MANIFEST."
(define texinfo (define texinfo ;lazy reference
;; Lazy reference. (module-ref (resolve-interface '(gnu packages texinfo)) 'texinfo))
(module-ref (resolve-interface '(gnu packages texinfo)) (define gzip ;lazy reference
'texinfo)) (module-ref (resolve-interface '(gnu packages compression)) 'gzip))
(define build (define build
#~(begin #~(begin
(use-modules (guix build utils) (use-modules (guix build utils)
@ -396,6 +397,7 @@ MANIFEST."
(or (scandir infodir info-file?) '())))) (or (scandir infodir info-file?) '()))))
(define (install-info info) (define (install-info info)
(setenv "PATH" (string-append #+gzip "/bin")) ;for info.gz files
(zero? (zero?
(system* (string-append #+texinfo "/bin/install-info") (system* (string-append #+texinfo "/bin/install-info")
info (string-append #$output "/share/info/dir")))) info (string-append #$output "/share/info/dir"))))

12
guix/scripts/package.scm
View File

@ -39,7 +39,8 @@
#:use-module (srfi srfi-26) #:use-module (srfi srfi-26)
#:use-module (srfi srfi-37) #:use-module (srfi srfi-37)
#:use-module (gnu packages) #:use-module (gnu packages)
#:use-module ((gnu packages base) #:select (guile-final)) #:use-module (gnu packages base)
#:use-module (gnu packages guile)
#:use-module ((gnu packages bootstrap) #:select (%bootstrap-guile)) #:use-module ((gnu packages bootstrap) #:select (%bootstrap-guile))
#:export (specification->package+output #:export (specification->package+output
guix-package)) guix-package))
@ -914,8 +915,9 @@ more information.~%"))
(set-build-options-from-command-line (%store) opts) (set-build-options-from-command-line (%store) opts)
(parameterize ((%guile-for-build (parameterize ((%guile-for-build
(package-derivation (%store) (package-derivation
(if (assoc-ref opts 'bootstrap?) (%store)
%bootstrap-guile (if (assoc-ref opts 'bootstrap?)
guile-final)))) %bootstrap-guile
(canonical-package guile-2.0)))))
(process-actions opts))))))) (process-actions opts)))))))

5
guix/scripts/pull.scm
View File

@ -1,5 +1,5 @@
;;; GNU Guix --- Functional package management for GNU ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2013, 2014 Ludovic Courtès <ludo@gnu.org>
;;; ;;;
;;; This file is part of GNU Guix. ;;; This file is part of GNU Guix.
;;; ;;;
@ -24,6 +24,7 @@
#:use-module (guix derivations) #:use-module (guix derivations)
#:use-module (guix download) #:use-module (guix download)
#:use-module (gnu packages base) #:use-module (gnu packages base)
#:use-module (gnu packages guile)
#:use-module ((gnu packages bootstrap) #:use-module ((gnu packages bootstrap)
#:select (%bootstrap-guile)) #:select (%bootstrap-guile))
#:use-module (gnu packages compression) #:use-module (gnu packages compression)
@ -128,7 +129,7 @@ Download and deploy the latest version of Guix.\n"))
(package-derivation store (package-derivation store
(if (assoc-ref opts 'bootstrap?) (if (assoc-ref opts 'bootstrap?)
%bootstrap-guile %bootstrap-guile
guile-final))) (canonical-package guile-2.0))))
(current-build-output-port (current-build-output-port
(if (assoc-ref opts 'verbose?) (if (assoc-ref opts 'verbose?)
(current-error-port) (current-error-port)

2
guix/scripts/refresh.scm
View File

@ -27,7 +27,7 @@
#:use-module (guix gnu-maintenance) #:use-module (guix gnu-maintenance)
#:use-module (guix gnupg) #:use-module (guix gnupg)
#:use-module (gnu packages) #:use-module (gnu packages)
#:use-module ((gnu packages base) #:select (%final-inputs)) #:use-module ((gnu packages commencement) #:select (%final-inputs))
#:use-module (ice-9 match) #:use-module (ice-9 match)
#:use-module (ice-9 regex) #:use-module (ice-9 regex)
#:use-module (ice-9 vlist) #:use-module (ice-9 vlist)

2
guix/svn-download.scm
View File

@ -61,7 +61,7 @@ type HASH-ALGO (a symbol). Use NAME as the file name, or a generic name if
((? package?) ((? package?)
(package-derivation store guile system)) (package-derivation store guile system))
(#f ; the default (#f ; the default
(let* ((distro (resolve-interface '(gnu packages base))) (let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final))) (guile (module-ref distro 'guile-final)))
(package-derivation store guile system))))) (package-derivation store guile system)))))

4
tests/builders.scm
View File

@ -46,14 +46,14 @@
(map (match-lambda (map (match-lambda
((name package) ((name package)
(list name (package-derivation %store package)))) (list name (package-derivation %store package))))
(@@ (gnu packages base) %boot0-inputs)))) (@@ (gnu packages commencement) %boot0-inputs))))
(define %bootstrap-search-paths (define %bootstrap-search-paths
;; Search path specifications that go with %BOOTSTRAP-INPUTS. ;; Search path specifications that go with %BOOTSTRAP-INPUTS.
(append-map (match-lambda (append-map (match-lambda
((name package _ ...) ((name package _ ...)
(package-native-search-paths package))) (package-native-search-paths package)))
(@@ (gnu packages base) %boot0-inputs))) (@@ (gnu packages commencement) %boot0-inputs)))
(define network-reachable? (define network-reachable?
(false-if-exception (getaddrinfo "www.gnu.org" "80" AI_NUMERICSERV))) (false-if-exception (getaddrinfo "www.gnu.org" "80" AI_NUMERICSERV)))

12
tests/guix-build.sh
View File

@ -31,18 +31,18 @@ if guix build -e '(@ (gnu packages bootstrap) %bootstrap-glibc)' -S
then false; else true; fi then false; else true; fi
# Should pass. # Should pass.
guix build -e '(@@ (gnu packages base) %bootstrap-guile)' | \ guix build -e '(@@ (gnu packages bootstrap) %bootstrap-guile)' | \
grep -e '-guile-' grep -e '-guile-'
guix build hello -d | \ guix build hello -d | \
grep -e '-hello-[0-9\.]\+\.drv$' grep -e '-hello-[0-9\.]\+\.drv$'
# Should all return valid log files. # Should all return valid log files.
drv="`guix build -d -e '(@@ (gnu packages base) %bootstrap-guile)'`" drv="`guix build -d -e '(@@ (gnu packages bootstrap) %bootstrap-guile)'`"
out="`guix build -e '(@@ (gnu packages base) %bootstrap-guile)'`" out="`guix build -e '(@@ (gnu packages bootstrap) %bootstrap-guile)'`"
log="`guix build --log-file $drv`" log="`guix build --log-file $drv`"
echo "$log" | grep log/.*guile.*drv echo "$log" | grep log/.*guile.*drv
test -f "$log" test -f "$log"
test "`guix build -e '(@@ (gnu packages base) %bootstrap-guile)' --log-file`" \ test "`guix build -e '(@@ (gnu packages bootstrap) %bootstrap-guile)' --log-file`" \
= "$log" = "$log"
test "`guix build --log-file guile-bootstrap`" = "$log" test "`guix build --log-file guile-bootstrap`" = "$log"
test "`guix build --log-file $out`" = "$log" test "`guix build --log-file $out`" = "$log"
@ -53,11 +53,11 @@ if guix build hello-0.0.1 -n; then false; else true; fi
# Keep a symlink to the result, registered as a root. # Keep a symlink to the result, registered as a root.
result="t-result-$$" result="t-result-$$"
guix build -r "$result" \ guix build -r "$result" \
-e '(@@ (gnu packages base) %bootstrap-guile)' -e '(@@ (gnu packages bootstrap) %bootstrap-guile)'
test -x "$result/bin/guile" test -x "$result/bin/guile"
# Should fail, because $result already exists. # Should fail, because $result already exists.
if guix build -r "$result" -e '(@@ (gnu packages base) %bootstrap-guile)' if guix build -r "$result" -e '(@@ (gnu packages bootstrap) %bootstrap-guile)'
then false; else true; fi then false; else true; fi
rm -f "$result" rm -f "$result"

2
tests/guix-package.sh
View File

@ -57,7 +57,7 @@ test "`guix package --search-paths -p "$profile" | wc -l`" = 0
# Check whether we have network access. # Check whether we have network access.
if guile -c '(getaddrinfo "www.gnu.org" "80" AI_NUMERICSERV)' 2> /dev/null if guile -c '(getaddrinfo "www.gnu.org" "80" AI_NUMERICSERV)' 2> /dev/null
then then
boot_make="(@@ (gnu packages base) gnu-make-boot0)" boot_make="(@@ (gnu packages commencement) gnu-make-boot0)"
boot_make_drv="`guix build -e "$boot_make" | grep -v -e -debug`" boot_make_drv="`guix build -e "$boot_make" | grep -v -e -debug`"
guix package --bootstrap -p "$profile" -i "$boot_make_drv" guix package --bootstrap -p "$profile" -i "$boot_make_drv"
test -L "$profile-2-link" test -L "$profile-2-link"

2
tests/packages.scm
View File

@ -339,7 +339,7 @@
(test-assert "GNU Make, bootstrap" (test-assert "GNU Make, bootstrap"
;; GNU Make is the first program built during bootstrap; we choose it ;; GNU Make is the first program built during bootstrap; we choose it
;; here so that the test doesn't last for too long. ;; here so that the test doesn't last for too long.
(let ((gnu-make (@@ (gnu packages base) gnu-make-boot0))) (let ((gnu-make (@@ (gnu packages commencement) gnu-make-boot0)))
(and (package? gnu-make) (and (package? gnu-make)
(or (location? (package-location gnu-make)) (or (location? (package-location gnu-make))
(not (package-location gnu-make))) (not (package-location gnu-make)))