@code{--system=i686-linux} on an @code{x86_64-linux} system allows users
to build packages in a complete 32-bit environment.
+@item --target=@var{triplet}
+@cindex cross-compilation
+Cross-build for @var{triplet}, which must be a valid GNU triplet, such
+as @code{"mips64el-linux-gnu"} (@pxref{Configuration Names, GNU
+configuration triplets,, configure, GNU Configure and Build System}).
+
@item --derivations
@itemx -d
Return the derivation paths, not the output paths, of the given
(define %store
(make-parameter #f))
-(define (derivations-from-package-expressions str system source?)
+(define (derivations-from-package-expressions str package-derivation
+ system source?)
"Read/eval STR and return the corresponding derivation path for SYSTEM.
-When SOURCE? is true, return the derivations of the package sources."
+When SOURCE? is true, return the derivations of the package sources;
+otherwise, use PACKAGE-DERIVATION to compute the derivation of a package."
(let ((p (read/eval-package-expression str)))
(if source?
(let ((source (package-source p)))
-S, --source build the packages' source derivations"))
(display (_ "
-s, --system=SYSTEM attempt to build for SYSTEM--e.g., \"i686-linux\""))
+ (display (_ "
+ --target=TRIPLET cross-build for TRIPLET--e.g., \"armel-linux-gnu\""))
(display (_ "
-d, --derivations return the derivation paths of the given packages"))
(display (_ "
(lambda (opt name arg result)
(alist-cons 'system arg
(alist-delete 'system result eq?))))
+ (option '("target") #t #f
+ (lambda (opt name arg result)
+ (alist-cons 'target arg
+ (alist-delete 'target result eq?))))
(option '(#\d "derivations") #f #f
(lambda (opt name arg result)
(alist-cons 'derivations-only? #t result)))
(with-error-handling
(let ((opts (parse-options)))
+ (define package->derivation
+ (match (assoc-ref opts 'target)
+ (#f package-derivation)
+ (triplet
+ (cut package-cross-derivation <> <> triplet <>))))
+
(parameterize ((%store (open-connection)))
(let* ((src? (assoc-ref opts 'source?))
(sys (assoc-ref opts 'system))
(drv (filter-map (match-lambda
(('expression . str)
- (derivations-from-package-expressions str sys
- src?))
+ (derivations-from-package-expressions
+ str package->derivation sys src?))
(('argument . (? derivation-path? drv))
drv)
(('argument . (? string? x))
(let ((s (package-source p)))
(package-source-derivation
(%store) s))
- (package-derivation (%store) p sys))))
+ (package->derivation (%store) p sys))))
(_ #f))
opts))
(roots (filter-map (match-lambda