;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2016 Federico Beffa ;;; Copyright © 2016 Efraim Flashner ;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice ;;; Copyright © 2019 Brett Gilio ;;; Copyright © 2020 Brendan Tildesley ;;; Copyright © 2021, 2022 Philip McGrath ;;; ;;; 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 . (define-module (gnu packages chez-and-racket-bootstrap) #:use-module (guix packages) #:use-module (guix download) #:use-module (guix git-download) #:use-module (guix utils) #:use-module (guix gexp) #:use-module (ice-9 match) #:use-module (ice-9 regex) #:use-module (srfi srfi-1) #:use-module (srfi srfi-26) #:use-module (guix build-system copy) #:use-module (guix build-system gnu) #:use-module (gnu packages) #:use-module (gnu packages autotools) #:use-module (gnu packages bash) #:use-module (gnu packages compression) #:use-module (gnu packages ghostscript) #:use-module (gnu packages libffi) #:use-module (gnu packages linux) #:use-module (gnu packages ncurses) #:use-module (gnu packages netpbm) #:use-module (gnu packages tex) #:use-module (gnu packages xorg) #:use-module ((guix licenses) #:prefix license:) #:export (chez-scheme-for-system racket-vm-for-system)) ;; Commentary: ;; ;; Alphabetically and chronologically, Chez comes before Racket. ;; ;; The bootstrapping paths for Chez Scheme and Racket are closely ;; entwined. Racket CS (the default Racket implementation) is based on (a fork ;; of) Chez Scheme. Racket's variant of Chez Scheme shares sources for ;; nanopass and stex with upstream Chez Scheme. ;; ;; Racket's variant of Chez Scheme can be bootstrapped by an older Racket ;; implementation, Racket BC, which can be bootstrapped from C. Porting that ;; code to work with upstream Chez Scheme (or finding an old version that ;; does) is our best hope for some day bootstrapping upstream Chez Scheme from ;; source. ;; ;; Putting the relevant definitions together in this module avoids having to ;; work around dependency cycles. ;; ;; Anatomy of Racket: ;; ------------------ ;; ;; The main Racket Git repository () is ;; organized broadly like this: ;; ;; . ;; ├── Makefile ;; ├── pkgs/ ;; └── racket/ ;; ├── collects/ ;; └── src/ ;; ├── configure ;; ├── Makefile.in ;; ├── bc/ ;; ├── cs/ ;; ├── ChezScheme/ ;; └── ... ;; ;; The 'racket/src/' directory contains the source of the runtime system, core ;; compiler, and primitives for the major Racket implementations: this layer ;; is called the ``Racket VM''. It is basically a normal autotools ;; project. (Even when Racket VM implementations use components implemented in ;; Racket, they are compiled in special modes to produce VM primitives.) ;; (There are or have been experimental Racket VM implementations elsewhere, ;; e.g. .) One way of thinking about the ;; bounary between the Racket VM and Racket programs is that the VM implements ;; the primitives accessed by the 'ffi/unsafe/vm' library. Another perspective ;; is that DrRacket's ``Open defining file''/``Jump to definition'' features ;; can navigate into Racket programs, including into the implementation of ;; 'racket/base', but can not jump into the implementation of the Racket VM ;; itself. A third, related perspective is that Racket code is usually ;; installed with source files alongside compiled code (though this is not ;; mandatory), whereas the Racket VM is installed only in compiled form. ;; ;; The 'racket/collects/' directory contains ``built in'' Racket libraries ;; that are not part of any package, including the implementation of ;; 'racket/base': in particular, it must contain enough to implement `raco pkg ;; install'. It is theoretically possible to use the Racket VM layer without ;; the main collections, but it is not stable or useful. ;; ;; The 'pkgs/' directory contains Racket packages that are especially closely ;; tied to the implementation of the Racket VM, including 'compiler-lib', ;; 'racket-doc', and 'racket-test'. Some of these packages depend on Racket ;; packages that are developed in other Git repositories, predominantly but ;; not exclusively under the 'racket' GitHub organization. Conversely, not all ;; of the packages developed in the main Git repository are part of the main ;; Racket distribution. (Additionally, components of the Racket VM that are ;; implemented in Racket can be installed as packages, mostly for ease of ;; development.) ;; ;; The top-level 'Makefile' is more like a directory of scripts: it has ;; convienience targets for developing Racket, and it cooperates with the ;; 'distro-build' package to assemble custom Racket distributions. It is not ;; part of Racket source distributions: the root of a source distribution is ;; basically 'racket/src' with some extra package sources and configuration ;; added. ;; ;; A ''minimal Racket'' installation includes two packages: 'base', which is a ;; sort of bridge between the current ``built-in'' collections and the package ;; system's model of dependencies, and 'racket-lib', which, for installations ;; that can not rely on a system package manager, pulls in the SQLite and ;; OpenSSL shared libraries as platform-specific dependencies for use by the ;; ``built-in'' collections. ;; ;; The main Racket distribution consists of installing the 'main-distribution' ;; package and all of its dependencies. ;; ;; The default mode when building Racket (or installing it with the released ;; installers) is an ``in-place build'', which produces a self-contained, ;; relocatable, roughly FHS-like directory. (Racket also supports ;; ``Unix-style'' installations, which rearrange the parts of an in-place ;; build into Racket-specific subdirectories and generally tries to work for ;; installation into an FHS-based system.) Certain tools, e.g. 'distro-build' ;; and 'raco cross', are able to work with an in-place Racket build. ;; ;; This file defines the packages 'racket-vm-cgc', 'racket-vm-bc', and ;; 'racket-vm-cs'. All three are in-place builds of 'racket/src/' and ;; 'racket/collects/' and are installed to 'opt/racket-vm/' in the store ;; output. The function 'racket-vm-for-system' returns the recomended Racket ;; VM package for a given system. ;; ;; The file 'racket.scm' builds on these packages to define 'racket-minimal' ;; and 'racket' packages. These use Racket's support for ``layered ;; installations'', which allow an immutable base layer to be extended with ;; additional packages. They use the layer configuration directly provide ;; ready-to-install FHS-like trees, rather than relying on the built in ;; ``Unix-style install'' mechanism. ;; ;; Bootstrapping Racket: ;; --------------------- ;; ;; Here's how bootstrapping Racket works: ;; ;; - Racket BC [CGC] can be built with only a C compiler (except for ;; one caveat discussed below). ;; - Racket BC [3M] needs an existing Racket to run "xform", ;; which transforms its own C source code to add additional annotations ;; for the precise garbage collector. ;; - Racket CS needs (bootfiles for) Racket's fork of Chez Scheme. ;; It also needs an existing Racket to compile Racket-implemented ;; parts of the runtime system to R6RS libraries. ;; - Chez Scheme also needs bootfiles for itself, but Racket can simulate ;; enough of Chez Scheme to load Racket's fork of the Chez Scheme compiler ;; purely from source into Racket and apply the compiler to itself, ;; producing the needed bootfiles (albeit very slowly). ;; Any variant of Racket since version 7.1 can run the simulation. ;; ;; So, we build CGC to build 3M to build bootfiles and CS. ;; ;; (Note: since the CGC variant is basically only for bootstrapping, we ;; often use "BC" to mean "3M", consistent with `(banner)` and the ;; suffixes used on executables when more than one variant co-exists.) ;; ;; One remaining bootstrapping limitation is that Racket's reader, module ;; system, and macro expander are implemented in Racket. For Racket CS, ;; they are compiled to R6RS libraries as discussed above. This note from the ;; README file applies to all such subsystems: ;; ;; The Racket version must be practically the same as the current Racket ;; verson, although it can be the Racket BC implementation (instead of ;; the Racket CS implementation). ;; ;; Unlike Chez Scheme boot files, the files generated in "schemified" ;; are human-readable and -editable Scheme code. That provides a way ;; out of bootstrapping black holes, even without BC. ;; ;; However, other Racket subsystems implemented in Racket for Racket CS ;; use older C implementations for Racket BC, whereas the reader, expander, ;; and module system were completely replaced with the Racket implementation ;; ;; For Racket BC, the compiled "linklet" s-expressions (primitive modules) ;; are embeded in C as a static string constant. Eventually, they are further ;; compiled by the C-implemented Racket BC bytecode and JIT compilers. ;; (On platforms where Racket BC's JIT is not supported, yet another compiler ;; instead compiles the linklets to C code, but this is not a bootstrapping ;; issue.) ;; ;; Code: (define* (chez-scheme-for-system #:optional (system (or (%current-target-system) (%current-system)))) "Return 'chez-scheme' if it supports SYSTEM without restrictions; 'chez-scheme-racket-variant' otherwise." (if (and=> (nix-system->chez-machine system) chez-machine->upstream-restriction) chez-scheme-for-racket chez-scheme)) (define* (racket-vm-for-system #:optional (system (or (%current-target-system) (%current-system)))) "Return 'racket-vm-cs' if it supports SYSTEM; 'racket-vm-bc' otherwise." (if (nix-system->chez-machine system) racket-vm-cs racket-vm-bc)) (define (chez-machine->unthreaded mach) "Given a string MACH naming a Chez Scheme machine type, returns a string naming the unthreaded machine type for the same architecture and OS as MACH. The returned string may share storage with MACH." (if (eqv? #\t (string-ref mach 0)) (substring mach 1) mach)) (define (chez-machine->threaded mach) "Like @code{chez-machine->unthreaded}, but returns the threaded machine type." (if (eqv? #\t (string-ref mach 0)) mach (string-append "t" mach))) ;; Based on the implementation from raco-cross-lib/private/cross/platform.rkt ;; in https://github.com/racket/raco-cross. ;; For supported platforms, refer to release_notes/release_notes.stex in the ;; upstream Chez Scheme repository or to racket/src/ChezScheme/README.md ;; in https://github.com/racket/racket. (define %nix-arch-to-chez-alist `(("x86_64" . "a6") ("i386" . "i3") ("aarch64" . "arm64") ("armhf" . "arm32") ;; Chez supports ARM v6+ ("ppc" . "ppc32"))) (define %nix-os-to-chez-alist `(("w64-mingw32" . "nt") ("darwin" . "osx") ("linux" . "le") ("freebsd" . "fb") ("openbsd" . "ob") ("netbsd" . "nb") ("solaris" . "s2"))) (define (chez-machine->upstream-restriction mach) "Given a string MACH naming a Chez Scheme machine type, returns a symbol naming a restriction on the upstream Chez Scheme implementation compared to the Racket variant, or @code{#f} if no such restriction exists. The restriction is reported for the architecture--OS pair, regardless of whether MACH specifies a threaded or an unthreaded variant. Possible restrictions currently include: @itemize @bullet @item @code{'no-threads}: Support for native threads is not available upstream. @item @code{'no-support}: The upstream release doesn't claim to support this architecture--OS combination at all. @end itemize See @code{chez-machine->nix-system} for more details about acceptable values for MACH." (let ((mach (chez-machine->unthreaded mach))) (cond ((string-prefix? "arm64" mach) 'no-support) ((string-prefix? "arm32" mach) (if (string-suffix? "le" mach) 'no-threads 'no-support)) ((string-prefix? "ppc32" mach) (if (string-suffix? "le" mach) #f 'no-support)) (else #f)))) (define (chez-machine->nix-system mach) "Return the Nix system type corresponding to the Chez Scheme machine type MACH. If MACH is not a string representing a known machine type, an exception is raised. This function does not distinguish between threaded and unthreaded variants of MACH. Note that this function only handles Chez Scheme machine types in the strictest sense, not other kinds of descriptors sometimes used in place of a Chez Scheme machine type by the Racket, such as @code{\"pb\"}, @code{#f}, or @code{\"racket\"}. (When using such extensions, the Chez Scheme machine type for the host system is often still relevant.)" (let ((mach (chez-machine->unthreaded mach))) (let find-arch ((alist %nix-arch-to-chez-alist)) (match alist (((nix . chez) . alist) (if (string-prefix? chez mach) (string-append nix "-" (let ((mach-os (substring mach (string-length chez)))) (let find-os ((alist %nix-os-to-chez-alist)) (match alist (((nix . chez) . alist) (if (equal? chez mach-os) nix (find-os alist))))))) (find-arch alist))))))) (define* (nix-system->chez-machine #:optional (system (%current-system)) #:key (threads? 'always)) "Return the Chez Scheme machine type corresponding to the Nix system identifier SYSTEM, or @code{#f} if the translation of SYSTEM to a Chez Scheme machine type is undefined. When THREADS? is @code{'always} (the default), the threaded variant of the machine type will be returned: note that the package returned by @code{chez-scheme-for-system} will always support native threads. When THREADS? is @code{#f}, the unthreaded machine type will be returned. If THREADS? is @code{'upstream} (the default), the threaded variant of the machine type will be returned if and only if it is supported by upstream Chez Scheme (see @code{chez-machine->upstream-restriction}). If THREADS? is any other value, an exception is raised." (let* ((hyphen (string-index system #\-)) (nix-arch (substring system 0 hyphen)) (nix-os (substring system (+ 1 hyphen))) (chez-arch (assoc-ref %nix-arch-to-chez-alist nix-arch)) (chez-os (assoc-ref %nix-os-to-chez-alist nix-os)) (mach (and chez-arch chez-os (string-append chez-arch chez-os)))) (and mach (match threads? ('always (chez-machine->threaded mach)) (#f mach) ('upstream (if (chez-machine->upstream-restriction mach) mach (chez-machine->threaded mach))))))) ;; ;; Chez auxiliary G-expressions: ;; (define unbundle-chez-submodules #~(begin (use-modules (guix build utils)) (for-each (lambda (dir) (when (directory-exists? dir) (delete-file-recursively dir))) '("stex" "nanopass" "lz4" "zlib")))) (define unpack-nanopass+stex #~(begin (copy-recursively (dirname (search-input-file %build-inputs "lib/chez-scheme/nanopass.ss")) "nanopass" #:keep-mtime? #t) (mkdir-p "stex") (with-output-to-file "stex/Mf-stex" (lambda () ;; otherwise, it will try to download submodules (display "# to placate ../configure"))))) ;; ;; Racket VM: ;; (define (racket-vm-common-configure-flags) ;; under a lambda extraction to avoid evaluating bash-minimal too early #~`(,@(cond ((false-if-exception (search-input-file %build-inputs "/bin/libtool")) => (lambda (libtool) (list (string-append "--enable-lt=" libtool)))) (else '())) ,@(cond ((false-if-exception (search-input-file %build-inputs "/opt/racket-vm/bin/racket")) => (lambda (racket) (list (string-append "--enable-racket=" racket)))) (else '())) ,(string-append "CPPFLAGS=-DGUIX_RKTIO_PATCH_BIN_SH=" #$(file-append bash-minimal "/bin/sh")) "--disable-strip" "--enable-origtree")) (define-public racket-vm-cgc ;; Eventually, it may make sense for some vm packages to not be hidden, ;; but this one is especially likely to remain hidden. (hidden-package (package (name "racket-vm-cgc") (version "8.4") ;; ^ Remember to also update the version of ;; chez-scheme-for-racket-bootstrap-bootfiles (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/racket/racket") (commit (string-append "v" version)))) (sha256 (base32 "1vpl66gdgc8rnldmn8rmb7ar9l057jqjvgpfn29k57i3c5skr8s6")) (file-name (git-file-name "racket" version)) (patches (search-patches "racket-minimal-sh-via-rktio.patch" ;; Remove by Racket 8.5: "racket-enable-scheme-backport.patch")) (modules '((guix build utils))) (snippet #~(begin ;; Unbundle Chez submodules. (with-directory-excursion "racket/src/ChezScheme" #$unbundle-chez-submodules) ;; Unbundle libffi. (delete-file-recursively "racket/src/bc/foreign/libffi"))))) (inputs (list ncurses ;; <- common to all variants (for #%terminal) bash-minimal ;; <- common to all variants (for `system`) libffi)) ;; <- only for BC variants (native-inputs (list libtool)) ;; <- only for BC variants (outputs '("out" "debug")) (build-system gnu-build-system) (arguments (list #:configure-flags #~(cons "--enable-cgcdefault" #$(racket-vm-common-configure-flags)) ;; Tests are in packages like racket-test-core and ;; main-distribution-test that aren't part of the main ;; distribution. #:tests? #f ;; Upstream recommends #:out-of-source?, and it does ;; help with debugging, but it confuses `install-license-files`. #:modules '((ice-9 match) (ice-9 regex) (guix build gnu-build-system) (guix build utils)) #:strip-directories #~'("opt/racket-vm/bin" "opt/racket-vm/lib") #:phases #~(let () (define* ((wrap-racket-vm-outputs phase) . args) (apply phase (let loop ((args args)) (match args ((#:outputs outputs . args) `(#:outputs ,(let loop ((outputs outputs)) (match outputs ((("out" . out) . outputs) `(("out" . ,(string-append out "/opt/racket-vm/")) ,@outputs)) ((other . outputs) (cons other (loop outputs))))) ,@args)) ((arg . args) (cons arg (loop args))))))) (modify-phases %standard-phases (add-before 'configure 'initialize-config.rktd (lambda* (#:key inputs #:allow-other-keys) (define (write-racket-hash alist) ;; inside must use dotted pair notation (display "#hash(") (for-each (match-lambda ((k . v) (format #t "(~s . ~s)" k v))) alist) (display ")\n")) (define maybe-release-catalog (let ((v #$(package-version this-package))) (if (string-match "^[0-9]+\\.[0-9]+($|\\.[0-8][0-9]*$)" v) `(,(string-append "https://download.racket-lang.org/releases/" v "/catalog/")) '()))) (mkdir-p "racket/etc") (with-output-to-file "racket/etc/config.rktd" (lambda () (write-racket-hash `((build-stamp . "") (catalogs ,@maybe-release-catalog #f))))))) (add-before 'configure 'chdir (lambda _ (chdir "racket/src"))) (replace 'configure (wrap-racket-vm-outputs (assoc-ref %standard-phases 'configure))) (replace 'patch-shebangs (wrap-racket-vm-outputs (assoc-ref %standard-phases 'patch-shebangs))) (replace 'validate-runpath (wrap-racket-vm-outputs (assoc-ref %standard-phases 'validate-runpath))) (replace 'make-dynamic-linker-cache (wrap-racket-vm-outputs (assoc-ref %standard-phases 'make-dynamic-linker-cache))) (replace 'patch-dot-desktop-files (wrap-racket-vm-outputs (assoc-ref %standard-phases 'patch-dot-desktop-files))))))) (home-page "https://racket-lang.org") (synopsis "Old Racket implementation used for bootstrapping") (description "This variant of the Racket BC (``before Chez'' or ``bytecode'') implementation is not recommended for general use. It uses CGC (a ``Conservative Garbage Collector''), which was succeeded as default in PLT Scheme version 370 (which translates to 3.7 in the current versioning scheme) by the 3M variant, which in turn was succeeded in version 8.0 by the Racket CS implementation. Racket CGC is primarily used for bootstrapping Racket BC [3M]. It may also be used for embedding applications without the annotations needed in C code to use the 3M garbage collector.") ;; https://download.racket-lang.org/license.html ;; The LGPL components are only used by Racket BC. (license (list license:lgpl3+ license:asl2.0 license:expat))))) (define-public racket-vm-bc (package (inherit racket-vm-cgc) (name "racket-vm-bc") (native-inputs (modify-inputs (package-native-inputs racket-vm-cgc) (prepend racket-vm-cgc))) (arguments (substitute-keyword-arguments (package-arguments racket-vm-cgc) ((#:configure-flags _ '()) #~(cons "--enable-bconly" #$(racket-vm-common-configure-flags))))) (synopsis "Racket BC [3M] implementation") (description "The Racket BC (``before Chez'' or ``bytecode'') implementation was the default before Racket 8.0. It uses a compiler written in C targeting architecture-independent bytecode, plus a JIT compiler on most platforms. Racket BC has a different C API and supports a slightly different set of architectures than the current default runtime system, Racket CS (based on ``Chez Scheme''). It is the recommended implementation for architectures that Racket CS doesn't support. This package is the normal implementation of Racket BC with a precise garbage collector, 3M (``Moving Memory Manager'')."))) (define-public racket-vm-cs (package (inherit racket-vm-bc) (name "racket-vm-cs") (inputs (modify-inputs (package-inputs racket-vm-cgc) (prepend zlib lz4) (delete "libffi"))) (native-inputs (modify-inputs (package-native-inputs racket-vm-cgc) (delete "libtool") (prepend chez-scheme-for-racket chez-nanopass-bootstrap racket-vm-bc))) (arguments (substitute-keyword-arguments (package-arguments racket-vm-cgc) ((#:phases those-phases #~%standard-phases) #~(modify-phases #$those-phases (add-after 'unpack 'unpack-nanopass+stex (lambda args (with-directory-excursion "racket/src/ChezScheme" #$unpack-nanopass+stex))))) ((#:configure-flags _ '()) #~(cons* "--enable-csonly" "--enable-libz" "--enable-lz4" (string-append "--enable-scheme=" #$(this-package-native-input "chez-scheme-for-racket") "/bin/scheme") #$(racket-vm-common-configure-flags))))) (synopsis "Racket CS implementation") (description "The Racket CS implementation, which uses ``Chez Scheme'' as its core compiler and runtime system, has been the default Racket VM implemetation since Racket 8.0. It performs better than the Racket BC implementation for most programs. Using the Racket VM packages directly is not recommended: instead, install the @code{racket-minimal} or @code{racket} packages.") ;; https://download.racket-lang.org/license.html ;; The LGPL components are only used by Racket BC. (license (list license:asl2.0 license:expat)))) ;; ;; Chez Scheme: ;; (define-public chez-scheme-bootstrap-bootfiles (package (name "chez-scheme-bootstrap-bootfiles") ;; The version should match `(scheme-version-number)`. ;; See s/cmacros.ss c. line 360. (version "9.5.6") (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/cisco/ChezScheme") (commit (string-append "v" version)))) (sha256 (base32 "07s433hn1z2slfc026sidrpzxv3a8narcd40qqr1xrpb9012xdky")) (file-name (git-file-name "chez-scheme" version)) (snippet unbundle-chez-submodules))) (build-system copy-build-system) ;; TODO: cross compilation (arguments (list #:install-plan #~`(("boot/" "lib/chez-scheme-bootfiles")))) (supported-systems ;; Upstream only distributes pre-built bootfiles for ;; arm32le and t?(i3|a6)(le|nt|osx) (filter (lambda (system) (let ((mach (nix-system->chez-machine system #:threads? #f))) (or (equal? "arm32le" mach) (and mach (member (substring mach 0 2) '("i3" "a6")) (or-map (cut string-suffix? <> mach) '("le" "nt" "osx")))))) %supported-systems)) (home-page "https://cisco.github.io/ChezScheme/") (synopsis "Chez Scheme bootfiles (binary seed)") (description "Chez Scheme is a self-hosting compiler: building it requires ``bootfiles'' containing the Scheme-implemented portions compiled for the current platform. (Chez can then cross-compile bootfiles for all other supported platforms.) This package provides bootstrap bootfiles for upstream Chez Scheme. Currently, it simply packages the binaries checked in to the upsream repository. Hopefully we can eventually adapt Racket's @code{cs-bootstrap} to work with upstream Chez Scheme so that we can bootstrap these files from source.") (properties `((hidden? . #t))) (license license:asl2.0))) (define-public chez-scheme (package (name "chez-scheme") (version (package-version chez-scheme-bootstrap-bootfiles)) (source (package-source chez-scheme-bootstrap-bootfiles)) (build-system gnu-build-system) (inputs (list `(,util-linux "lib") ;<-- libuuid zlib lz4 ncurses ;<-- for expeditor ;; for X11 clipboard support in expeditor: ;; https://github.com/cisco/ChezScheme/issues/9#issuecomment-222057232 libx11)) (native-inputs (list chez-scheme-bootstrap-bootfiles chez-nanopass-bootstrap stex-bootstrap)) (native-search-paths (list (search-path-specification (variable "CHEZSCHEMELIBDIRS") (files (list (string-append "lib/chez-scheme")))))) (outputs '("out" "doc")) (arguments (list #:modules '((guix build gnu-build-system) (guix build utils) (ice-9 ftw) (ice-9 match)) #:test-target "test" ;; TODO when we fix armhf, it may not support --threads #:configure-flags #~'("--threads") #:phases #~(modify-phases %standard-phases (add-after 'unpack 'unpack-nanopass+stex (lambda args #$unpack-nanopass+stex)) (add-after 'unpack-nanopass+stex 'unpack-bootfiles (lambda* (#:key native-inputs inputs #:allow-other-keys) (when (directory-exists? "boot") (delete-file-recursively "boot")) (copy-recursively (search-input-directory (or native-inputs inputs) "lib/chez-scheme-bootfiles") "boot"))) ;; NOTE: the custom Chez 'configure' script doesn't allow ;; unrecognized flags, such as those automatically added ;; by `gnu-build-system`. (replace 'configure (lambda* (#:key inputs (configure-flags '()) #:allow-other-keys) ;; add flags which are always required: (let ((flags (cons* (string-append "--installprefix=" #$output) "ZLIB=-lz" "LZ4=-llz4" "--libkernel" ;; Guix will do compress-man-pages, ;; and letting Chez try causes an error "--nogzip-man-pages" configure-flags))) (format #t "configure flags: ~s~%" flags) ;; Some makefiles (for tests) don't seem to propagate CC ;; properly, so we take it out of their hands: (setenv "CC" #$(cc-for-target)) (setenv "HOME" "/tmp") (apply invoke "./configure" flags)))) ;; The binary file name is called "scheme" as is the one from ;; MIT/GNU Scheme. We add a symlink to use in case both are ;; installed. (add-after 'install 'install-symlink (lambda* (#:key outputs #:allow-other-keys) (let* ((scheme (search-input-file outputs "/bin/scheme")) (bin-dir (dirname scheme))) (symlink scheme (string-append bin-dir "/chez-scheme")) (match (find-files (string-append bin-dir "/../lib") "scheme.boot") ((scheme.boot) (symlink scheme.boot (string-append (dirname scheme.boot) "/chez-scheme.boot"))))))) ;; Building the documentation requires stex and a running scheme. ;; FIXME: this is probably wrong for cross-compilation (add-after 'install-symlink 'install-doc (lambda* (#:key native-inputs inputs outputs #:allow-other-keys) (match (assoc-ref outputs "doc") (#f (format #t "not installing docs~%")) (doc-prefix (let* ((chez+version (strip-store-file-name #$output)) (scheme (search-input-file outputs "/bin/scheme")) (stexlib (search-input-directory (or native-inputs inputs) "/lib/stex")) (doc-dir (string-append doc-prefix "/share/doc/" chez+version))) (define* (stex-make #:optional (suffix "")) (invoke "make" "install" (string-append "Scheme=" scheme) (string-append "STEXLIB=" stexlib) (string-append "installdir=" doc-dir suffix))) (with-directory-excursion "csug" (stex-make "/csug")) (with-directory-excursion "release_notes" (stex-make "/release_notes")) (with-directory-excursion doc-dir (symlink "release_notes/release_notes.pdf" "release_notes.pdf") (symlink "csug/csug9_5.pdf" "csug.pdf")))))))))) ;; Chez Scheme does not have a MIPS backend. ;; FIXME: Debian backports patches to get armhf working. ;; We should too. It is the Chez machine type arm32le ;; (no threaded version upstream yet, though there is in ;; Racket's fork), more specifically (per the release notes) ARMv6. (supported-systems (delete "armhf-linux" ;; <-- should work, but reportedly broken (filter (lambda (system) (and=> (nix-system->chez-machine system) (lambda (mach) (not (eq? 'no-support (chez-machine->upstream-restriction mach)))))) %supported-systems))) (home-page (package-home-page chez-scheme-bootstrap-bootfiles)) (synopsis "R6RS Scheme compiler and run-time") (description "Chez Scheme is a compiler and run-time system for the language of the Revised^6 Report on Scheme (R6RS), with numerous extensions. The compiler generates native code for each target processor, with support for x86, x86_64, and 32-bit PowerPC architectures.") (license license:asl2.0))) (define-public chez-scheme-for-racket-bootstrap-bootfiles (package (inherit chez-scheme-bootstrap-bootfiles) (name "chez-scheme-for-racket-bootstrap-bootfiles") (version "9.5.7.3") ;; The version should match `(scheme-fork-version-number)`. ;; See racket/src/ChezScheme/s/cmacros.ss c. line 360. ;; It will always be different than the upstream version! (source (package-source racket-vm-cgc)) (native-inputs (list chez-nanopass-bootstrap racket-vm-bc)) (arguments (substitute-keyword-arguments (package-arguments chez-scheme-bootstrap-bootfiles) ((#:phases those-phases #~%standard-phases) #~(modify-phases #$those-phases (add-after 'unpack 'chdir (lambda args (chdir "racket/src/ChezScheme"))) (add-after 'chdir 'unpack-nanopass+stex (lambda args #$unpack-nanopass+stex)) (add-before 'install 'build (lambda* (#:key native-inputs inputs #:allow-other-keys) (invoke (search-input-file (or native-inputs inputs) "/opt/racket-vm/bin/racket") "rktboot/main.rkt"))))))) (home-page "https://github.com/racket/ChezScheme") ;; ^ This is downstream of https://github.com/racket/racket, ;; but it's designed to be a friendly landing place for people ;; who want a ChezScheme-shaped repositroy. (synopsis "Chez Scheme bootfiles bootstrapped by Racket") (description "Chez Scheme is a self-hosting compiler: building it requires ``bootfiles'' containing the Scheme-implemented portions compiled for the current platform. (Chez can then cross-compile bootfiles for all other supported platforms.) The Racket package @code{cs-bootstrap} (part of the main Racket Git repository) implements enough of a Chez Scheme simulation to load the Chez Scheme compiler purely from source into Racket and apply the compiler to itself, thus bootstrapping Chez Scheme. Bootstrapping takes about 10 times as long as using an existing Chez Scheme, but @code{cs-bootstrap} supports Racket 7.1 and later, including the Racket BC variant. Note that the generated bootfiles are specific to Racket's fork of Chez Scheme, and @code{cs-bootstrap} does not currently support building upstream Chez Scheme.") (properties `()) (license license:asl2.0))) (define-public chez-scheme-for-racket (package (inherit chez-scheme) (name "chez-scheme-for-racket") (version (package-version chez-scheme-for-racket-bootstrap-bootfiles)) (source (package-source racket-vm-cgc)) (inputs (modify-inputs (package-inputs chez-scheme) (delete "libx11" "util-linux:lib"))) (native-inputs (modify-inputs (package-native-inputs chez-scheme) (replace "chez-scheme-bootstrap-bootfiles" chez-scheme-for-racket-bootstrap-bootfiles))) (arguments (substitute-keyword-arguments (package-arguments chez-scheme) ((#:configure-flags cfg-flags #~'()) #~(cons "--disable-x11" #$cfg-flags)) ((#:phases those-phases #~%standard-phases) #~(modify-phases #$those-phases (add-after 'unpack 'chdir (lambda args (chdir "racket/src/ChezScheme"))))))) (supported-systems (filter nix-system->chez-machine %supported-systems)) (home-page (package-home-page chez-scheme-for-racket-bootstrap-bootfiles)) (synopsis "Variant of Chez Scheme extended for Racket") (description "This variant of Chez Scheme is extended to support the implementation of Racket. It may be useful on platforms that are not yet supported by upstream Chez Scheme. Main additions to Chez Scheme in the Racket variant: @itemize @bullet @item AArch64 support @item Portable bytes (@code{pb}) support, which is mainly useful for bootstrapping a build on any supported platform @item Unboxed floating-point arithmetic and flvectors @item Type reconstruction during optimization (especially for safe code) @item Continuation attachments @item Parallel garbage collection, in-place garbage collection for old-generation objects (instead of always copying), and reachability-based memory accounting @item Ordered finalization, immobile (but collectable) objects, weak/ephemeron generic hash tables, and reference bytevectors @item Faster multiplication and division for large exact numbers @end itemize") (license license:asl2.0))) ;; ;; Chez's bootstrap dependencies: ;; (define-public stex-bootstrap ;; This commit includes a fix which we would otherwise want to use as ;; patch. Let's revert to tagged releases as soon as one becomes available. (let ((commit "54051494434a197772bf6ca5b4e6cf6be55f39a5") (revision "1")) (hidden-package (package (name "stex") ;; ^ Debian calls this "stex", not "chez-stex". It is a set of ;; command-line tools, and there isn't a Scheme API, let alone a ;; Chez-specific one, except perhaps that the Scheme examples are ;; assumed to be Chez-compatible. (version (git-version "1.2.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/dybvig/stex") (commit commit))) (sha256 (base32 "01jnvw8qw33gnpzwrakwhsr05h6b609lm180jnspcrb7lds2p23d")) (file-name (git-file-name name version)) (snippet #~(for-each delete-file '("sbin/install" "doc/stex.pdf" "doc/stex.html"))))) (outputs '("out")) (build-system copy-build-system) ;; N.B. Upstream does not seem to support cross-compilation, ;; though it would probably be easy to add. (propagated-inputs (list xorg-rgb (texlive-updmap.cfg (list texlive-dvips-l3backend texlive-hyperref texlive-bibtex texlive-epsf texlive-fonts-ec texlive-oberdiek)) ghostscript netpbm)) ;; Debian uses a versionless path for STEXLIB, ;; which is much more convienient. (arguments (list #:install-plan #~`(("inputs" "lib/stex/") ("gifs" "lib/stex/") ("math" "lib/stex/") ("src" "lib/stex/") ;; can run without compiling ("Mf-stex" "lib/stex/") ("Makefile.template" "lib/stex/")) #:phases #~(modify-phases %standard-phases (add-before 'install 'patch-sources (lambda* (#:key native-inputs inputs outputs #:allow-other-keys) (define scheme (false-if-exception (search-input-file inputs "/bin/scheme"))) (when scheme (setenv "Scheme" scheme)) (substitute* '("Makefile.template" "doc/Makefile") (("STEXLIB=[^\n]*") (string-append "STEXLIB=" #$output "/lib/stex")) (("Scheme=[^\n]*") (string-append "Scheme=" (or scheme "scheme")))) (substitute* '("Mf-stex" "math/Makefile") (("/bin/rm") "rm")) (substitute* "Mf-stex" (("SHELL=bash") ;; avoid Solaris workaround "#SHELL=bash")))) (add-after 'install 'maybe-compile (lambda* (#:key native-inputs inputs outputs #:allow-other-keys) (cond ((getenv "Scheme") => (lambda (scheme) (define makefile (string-append (getcwd) "/Makefile")) (define machine #$(nix-system->chez-machine (or (%current-target-system) (%current-system)))) (with-directory-excursion (search-input-directory outputs "/lib/stex") (invoke "make" "-f" makefile (string-append "Scheme=" scheme)) (for-each delete-file (find-files machine "\\."))))) (else (format #t "not compiling~%"))))) (add-after 'maybe-compile 'maybe-make-docs (lambda* (#:key native-inputs inputs outputs #:allow-other-keys) (cond ((assoc-ref outputs "doc") => (lambda (doc-prefix) (define doc-dir (string-append doc-prefix "/share/doc/stex")) ;; the Makefile is referenced in the documentation (copy-recursively "doc" doc-dir) (install-file "ReadMe" doc-dir) (with-directory-excursion "doc" (invoke "make") (install-file "stex.html" doc-dir) (install-file "stex.pdf" doc-dir)))) (else (format #t "not making docs~%")))))))) (home-page "https://github.com/dybvig/stex") (synopsis "LaTeX with embeded Scheme code and HTML generation") (description "The @code{stex} package extends LaTeX with a handful of commands for including Scheme code (or pretty much any other kind of code, as long as you don't plan to use the Scheme-specific transcript support) in a document. It provides the programs @code{scheme-prep} and @code{html-prep} to convert @code{stex} documents to LaTeX and HTML, respectively, plus makefile templates, style files, and other resources. The @code{stex} system is used to typeset @cite{The Scheme Programming Language} and the @cite{Chez Scheme User's Guix}, among other documents.") (license license:expat))))) (define-public stex (package/inherit stex-bootstrap (inputs (modify-inputs (package-inputs stex-bootstrap) (prepend chez-scheme))) (outputs '("out" "doc")) (properties '()))) (define-public chez-nanopass-bootstrap (hidden-package (package (name "chez-nanopass") (version "1.9.2") (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/nanopass/nanopass-framework-scheme") (commit (string-append "v" version)))) (sha256 (base32 "16vjsik9rrzbabbhbxbaha51ppi3f9n8rk59pc6zdyffs0vziy4i")) (file-name (git-file-name "nanopass-framework-scheme" version)) (snippet #~(begin (use-modules (guix build utils)) (when (file-exists? "doc/user-guide.pdf") (delete-file "doc/user-guide.pdf")) (substitute* "doc/Makefile" (("include ~/stex/Mf-stex") "include $(STEXLIB)/Mf-stex")))))) (build-system copy-build-system) (arguments (list #:install-plan #~`(("nanopass.ss" "lib/chez-scheme/") ("nanopass" "lib/chez-scheme/")))) (home-page "https://nanopass.org") (synopsis "DSL for compiler development") (description "The Nanopass framework is an embedded domain-specific language for writing compilers composed of several simple passes that operate over well-defined intermediate languages. The goal of this organization is both to simplify the understanding of each pass, because it is responsible for a single task, and to simplify the addition of new passes anywhere in the compiler. Nanopass reduces the boilerplate required to create compilers, making them easier to understand and maintain.") (license license:expat)))) (define-public chez-nanopass (package/inherit chez-nanopass-bootstrap (properties '()) ;; TODO: cross-compilation (native-inputs (list chez-scheme stex)) (arguments (substitute-keyword-arguments (package-arguments chez-nanopass-bootstrap) ((#:install-plan base-plan) #~`(("nanopass.so" "lib/chez-scheme/") ("doc/user-guide.pdf" #$(string-append "share/doc/" (package-name this-package) "-" (package-version this-package) "/")) ,@#$base-plan)) ((#:phases base-phases #~%standard-phases) #~(modify-phases #$base-phases (add-before 'install 'compile-and-test (lambda args (invoke "scheme" "--compile-imported-libraries" "--program" "test-all.ss"))) (add-after 'compile-and-test 'build-doc (lambda* (#:key native-inputs inputs #:allow-other-keys) (with-directory-excursion "doc" (invoke "make" (string-append "Scheme=" (search-input-file (or native-inputs inputs) "/bin/scheme")) (string-append "STEXLIB=" (search-input-directory (or native-inputs inputs) "/lib/stex"))))))))))))