;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2019 Brett Gilio <brettg@gnu.org>
;;; Copyright © 2020 Brendan Tildesley <mail@brendan.scot>
;;; Copyright © 2021, 2022 Philip McGrath <philip@philipmcgrath.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 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:))

;; 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 (<https://github.com/racket/racket>) 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. <https://github.com/pycket/pycket>.)
;;
;; 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-machine->nonthreaded machine)
  "Given a string MACHINE naming a Chez Scheme machine type, returns a string
naming the nonthreaded machine type for the same architecture and OS as
MACHINE.  The returned string may share storage with MACHINE."
  ;; Chez Scheme documentation consistently uses "nonthreaded" rather than
  ;; e.g. "unthreaded"
  (if (eqv? #\t (string-ref machine 0))
      (substring machine 1)
      machine))
(define (chez-machine->threaded machine)
  "Like @code{chez-machine->nonthreaded}, but returns the threaded machine
type."
  (if (eqv? #\t (string-ref machine 0))
      machine
      (string-append "t" machine)))

;; 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->nix-system machine)
  "Return the Nix system type corresponding to the Chez Scheme machine type
MACHINE.  If MACHINE is not a string representing a known machine type, an
exception is raised.  This function does not distinguish between threaded and
nonthreaded variants of MACHINE.

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 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 ((machine (chez-machine->nonthreaded machine)))
    (let find-arch ((alist %nix-arch-to-chez-alist))
      (match alist
        (((nix . chez) . alist)
         (if (string-prefix? chez machine)
             (string-append
              nix "-" (let ((machine-os
                             (substring machine (string-length chez))))
                        (let find-os ((alist %nix-os-to-chez-alist))
                          (match alist
                            (((nix . chez) . alist)
                             (if (equal? chez machine-os)
                                 nix
                                 (find-os alist)))))))
             (find-arch alist)))))))

(define* (nix-system->chez-machine #:optional
                                   (system (or (%current-target-system)
                                               (%current-system))))
  "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.

It is unspecified whether the resulting string will name a threaded or a
nonthreaded machine type: when the distinction is relevant, use
@code{chez-machine->nonthreaded} or @code{chez-machine->threaded} to adjust
the result."
  (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)))
    (and chez-arch chez-os (string-append chez-arch chez-os))))

(define* (chez-upstream-features-for-system #:optional
                                            (system
                                             (or (%current-target-system)
                                                 (%current-system))))
  "Return a list of symbols naming features supported by upstream Chez Scheme
for the Nix system identifier SYSTEM, or @code{#f} if upstream Chez Scheme
does not support SYSTEM at all.

If native threads are supported, the returned list will include
@code{'threads}.  Other feature symbols may be added in the future."
  (cond
   ((not (nix-system->chez-machine system))
    #f)
   ((target-aarch64? system)
    #f)
   ((target-arm32? system)
    (and (target-linux? system)
         '()))
   ((target-ppc32? system)
    (and (target-linux? system)
         '(threads)))
   (else
    '(threads))))

;;
;; 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
  (package
    (name "chez-scheme")
    ;; 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 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 chez-upstream-features-for-system
              %supported-systems)))
    (home-page "https://cisco.github.io/ChezScheme/")
    (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-bootstrap-bootfiles
  (package
    (inherit chez-scheme)
    (name "chez-scheme-bootstrap-bootfiles")
    (inputs '())
    (native-inputs '())
    (outputs '("out"))
    (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 ((machine (and=> (nix-system->chez-machine system)
                                     chez-machine->nonthreaded)))
                 (or (equal? "arm32le" machine)
                     (and machine
                          (member (substring machine 0 2) '("i3" "a6"))
                          (or-map (cut string-suffix? <> machine)
                                  '("le" "nt" "osx"))))))
             %supported-systems))
    (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.")))

(define-public chez-scheme-for-racket
  (package
    (inherit chez-scheme)
    (name "chez-scheme-for-racket")
    (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))
    (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 "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 "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)))

(define-public chez-scheme-for-racket-bootstrap-bootfiles
  (package
    (inherit chez-scheme-bootstrap-bootfiles)
    (name "chez-scheme-for-racket-bootstrap-bootfiles")
    (version (package-version chez-scheme-for-racket))
    (source (package-source chez-scheme-for-racket))
    (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.")))

;;
;; 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/")
                            ("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
                          #$(chez-machine->threaded
                             (nix-system->chez-machine)))
                        (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
                   ;; for bootstrapping, can run without ahead-of-time
                   ;; compilation
                   (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"))))))))))))