2013-01-06 00:47:50 +01:00
|
|
|
|
;;; GNU Guix --- Functional package management for GNU
|
2014-01-10 23:27:39 +01:00
|
|
|
|
;;; Copyright © 2012, 2013, 2014 Ludovic Courtès <ludo@gnu.org>
|
2013-11-12 22:56:13 +01:00
|
|
|
|
;;; Copyright © 2013 Mark H Weaver <mhw@netris.org>
|
2012-06-01 23:08:32 +02:00
|
|
|
|
;;;
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; This file is part of GNU Guix.
|
2012-06-01 23:08:32 +02:00
|
|
|
|
;;;
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; GNU Guix is free software; you can redistribute it and/or modify it
|
2012-06-01 23:08:32 +02:00
|
|
|
|
;;; 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.
|
|
|
|
|
;;;
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; GNU Guix is distributed in the hope that it will be useful, but
|
2012-06-01 23:08:32 +02:00
|
|
|
|
;;; 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
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
|
2012-06-01 23:08:32 +02:00
|
|
|
|
|
|
|
|
|
(define-module (guix utils)
|
2012-11-03 21:07:52 +01:00
|
|
|
|
#:use-module (guix config)
|
2012-06-01 23:29:55 +02:00
|
|
|
|
#:use-module (srfi srfi-1)
|
2012-06-27 23:40:12 +02:00
|
|
|
|
#:use-module (srfi srfi-9)
|
2012-06-01 23:29:55 +02:00
|
|
|
|
#:use-module (srfi srfi-26)
|
2012-06-07 23:15:00 +02:00
|
|
|
|
#:use-module (srfi srfi-39)
|
2012-06-01 23:08:32 +02:00
|
|
|
|
#:use-module (srfi srfi-60)
|
|
|
|
|
#:use-module (rnrs bytevectors)
|
2012-06-28 22:57:40 +02:00
|
|
|
|
#:use-module ((rnrs io ports) #:select (put-bytevector))
|
2013-04-29 23:25:19 +02:00
|
|
|
|
#:use-module ((guix build utils) #:select (dump-port))
|
2012-06-09 15:25:51 +02:00
|
|
|
|
#:use-module (ice-9 vlist)
|
2012-06-01 23:29:55 +02:00
|
|
|
|
#:use-module (ice-9 format)
|
2012-06-07 23:15:00 +02:00
|
|
|
|
#:autoload (ice-9 popen) (open-pipe*)
|
|
|
|
|
#:autoload (ice-9 rdelim) (read-line)
|
2012-06-11 21:50:17 +02:00
|
|
|
|
#:use-module (ice-9 regex)
|
2012-06-27 23:40:12 +02:00
|
|
|
|
#:use-module (ice-9 match)
|
2012-07-01 17:32:03 +02:00
|
|
|
|
#:use-module (ice-9 format)
|
2014-01-10 23:27:39 +01:00
|
|
|
|
#:use-module (system foreign)
|
Move base32 code to (guix base32).
* guix/utils.scm (bytevector-quintet-ref, bytevector-quintet-ref-right,
bytevector-quintet-length, bytevector-quintet-fold,
bytevector-quintet-fold-right, make-bytevector->base32-string,
%nix-base32-chars, %rfc4648-base32-chars, bytevector->base32-string,
bytevector->nix-base32-string, bytevector-quintet-set!,
bytevector-quintet-set-right!, base32-string-unfold,
base32-string-unfold-right, make-base32-string->bytevector,
base32-string->bytevector, nix-base32-string->bytevector): Move to...
* guix/base32.scm: ... here. New file.
* tests/utils.scm (%nix-hash, "bytevector->base32-string",
"base32-string->bytevector", "nix-base32-string->bytevector", "sha256
& bytevector->base32-string"): Move to...
* tests/base32.scm: ... here. New file
* guix-download.in, guix/derivations.scm, guix/packages.scm,
guix/snix.scm, tests/builders.scm, tests/derivations.scm: Adjust
accordingly.
* guix.scm (%public-modules): Add `base32'.
2012-11-11 22:33:28 +01:00
|
|
|
|
#:export (bytevector->base16-string
|
2012-06-09 16:34:18 +02:00
|
|
|
|
base16-string->bytevector
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
|
|
|
|
%nixpkgs-directory
|
|
|
|
|
nixpkgs-derivation
|
2012-07-11 17:26:43 +02:00
|
|
|
|
nixpkgs-derivation*
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
2012-06-28 22:38:09 +02:00
|
|
|
|
compile-time-value
|
2014-01-10 23:27:39 +01:00
|
|
|
|
fcntl-flock
|
2012-06-11 21:50:17 +02:00
|
|
|
|
memoize
|
2012-11-05 23:46:55 +01:00
|
|
|
|
default-keyword-arguments
|
|
|
|
|
substitute-keyword-arguments
|
2012-09-01 19:21:06 +02:00
|
|
|
|
|
2012-11-19 23:02:59 +01:00
|
|
|
|
<location>
|
2012-09-01 19:21:06 +02:00
|
|
|
|
location
|
|
|
|
|
location?
|
|
|
|
|
location-file
|
|
|
|
|
location-line
|
|
|
|
|
location-column
|
|
|
|
|
source-properties->location
|
|
|
|
|
|
2012-06-11 21:50:17 +02:00
|
|
|
|
gnu-triplet->nix-system
|
2012-11-04 01:29:18 +01:00
|
|
|
|
%current-system
|
2013-05-24 22:21:24 +02:00
|
|
|
|
%current-target-system
|
2013-02-12 18:02:15 +01:00
|
|
|
|
version-compare
|
|
|
|
|
version>?
|
2013-08-23 15:51:36 +02:00
|
|
|
|
guile-version>?
|
2013-04-14 16:56:08 +02:00
|
|
|
|
package-name->name+version
|
2013-04-28 21:38:40 +02:00
|
|
|
|
string-tokenize*
|
2013-11-12 22:56:13 +01:00
|
|
|
|
string-replace-substring
|
2013-04-24 23:48:36 +02:00
|
|
|
|
file-extension
|
2013-10-09 00:04:45 +02:00
|
|
|
|
file-sans-extension
|
2013-04-21 22:40:23 +02:00
|
|
|
|
call-with-temporary-output-file
|
2013-12-29 15:51:07 +01:00
|
|
|
|
with-atomic-file-output
|
2013-04-29 23:25:19 +02:00
|
|
|
|
fold2
|
|
|
|
|
filtered-port))
|
2012-06-01 23:08:32 +02:00
|
|
|
|
|
2012-06-28 22:57:40 +02:00
|
|
|
|
|
|
|
|
|
;;;
|
|
|
|
|
;;; Compile-time computations.
|
|
|
|
|
;;;
|
|
|
|
|
|
|
|
|
|
(define-syntax compile-time-value
|
|
|
|
|
(syntax-rules ()
|
|
|
|
|
"Evaluate the given expression at compile time. The expression must
|
|
|
|
|
evaluate to a simple datum."
|
|
|
|
|
((_ exp)
|
|
|
|
|
(let-syntax ((v (lambda (s)
|
|
|
|
|
(let ((val exp))
|
|
|
|
|
(syntax-case s ()
|
|
|
|
|
(_ #`'#,(datum->syntax s val)))))))
|
|
|
|
|
v))))
|
|
|
|
|
|
2012-06-01 23:29:55 +02:00
|
|
|
|
|
|
|
|
|
;;;
|
|
|
|
|
;;; Base 16.
|
|
|
|
|
;;;
|
|
|
|
|
|
|
|
|
|
(define (bytevector->base16-string bv)
|
|
|
|
|
"Return the hexadecimal representation of BV's contents."
|
|
|
|
|
(define len
|
|
|
|
|
(bytevector-length bv))
|
|
|
|
|
|
|
|
|
|
(let-syntax ((base16-chars (lambda (s)
|
|
|
|
|
(syntax-case s ()
|
|
|
|
|
(_
|
|
|
|
|
(let ((v (list->vector
|
|
|
|
|
(unfold (cut > <> 255)
|
|
|
|
|
(lambda (n)
|
|
|
|
|
(format #f "~2,'0x" n))
|
|
|
|
|
1+
|
|
|
|
|
0))))
|
|
|
|
|
v))))))
|
|
|
|
|
(define chars base16-chars)
|
|
|
|
|
(let loop ((i 0)
|
|
|
|
|
(r '()))
|
|
|
|
|
(if (= i len)
|
|
|
|
|
(string-concatenate-reverse r)
|
|
|
|
|
(loop (+ 1 i)
|
|
|
|
|
(cons (vector-ref chars (bytevector-u8-ref bv i)) r))))))
|
|
|
|
|
|
2012-06-09 16:34:18 +02:00
|
|
|
|
(define base16-string->bytevector
|
|
|
|
|
(let ((chars->value (fold (lambda (i r)
|
|
|
|
|
(vhash-consv (string-ref (number->string i 16)
|
|
|
|
|
0)
|
|
|
|
|
i r))
|
|
|
|
|
vlist-null
|
|
|
|
|
(iota 16))))
|
|
|
|
|
(lambda (s)
|
|
|
|
|
"Return the bytevector whose hexadecimal representation is string S."
|
|
|
|
|
(define bv
|
|
|
|
|
(make-bytevector (quotient (string-length s) 2) 0))
|
|
|
|
|
|
|
|
|
|
(string-fold (lambda (chr i)
|
|
|
|
|
(let ((j (quotient i 2))
|
|
|
|
|
(v (and=> (vhash-assv chr chars->value) cdr)))
|
|
|
|
|
(if v
|
|
|
|
|
(if (zero? (logand i 1))
|
|
|
|
|
(bytevector-u8-set! bv j
|
|
|
|
|
(arithmetic-shift v 4))
|
|
|
|
|
(let ((w (bytevector-u8-ref bv j)))
|
|
|
|
|
(bytevector-u8-set! bv j (logior v w))))
|
|
|
|
|
(error "invalid hexadecimal character" chr)))
|
|
|
|
|
(+ i 1))
|
|
|
|
|
0
|
|
|
|
|
s)
|
|
|
|
|
bv)))
|
|
|
|
|
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
2013-04-29 23:25:19 +02:00
|
|
|
|
|
|
|
|
|
;;;
|
|
|
|
|
;;; Filtering & pipes.
|
|
|
|
|
;;;
|
|
|
|
|
|
|
|
|
|
(define (filtered-port command input)
|
|
|
|
|
"Return an input port where data drained from INPUT is filtered through
|
|
|
|
|
COMMAND (a list). In addition, return a list of PIDs that the caller must
|
2013-05-15 23:40:09 +02:00
|
|
|
|
wait. When INPUT is a file port, it must be unbuffered; otherwise, any
|
|
|
|
|
buffered data is lost."
|
2013-04-29 23:25:19 +02:00
|
|
|
|
(let loop ((input input)
|
|
|
|
|
(pids '()))
|
|
|
|
|
(if (file-port? input)
|
|
|
|
|
(match (pipe)
|
|
|
|
|
((in . out)
|
|
|
|
|
(match (primitive-fork)
|
|
|
|
|
(0
|
|
|
|
|
(close-port in)
|
|
|
|
|
(close-port (current-input-port))
|
|
|
|
|
(dup2 (fileno input) 0)
|
|
|
|
|
(close-port (current-output-port))
|
|
|
|
|
(dup2 (fileno out) 1)
|
|
|
|
|
(apply execl (car command) command))
|
|
|
|
|
(child
|
|
|
|
|
(close-port out)
|
|
|
|
|
(values in (cons child pids))))))
|
|
|
|
|
|
|
|
|
|
;; INPUT is not a file port, so fork just for the sake of tunneling it
|
|
|
|
|
;; through a file port.
|
|
|
|
|
(match (pipe)
|
|
|
|
|
((in . out)
|
|
|
|
|
(match (primitive-fork)
|
|
|
|
|
(0
|
|
|
|
|
(dynamic-wind
|
|
|
|
|
(const #t)
|
|
|
|
|
(lambda ()
|
|
|
|
|
(close-port in)
|
|
|
|
|
(dump-port input out))
|
|
|
|
|
(lambda ()
|
|
|
|
|
(false-if-exception (close out))
|
|
|
|
|
(primitive-exit 0))))
|
|
|
|
|
(child
|
|
|
|
|
(close-port out)
|
|
|
|
|
(loop in (cons child pids)))))))))
|
|
|
|
|
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
|
|
|
|
;;;
|
|
|
|
|
;;; Nixpkgs.
|
|
|
|
|
;;;
|
|
|
|
|
|
|
|
|
|
(define %nixpkgs-directory
|
2012-06-28 22:38:09 +02:00
|
|
|
|
(make-parameter
|
|
|
|
|
;; Capture the build-time value of $NIXPKGS.
|
2012-12-10 22:53:28 +01:00
|
|
|
|
(or %nixpkgs
|
|
|
|
|
(and=> (getenv "NIXPKGS")
|
|
|
|
|
(lambda (val)
|
|
|
|
|
;; Bail out when passed an empty string, otherwise
|
|
|
|
|
;; `nix-instantiate' will sit there and attempt to read
|
|
|
|
|
;; from its standard input.
|
|
|
|
|
(if (string=? val "")
|
|
|
|
|
#f
|
|
|
|
|
val))))))
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
2012-10-25 23:42:06 +02:00
|
|
|
|
(define* (nixpkgs-derivation attribute #:optional (system (%current-system)))
|
2012-06-07 23:15:00 +02:00
|
|
|
|
"Return the derivation path of ATTRIBUTE in Nixpkgs."
|
2012-08-14 18:36:01 +02:00
|
|
|
|
(let* ((p (open-pipe* OPEN_READ (or (getenv "NIX_INSTANTIATE")
|
2012-11-03 21:07:52 +01:00
|
|
|
|
%nix-instantiate)
|
2012-10-25 23:42:06 +02:00
|
|
|
|
"-A" attribute (%nixpkgs-directory)
|
|
|
|
|
"--argstr" "system" system))
|
2012-06-07 23:15:00 +02:00
|
|
|
|
(l (read-line p))
|
|
|
|
|
(s (close-pipe p)))
|
|
|
|
|
(and (zero? (status:exit-val s))
|
|
|
|
|
(not (eof-object? l))
|
|
|
|
|
l)))
|
|
|
|
|
|
2012-07-11 17:26:43 +02:00
|
|
|
|
(define-syntax-rule (nixpkgs-derivation* attribute)
|
|
|
|
|
"Evaluate the given Nixpkgs derivation at compile-time."
|
|
|
|
|
(compile-time-value (nixpkgs-derivation attribute)))
|
|
|
|
|
|
2014-01-10 23:27:39 +01:00
|
|
|
|
|
|
|
|
|
;;;
|
|
|
|
|
;;; Advisory file locking.
|
|
|
|
|
;;;
|
|
|
|
|
|
|
|
|
|
(define %struct-flock
|
|
|
|
|
;; 'struct flock' from <fcntl.h>.
|
|
|
|
|
(list short ; l_type
|
|
|
|
|
short ; l_whence
|
|
|
|
|
size_t ; l_start
|
|
|
|
|
size_t ; l_len
|
|
|
|
|
int)) ; l_pid
|
|
|
|
|
|
|
|
|
|
(define F_SETLKW
|
|
|
|
|
;; On Linux-based systems, this is usually 7, but not always
|
|
|
|
|
;; (exceptions include SPARC.) On GNU/Hurd, it's 9.
|
|
|
|
|
(compile-time-value
|
|
|
|
|
(cond ((string-contains %host-type "sparc") 9) ; sparc-*-linux-gnu
|
|
|
|
|
((string-contains %host-type "linux") 7) ; *-linux-gnu
|
|
|
|
|
(else 9)))) ; *-gnu*
|
|
|
|
|
|
2014-03-07 16:46:09 +01:00
|
|
|
|
(define F_SETLK
|
|
|
|
|
;; Likewise: GNU/Hurd and SPARC use 8, while the others typically use 6.
|
|
|
|
|
(compile-time-value
|
|
|
|
|
(cond ((string-contains %host-type "sparc") 8) ; sparc-*-linux-gnu
|
|
|
|
|
((string-contains %host-type "linux") 6) ; *-linux-gnu
|
|
|
|
|
(else 8)))) ; *-gnu*
|
|
|
|
|
|
2014-01-10 23:27:39 +01:00
|
|
|
|
(define F_xxLCK
|
|
|
|
|
;; The F_RDLCK, F_WRLCK, and F_UNLCK constants.
|
|
|
|
|
(compile-time-value
|
|
|
|
|
(cond ((string-contains %host-type "sparc") #(1 2 3)) ; sparc-*-linux-gnu
|
|
|
|
|
((string-contains %host-type "hppa") #(1 2 3)) ; hppa-*-linux-gnu
|
|
|
|
|
((string-contains %host-type "linux") #(0 1 2)) ; *-linux-gnu
|
|
|
|
|
(else #(1 2 3))))) ; *-gnu*
|
|
|
|
|
|
2014-03-06 21:41:51 +01:00
|
|
|
|
(define %libc-errno-pointer
|
|
|
|
|
;; Glibc's 'errno' pointer.
|
|
|
|
|
(let ((errno-loc (dynamic-func "__errno_location" (dynamic-link))))
|
|
|
|
|
(and errno-loc
|
|
|
|
|
(let ((proc (pointer->procedure '* errno-loc '())))
|
|
|
|
|
(proc)))))
|
|
|
|
|
|
|
|
|
|
(define (errno)
|
|
|
|
|
"Return the current errno."
|
|
|
|
|
;; XXX: We assume that nothing changes 'errno' while we're doing all this.
|
|
|
|
|
;; In particular, that means that no async must be running here.
|
|
|
|
|
(if %libc-errno-pointer
|
|
|
|
|
(let ((bv (pointer->bytevector %libc-errno-pointer (sizeof int))))
|
|
|
|
|
(bytevector-sint-ref bv 0 (native-endianness) (sizeof int)))
|
|
|
|
|
0))
|
|
|
|
|
|
2014-01-10 23:27:39 +01:00
|
|
|
|
(define fcntl-flock
|
|
|
|
|
(let* ((ptr (dynamic-func "fcntl" (dynamic-link)))
|
|
|
|
|
(proc (pointer->procedure int ptr `(,int ,int *))))
|
2014-03-07 16:46:09 +01:00
|
|
|
|
(lambda* (fd-or-port operation #:key (wait? #t))
|
2014-01-10 23:27:39 +01:00
|
|
|
|
"Perform locking OPERATION on the file beneath FD-OR-PORT. OPERATION
|
2014-03-07 16:46:09 +01:00
|
|
|
|
must be a symbol, one of 'read-lock, 'write-lock, or 'unlock. When WAIT? is
|
|
|
|
|
true, block until the lock is acquired; otherwise, thrown an 'flock-error'
|
|
|
|
|
exception if it's already taken."
|
2014-01-10 23:27:39 +01:00
|
|
|
|
(define (operation->int op)
|
|
|
|
|
(case op
|
|
|
|
|
((read-lock) (vector-ref F_xxLCK 0))
|
|
|
|
|
((write-lock) (vector-ref F_xxLCK 1))
|
|
|
|
|
((unlock) (vector-ref F_xxLCK 2))
|
|
|
|
|
(else (error "invalid fcntl-flock operation" op))))
|
|
|
|
|
|
|
|
|
|
(define fd
|
|
|
|
|
(if (port? fd-or-port)
|
|
|
|
|
(fileno fd-or-port)
|
|
|
|
|
fd-or-port))
|
|
|
|
|
|
|
|
|
|
;; XXX: 'fcntl' is a vararg function, but here we happily use the
|
|
|
|
|
;; standard ABI; crossing fingers.
|
|
|
|
|
(let ((err (proc fd
|
2014-03-07 16:46:09 +01:00
|
|
|
|
(if wait?
|
|
|
|
|
F_SETLKW ; lock & wait
|
|
|
|
|
F_SETLK) ; non-blocking attempt
|
2014-01-10 23:27:39 +01:00
|
|
|
|
(make-c-struct %struct-flock
|
|
|
|
|
(list (operation->int operation)
|
|
|
|
|
SEEK_SET
|
|
|
|
|
0 0 ; whole file
|
|
|
|
|
0)))))
|
|
|
|
|
(or (zero? err)
|
|
|
|
|
|
|
|
|
|
;; Presumably we got EAGAIN or so.
|
2014-03-06 21:41:51 +01:00
|
|
|
|
(throw 'flock-error (errno)))))))
|
2014-01-10 23:27:39 +01:00
|
|
|
|
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
|
|
|
|
;;;
|
|
|
|
|
;;; Miscellaneous.
|
|
|
|
|
;;;
|
|
|
|
|
|
|
|
|
|
(define (memoize proc)
|
|
|
|
|
"Return a memoizing version of PROC."
|
|
|
|
|
(let ((cache (make-hash-table)))
|
|
|
|
|
(lambda args
|
|
|
|
|
(let ((results (hash-ref cache args)))
|
|
|
|
|
(if results
|
|
|
|
|
(apply values results)
|
|
|
|
|
(let ((results (call-with-values (lambda ()
|
|
|
|
|
(apply proc args))
|
|
|
|
|
list)))
|
|
|
|
|
(hash-set! cache args results)
|
|
|
|
|
(apply values results)))))))
|
2012-06-11 21:50:17 +02:00
|
|
|
|
|
2012-11-05 23:46:55 +01:00
|
|
|
|
(define (default-keyword-arguments args defaults)
|
|
|
|
|
"Return ARGS augmented with any keyword/value from DEFAULTS for
|
|
|
|
|
keywords not already present in ARGS."
|
|
|
|
|
(let loop ((defaults defaults)
|
|
|
|
|
(args args))
|
|
|
|
|
(match defaults
|
|
|
|
|
((kw value rest ...)
|
|
|
|
|
(loop rest
|
|
|
|
|
(if (assoc-ref kw args)
|
|
|
|
|
args
|
|
|
|
|
(cons* kw value args))))
|
|
|
|
|
(()
|
|
|
|
|
args))))
|
|
|
|
|
|
|
|
|
|
(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)))))))
|
|
|
|
|
|
2012-06-11 21:50:17 +02:00
|
|
|
|
(define (gnu-triplet->nix-system triplet)
|
|
|
|
|
"Return the Nix system type corresponding to TRIPLET, a GNU triplet as
|
|
|
|
|
returned by `config.guess'."
|
|
|
|
|
(let ((triplet (cond ((string-match "^i[345]86-(.*)$" triplet)
|
|
|
|
|
=>
|
|
|
|
|
(lambda (m)
|
|
|
|
|
(string-append "i686-" (match:substring m 1))))
|
|
|
|
|
(else triplet))))
|
|
|
|
|
(cond ((string-match "^([^-]+)-([^-]+-)?linux-gnu.*" triplet)
|
|
|
|
|
=>
|
|
|
|
|
(lambda (m)
|
|
|
|
|
;; Nix omits `-gnu' for GNU/Linux.
|
|
|
|
|
(string-append (match:substring m 1) "-linux")))
|
|
|
|
|
((string-match "^([^-]+)-([^-]+-)?([[:alpha:]]+)([0-9]+\\.?)*$" triplet)
|
|
|
|
|
=>
|
|
|
|
|
(lambda (m)
|
|
|
|
|
;; Nix strip the version number from names such as `gnu0.3',
|
|
|
|
|
;; `darwin10.2.0', etc., and always strips the vendor part.
|
|
|
|
|
(string-append (match:substring m 1) "-"
|
|
|
|
|
(match:substring m 3))))
|
|
|
|
|
(else triplet))))
|
|
|
|
|
|
|
|
|
|
(define %current-system
|
|
|
|
|
;; System type as expected by Nix, usually ARCHITECTURE-KERNEL.
|
2012-12-05 23:02:47 +01:00
|
|
|
|
;; By default, this is equal to (gnu-triplet->nix-system %host-type).
|
|
|
|
|
(make-parameter %system))
|
2012-09-01 19:21:06 +02:00
|
|
|
|
|
2013-05-24 22:21:24 +02:00
|
|
|
|
(define %current-target-system
|
|
|
|
|
;; Either #f or a GNU triplet representing the target system we are
|
|
|
|
|
;; cross-building to.
|
|
|
|
|
(make-parameter #f))
|
|
|
|
|
|
2013-02-12 18:02:15 +01:00
|
|
|
|
(define version-compare
|
|
|
|
|
(let ((strverscmp
|
|
|
|
|
(let ((sym (or (dynamic-func "strverscmp" (dynamic-link))
|
|
|
|
|
(error "could not find `strverscmp' (from GNU libc)"))))
|
|
|
|
|
(pointer->procedure int sym (list '* '*)))))
|
|
|
|
|
(lambda (a b)
|
|
|
|
|
"Return '> when A denotes a newer version than B,
|
|
|
|
|
'< when A denotes a older version than B,
|
|
|
|
|
or '= when they denote equal versions."
|
|
|
|
|
(let ((result (strverscmp (string->pointer a) (string->pointer b))))
|
|
|
|
|
(cond ((positive? result) '>)
|
|
|
|
|
((negative? result) '<)
|
|
|
|
|
(else '=))))))
|
|
|
|
|
|
|
|
|
|
(define (version>? a b)
|
|
|
|
|
"Return #t when A denotes a newer version than B."
|
|
|
|
|
(eq? '> (version-compare a b)))
|
|
|
|
|
|
2013-08-23 15:51:36 +02:00
|
|
|
|
(define (guile-version>? str)
|
|
|
|
|
"Return #t if the running Guile version is greater than STR."
|
|
|
|
|
;; Note: Using (version>? (version) "2.0.5") or similar doesn't work,
|
|
|
|
|
;; because the result of (version) can have a prefix, like "2.0.5-deb1".
|
|
|
|
|
(version>? (string-append (major-version) "."
|
|
|
|
|
(minor-version) "."
|
|
|
|
|
(micro-version))
|
|
|
|
|
str))
|
|
|
|
|
|
2012-11-04 01:29:18 +01:00
|
|
|
|
(define (package-name->name+version name)
|
|
|
|
|
"Given NAME, a package name like \"foo-0.9.1b\", return two values:
|
|
|
|
|
\"foo\" and \"0.9.1b\". When the version part is unavailable, NAME and
|
|
|
|
|
#f are returned. The first hyphen followed by a digit is considered to
|
|
|
|
|
introduce the version part."
|
|
|
|
|
;; See also `DrvName' in Nix.
|
|
|
|
|
|
|
|
|
|
(define number?
|
|
|
|
|
(cut char-set-contains? char-set:digit <>))
|
|
|
|
|
|
|
|
|
|
(let loop ((chars (string->list name))
|
|
|
|
|
(prefix '()))
|
|
|
|
|
(match chars
|
|
|
|
|
(()
|
|
|
|
|
(values name #f))
|
|
|
|
|
((#\- (? number? n) rest ...)
|
|
|
|
|
(values (list->string (reverse prefix))
|
|
|
|
|
(list->string (cons n rest))))
|
|
|
|
|
((head tail ...)
|
|
|
|
|
(loop tail (cons head prefix))))))
|
|
|
|
|
|
2013-04-24 23:48:36 +02:00
|
|
|
|
(define (file-extension file)
|
|
|
|
|
"Return the extension of FILE or #f if there is none."
|
|
|
|
|
(let ((dot (string-rindex file #\.)))
|
|
|
|
|
(and dot (substring file (+ 1 dot) (string-length file)))))
|
|
|
|
|
|
2013-10-09 00:04:45 +02:00
|
|
|
|
(define (file-sans-extension file)
|
|
|
|
|
"Return the substring of FILE without its extension, if any."
|
|
|
|
|
(let ((dot (string-rindex file #\.)))
|
|
|
|
|
(if dot
|
|
|
|
|
(substring file 0 dot)
|
|
|
|
|
file)))
|
|
|
|
|
|
2013-04-28 21:38:40 +02:00
|
|
|
|
(define (string-tokenize* string separator)
|
|
|
|
|
"Return the list of substrings of STRING separated by SEPARATOR. This is
|
|
|
|
|
like `string-tokenize', but SEPARATOR is a string."
|
|
|
|
|
(define (index string what)
|
|
|
|
|
(let loop ((string string)
|
|
|
|
|
(offset 0))
|
|
|
|
|
(cond ((string-null? string)
|
|
|
|
|
#f)
|
|
|
|
|
((string-prefix? what string)
|
|
|
|
|
offset)
|
|
|
|
|
(else
|
|
|
|
|
(loop (string-drop string 1) (+ 1 offset))))))
|
|
|
|
|
|
|
|
|
|
(define len
|
|
|
|
|
(string-length separator))
|
|
|
|
|
|
|
|
|
|
(let loop ((string string)
|
|
|
|
|
(result '()))
|
|
|
|
|
(cond ((index string separator)
|
|
|
|
|
=>
|
|
|
|
|
(lambda (offset)
|
|
|
|
|
(loop (string-drop string (+ offset len))
|
|
|
|
|
(cons (substring string 0 offset)
|
|
|
|
|
result))))
|
|
|
|
|
(else
|
|
|
|
|
(reverse (cons string result))))))
|
|
|
|
|
|
2013-11-12 22:56:13 +01:00
|
|
|
|
(define* (string-replace-substring str substr replacement
|
|
|
|
|
#:optional
|
|
|
|
|
(start 0)
|
|
|
|
|
(end (string-length str)))
|
|
|
|
|
"Replace all occurrences of SUBSTR in the START--END range of STR by
|
|
|
|
|
REPLACEMENT."
|
|
|
|
|
(match (string-length substr)
|
|
|
|
|
(0
|
|
|
|
|
(error "string-replace-substring: empty substring"))
|
|
|
|
|
(substr-length
|
|
|
|
|
(let loop ((start start)
|
|
|
|
|
(pieces (list (substring str 0 start))))
|
|
|
|
|
(match (string-contains str substr start end)
|
|
|
|
|
(#f
|
|
|
|
|
(string-concatenate-reverse
|
|
|
|
|
(cons (substring str start) pieces)))
|
|
|
|
|
(index
|
|
|
|
|
(loop (+ index substr-length)
|
|
|
|
|
(cons* replacement
|
|
|
|
|
(substring str start index)
|
|
|
|
|
pieces))))))))
|
|
|
|
|
|
2013-04-21 22:40:23 +02:00
|
|
|
|
(define (call-with-temporary-output-file proc)
|
|
|
|
|
"Call PROC with a name of a temporary file and open output port to that
|
|
|
|
|
file; close the file and delete it when leaving the dynamic extent of this
|
|
|
|
|
call."
|
|
|
|
|
(let* ((template (string-copy "guix-file.XXXXXX"))
|
|
|
|
|
(out (mkstemp! template)))
|
|
|
|
|
(dynamic-wind
|
|
|
|
|
(lambda ()
|
|
|
|
|
#t)
|
|
|
|
|
(lambda ()
|
|
|
|
|
(proc template out))
|
|
|
|
|
(lambda ()
|
|
|
|
|
(false-if-exception (close out))
|
|
|
|
|
(false-if-exception (delete-file template))))))
|
2013-12-29 15:51:07 +01:00
|
|
|
|
|
|
|
|
|
(define (with-atomic-file-output file proc)
|
|
|
|
|
"Call PROC with an output port for the file that is going to replace FILE.
|
|
|
|
|
Upon success, FILE is atomically replaced by what has been written to the
|
|
|
|
|
output port, and PROC's result is returned."
|
|
|
|
|
(let* ((template (string-append file ".XXXXXX"))
|
|
|
|
|
(out (mkstemp! template)))
|
|
|
|
|
(with-throw-handler #t
|
|
|
|
|
(lambda ()
|
|
|
|
|
(let ((result (proc out)))
|
|
|
|
|
(close out)
|
|
|
|
|
(rename-file template file)
|
|
|
|
|
result))
|
|
|
|
|
(lambda (key . args)
|
|
|
|
|
(false-if-exception (delete-file template))))))
|
2013-04-21 22:40:23 +02:00
|
|
|
|
|
2013-04-14 16:56:08 +02:00
|
|
|
|
(define fold2
|
|
|
|
|
(case-lambda
|
|
|
|
|
((proc seed1 seed2 lst)
|
|
|
|
|
"Like `fold', but with a single list and two seeds."
|
|
|
|
|
(let loop ((result1 seed1)
|
|
|
|
|
(result2 seed2)
|
|
|
|
|
(lst lst))
|
|
|
|
|
(if (null? lst)
|
|
|
|
|
(values result1 result2)
|
|
|
|
|
(call-with-values
|
|
|
|
|
(lambda () (proc (car lst) result1 result2))
|
|
|
|
|
(lambda (result1 result2)
|
|
|
|
|
(loop result1 result2 (cdr lst)))))))
|
|
|
|
|
((proc seed1 seed2 lst1 lst2)
|
|
|
|
|
"Like `fold', but with a two lists and two seeds."
|
|
|
|
|
(let loop ((result1 seed1)
|
|
|
|
|
(result2 seed2)
|
|
|
|
|
(lst1 lst1)
|
|
|
|
|
(lst2 lst2))
|
|
|
|
|
(if (or (null? lst1) (null? lst2))
|
|
|
|
|
(values result1 result2)
|
|
|
|
|
(call-with-values
|
|
|
|
|
(lambda () (proc (car lst1) (car lst2) result1 result2))
|
|
|
|
|
(lambda (result1 result2)
|
|
|
|
|
(fold2 proc result1 result2 (cdr lst1) (cdr lst2)))))))))
|
|
|
|
|
|
2012-09-01 19:21:06 +02:00
|
|
|
|
|
|
|
|
|
;;;
|
|
|
|
|
;;; Source location.
|
|
|
|
|
;;;
|
|
|
|
|
|
|
|
|
|
;; A source location.
|
|
|
|
|
(define-record-type <location>
|
|
|
|
|
(make-location file line column)
|
|
|
|
|
location?
|
|
|
|
|
(file location-file) ; file name
|
|
|
|
|
(line location-line) ; 1-indexed line
|
|
|
|
|
(column location-column)) ; 0-indexed column
|
|
|
|
|
|
|
|
|
|
(define location
|
|
|
|
|
(memoize
|
|
|
|
|
(lambda (file line column)
|
|
|
|
|
"Return the <location> object for the given FILE, LINE, and COLUMN."
|
|
|
|
|
(and line column file
|
|
|
|
|
(make-location file line column)))))
|
|
|
|
|
|
|
|
|
|
(define (source-properties->location loc)
|
|
|
|
|
"Return a location object based on the info in LOC, an alist as returned
|
|
|
|
|
by Guile's `source-properties', `frame-source', `current-source-location',
|
|
|
|
|
etc."
|
|
|
|
|
(let ((file (assq-ref loc 'filename))
|
|
|
|
|
(line (assq-ref loc 'line))
|
|
|
|
|
(col (assq-ref loc 'column)))
|
2013-04-24 14:44:33 +02:00
|
|
|
|
;; In accordance with the GCS, start line and column numbers at 1. Note
|
|
|
|
|
;; that unlike LINE and `port-column', COL is actually 1-indexed here...
|
|
|
|
|
(location file (and line (+ line 1)) col)))
|