guix - Wojtek's customized Guix

about summary
about summary refs log tree commit diff

path: root/tests/base64.scm

diff options

Diffstat (limited to 'tests/base64.scm')

0 files changed, 0 insertions, 0 deletions

nd loader.) ;; ;; As of Chez Scheme 10.0.0 (and the pre-release versions that preceded it on ;; the Racket branch), there are several ways to obtain boot files: ;; ;; 1. The Racket package "cs-bootstrap" (in the "racket/src/rktboot/" ;; directory of the main Racket Git repository) simulates enough of Chez ;; Scheme to load the Chez Scheme compiler purely from source into Racket ;; and apply the compiler to itself, producing the needed boot files ;; (albeit very slowly). ;; Any variant of Racket since version 7.1 can run the simulation. Using ;; the older Racket BC implementation, which does not depend on Chez ;; Scheme, breaks the dependency cycle. ;; However, the simulation relies on implementation details of Chez ;; Scheme, so a given version of Chez Scheme can only be bootstrapped by ;; the corresponding version of the "cs-bootstrap" package. ;; ;; 2. The Chez Scheme makefile provides a "re.boot" target for bootstrapping ;; via a different version of Chez Scheme (9.5.4 or later). ;; This path manages potential differences in implementation details ;; across Chez Scheme versions using a strategy similar to "cs-bootstrap", ;; but the compatibility shim is maintained with the Chez Scheme source ;; code (in "s/reboot.ss"). Also, it's faster, since less indirection is ;; needed. ;; ;; 3. For cross-compilation, or with an extremely similar Chez Scheme, the ;; makefile provides "cross.boot" and related targets. ;; ;; 4. The Chez Scheme Git repository includes pre-built "pb" (portable ;; bytecode) boot files, which can be used for bootstrapping on any ;; platform, but these binary files are removed from the source Guix uses. ;; ;; Concretely, we use racket-vm-bc to bootstrap chez-scheme-for-racket, which ;; we then use to bootstrap both chez-scheme and racket-vm-cs. ;; ;; In principle, it would be possible instead to use chez-scheme to bootstrap ;; chez-scheme-for-racket. However, since Racket is ultimately used for ;; bootstrapping, chez-scheme would still need to be rebuilt when Racket ;; changes, whereas treating chez-scheme as a leaf avoids having to rebuild ;; Racket when upstream Chez Scheme changes. Furthermore, since "cs-bootstrap" ;; is developed in the Racket source repository, we don't have to look for the ;; version of "cs-bootstrap" compatible with the upstream Chez Scheme release. ;; ;; Code: (define-deprecated (chez-scheme-for-system #:optional system) chez-scheme "Returns 'chez-scheme'." chez-scheme) (define* (target-chez-arch #:optional (system (or (%current-target-system) (%current-system)))) "Return a string representing the architecture of SYSTEM as used in Chez Scheme machine types, or '#f' if none is defined." (cond ((target-x86-64? system) "a6") ((target-x86-32? system) "i3") ((target-aarch64? system) "arm64") ((target-arm32? system) "arm32") ((target-ppc64le? system) #f) ((target-ppc32? system) "ppc32") ((target-riscv64? system) "rv64") ((string-prefix? "loongarch64-" system) "la64") (else #f))) (define* (target-chez-os #:optional (system (or (%current-target-system) (%current-system)))) "Return a string representing the operating system kernel of SYSTEM as used in Chez Scheme machine types, or '#f' if none is defined." ;; e.g. "le" includes both GNU/Linux and Android (cond ((target-linux? system) "le") ((target-hurd? system) "gnu") ((target-mingw? system) "nt") ;; missing (guix utils) predicates ;; cf. https://github.com/NixOS/nixpkgs/blob/master/lib/systems/doubles.nix ((string-suffix? "-darwin" system) "osx") ((string-suffix? "-freebsd" system) "fb") ((string-suffix? "-openbsd" system) "ob") ((string-suffix? "-netbsd" system) "nb") ;; Nix says "x86_64-solaris", but accommodate "-solaris2" ((string-contains system "solaris") "s2") ((string-suffix? "-qnx" system) "qnx") ;; unknown (else #f))) (define-syntax define-machine-types (lambda (stx) (syntax-case stx (any) ((_ any id0 id ...) #`(define #,(datum->syntax #'id0 '%machine-types) '(id0 id ...)))))) ;; The following is copied from s/cmacros.ss, line 36, in the Chez source (define-machine-types any pb tpb pb32l tpb32l pb32b tpb32b pb64l tpb64l pb64b tpb64b i3nt ti3nt i3osx ti3osx i3le ti3le i3fb ti3fb i3ob ti3ob i3nb ti3nb i3s2 ti3s2 i3qnx ti3qnx i3gnu ti3gnu a6nt ta6nt a6osx ta6osx a6le ta6le a6fb ta6fb a6ob ta6ob a6nb ta6nb a6s2 ta6s2 ppc32osx tppc32osx ppc32le tppc32le ppc32fb tppc32fb ppc32ob tppc32ob ppc32nb tppc32nb arm32le tarm32le arm32fb tarm32fb arm32ob tarm32ob arm32nb tarm32nb arm64nt tarm64nt arm64osx tarm64osx arm64le tarm64le arm64fb tarm64fb arm64ob tarm64ob arm64nb tarm64nb rv64le trv64le rv64fb trv64fb rv64ob trv64ob rv64nb trv64nb la64le tla64le ) (define* (nix-system->pbarch-machine-type #:optional (system (or (%current-target-system) (%current-system))) #:key (threads? #t)) "Return a string naming the Chez Scheme machine type of the appropriate ``pbarch'' backend for SYSTEM: that is, the ``portable bytecode'' backend specialized for SYSTEM's word size and endianness. The result will name the threaded machine type unless THREADS? is provided as #f." (string-append (if threads? "t" "") "pb" (if (target-64bit? system) "64" "32") (if (target-little-endian? system) "l" "b"))) (define* (nix-system->native-chez-machine-type #:optional (system (or (%current-target-system) (%current-system))) #:key (threads? #t)) "Return a string naming the Chez Scheme machine type of the native-code backend for SYSTEM, if such a native-code backend exists. Otherwise, when SYSTEM can use only the ``portable bytecode'' backends, return #f. The result will name the threaded machine type unless THREADS? is provided as #f." (let* ((chez-arch (target-chez-arch system)) (chez-os (target-chez-os system)) (machine (and chez-arch chez-os (string-append (if threads? "t" "") chez-arch chez-os)))) (and machine (memq (string->symbol machine) %machine-types) machine))) ;; ;; Chez Scheme: ;; (define unpack-nanopass #~(lambda* (#:key inputs native-inputs #:allow-other-keys) (with-directory-excursion (if (directory-exists? "racket/src/ChezScheme") "racket/src/ChezScheme" ".") (symlink (dirname (search-input-file (or native-inputs inputs) "lib/chez-scheme/nanopass.ss")) "nanopass")))) (define chez-configure ;; The custom Chez 'configure' script doesn't allow unrecognized flags, such ;; as those automatically added by `gnu-build-system`. This replacement ;; phase uses only the explicitly provided `#:configure-flags`. #~(lambda* (#:key inputs (configure-flags '()) out-of-source? #:allow-other-keys) (let* ((abs-srcdir (getcwd)) (srcdir (if out-of-source? (string-append "../" (basename abs-srcdir)) "."))) (format #t "source directory: ~s (relative from build: ~s)~%" abs-srcdir srcdir) (when out-of-source? (begin (mkdir "../build") (chdir "../build"))) (format #t "build directory: ~s~%" (getcwd)) (format #t "configure flags: ~s~%" configure-flags) (apply invoke (string-append srcdir "/configure") configure-flags)))) (define-public chez-scheme-for-racket (package (name "chez-scheme-for-racket") ;; The version should match `(scheme-version #t)`. ;; See s/cmacros.ss c. line 360. (version "10.1.0-pre-release.1") (source #f) (build-system gnu-build-system) (inputs `(,@(if (nix-system->native-chez-machine-type) '() (list libffi)) ,chez-scheme-for-racket-bootstrap-bootfiles ,lz4 ,ncurses ;<-- for expeditor ,zlib)) (native-inputs `(,@(if (%current-target-system) (list this-package `(,this-package "doc")) (list stex-bootstrap (texlive-updmap.cfg (list texlive-enumitem texlive-etoolbox)))) ,chez-nanopass-bootstrap ,zuo)) (native-search-paths (list (search-path-specification (variable "CHEZSCHEMELIBDIRS") (files '("lib/chez-scheme"))))) (outputs '("out" "debug" "doc")) (arguments (list #:modules '((guix build gnu-build-system) (guix build utils) (ice-9 ftw) (ice-9 match) (srfi srfi-34)) #:out-of-source? #t #:test-target "test" ; test-one test-some-fast test-some test test-more #:configure-flags #~`(,@(let* ((chez+version (strip-store-file-name #$output)) (doc-dir (string-append #$output:doc "/share/doc/" chez+version))) (list (string-append "--installcsug=" doc-dir "/csug") (string-append "--installreleasenotes=" doc-dir "/release_notes"))) ,(string-append "--installprefix=" #$output) #$@(if (%current-target-system) (list (string-append "--toolprefix=" (%current-target-system) "-")) '()) ,@(if (false-if-exception (search-input-directory %build-inputs "/include/X11")) '() '("--disable-x11")) #$(string-append "-m=" (or (nix-system->native-chez-machine-type) (nix-system->pbarch-machine-type))) ;; ^ could skip -m= for non-cross non-pbarch builds #$@(if (nix-system->native-chez-machine-type) #~() ;; not inferred on non-native platforms: see ;; https://racket.discourse.group/t/950/9 #~("--enable-libffi" "CFLAGS+=-g -D_REENTRANT -pthread" "LIBS+=-lm -ldl -lrt -lncurses")) ,(string-append "STEXLIB=" (or (false-if-exception (search-input-directory %build-inputs "/lib/stex")) "/GuixNotUsingStex")) "ZUO=zuo" "ZLIB=-lz" "LZ4=-llz4" ;; Guix will do 'compress-man-pages', ;; and letting Chez try caused an error (at one point) "--nogzip-man-pages") #:phases #~(modify-phases %standard-phases (replace 'unpack (let ((unpack (assoc-ref %standard-phases 'unpack))) (lambda args (unpack #:source #$(or (package-source this-package) (package-source racket-vm-bc)))))) (add-after 'unpack 'unpack-nanopass #$unpack-nanopass) (add-after 'unpack-nanopass 'maybe-chdir (lambda args (when (directory-exists? "racket/src/ChezScheme") (chdir "racket/src/ChezScheme")))) (add-after 'maybe-chdir 'unpack-bootfiles (lambda* (#:key native-inputs inputs #:allow-other-keys) (when (directory-exists? "boot") (delete-file-recursively "boot")) (copy-recursively (search-input-directory inputs "lib/chez-scheme-bootfiles") "boot"))) (replace 'configure #$chez-configure) (add-after 'configure 'configure-environment-variables (lambda args ;; mats/6.ms needs HOME to be set: (setenv "HOME" "/tmp"))) (replace 'build ;; need to override target for cross-compilation ;; https://racket.discourse.group/t/950/19 (let ((gnu:build (assoc-ref %standard-phases 'build))) (lambda* (#:key target (make-flags '()) (parallel-build? #t) #:allow-other-keys) (gnu:build #:make-flags (if target (cons "kernel" make-flags) make-flags) #:parallel-build? parallel-build?)))) (add-before 'check 'build-docs ;; Building the documentation requires stex and a running scheme. ;; This comes BEFORE 'check because the test suite may take on the ;; order of an hour (without parallelism), so we want to get any ;; other errors first. ;; TODO: Improve cross support upstream: currently, it tries to ;; run the cross-compiled scheme. (lambda* (#:key native-inputs (make-flags '()) #:allow-other-keys) #$(if (%current-target-system) #~(format #t "not building docs for cross~%") #~(apply invoke "make" "docs" make-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* ((bin-dir (dirname (search-input-file outputs "/bin/scheme"))) (boot-dir (match (find-files (string-append bin-dir "/../lib") "scheme.boot") ((scheme.boot) (dirname scheme.boot))))) (for-each (lambda (dir) (with-directory-excursion dir (symlink "./scheme" "chez-scheme") (when (file-exists? "scheme.boot") (symlink "./scheme.boot" "chez-scheme.boot")))) (list bin-dir boot-dir))))) (add-after 'install-symlink 'install-docs ;; TODO: Improve cross support upstream. ;; The `install-docs` target has a Zuo dependency on the `docs` ;; target, so we have the same problem as the build-docs phase. (lambda* (#:key native-inputs (make-flags '()) #:allow-other-keys) #$(if (%current-target-system) #~(let* ((rel (string-append "share/doc/" (strip-store-file-name #$output))) (found/csug (search-input-directory native-inputs (string-append rel "/csug"))) (found (substring found/csug 0 (- (string-length found/csug) (string-length "/csug")))) (dest (string-append #$output:doc "/" rel))) (mkdir-p dest) (with-directory-excursion dest (for-each (lambda (f) (symlink (string-append found "/" f) f)) '("csug" "csug.pdf" "release_notes" "release_notes.pdf")))) #~(apply invoke "make" "install-docs" make-flags)))) (add-after 'install-docs 'link-doc-pdfs ;; otherwise, it's hard to notice them in a forest of HTML files ;; TODO: improve cross support upstream. (lambda* (#:key outputs #:allow-other-keys) #$(if (%current-target-system) #~(format #t "nothing to be done for cross~%") #~(with-directory-excursion (string-append (or (assoc-ref outputs "doc") (assoc-ref outputs "out")) "/share/doc/" (strip-store-file-name #$output)) (symlink "release_notes/release_notes.pdf" "release_notes.pdf") (match (find-files "csug" "csug.*\\.pdf$" ;; embeded version number #:fail-on-error? #t) ((pth) (symlink pth "csug.pdf")))))))))) (home-page "https://cisco.github.io/ChezScheme/") (synopsis "Bootstrapping version of Chez Scheme") (description "This is the precise pre-release version of Chez Scheme from a specific Racket release. It is used to build Racket and to bootstrap the released version of Chez Scheme.") (license asl2.0))) (define-public chez-scheme (package (inherit chez-scheme-for-racket) (name "chez-scheme") ;; The version should match `(scheme-version-number #t)`. ;; See s/cmacros.ss c. line 360. (version "10.0.0") (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/cisco/ChezScheme") (commit (string-append "v" version)))) (sha256 (base32 "1q66vafhiwk617z51qkm1v64r3bxqhhf5lzrmsa4l9d5yhvlyk09")) (file-name (git-file-name name version)) (patches (search-patches "chez-scheme-backport-configure.patch" "chez-scheme-backport-signal.patch" "chez-scheme-bin-sh.patch")) (snippet #~(begin (use-modules (guix build utils)) ;; TODO: consider putting this in a (guix ...) or ;; (guix build ...) module so it can be shared ;; with the Racket origin without cyclic issues. (for-each (lambda (dir) (when (directory-exists? dir) (delete-file-recursively dir))) '("boot" "lz4" "nanopass" "stex" "zlib" "zuo")))))) (build-system gnu-build-system) (inputs (modify-inputs (package-inputs chez-scheme-for-racket) (replace "chez-scheme-for-racket-bootstrap-bootfiles" chez-scheme-bootstrap-bootfiles) ;; for X11 clipboard support in expeditor: ;; https://github.com/cisco/ChezScheme/issues/9#issuecomment-222057232 (prepend libx11))) ;; replace unpack phase? (home-page "https://cisco.github.io/ChezScheme/") (synopsis "R6RS Scheme compiler and run-time") (description "Chez Scheme is both a programming language and a high-performance implementation of that language. The language is a superset of R6RS Scheme with numerous extensions, including native threads, non-blocking I/O, local modules, and much more. Chez Scheme compiles source expressions incrementally to machine code, providing the speed of compiled code in an interactive system. The system is intended to be as reliable and efficient as possible, with reliability taking precedence over efficiency if necessary.") (license asl2.0))) ;; ;; Bootfiles: ;; (define-public chez-scheme-for-racket-bootstrap-bootfiles (package (name "chez-scheme-for-racket-bootstrap-bootfiles") (version (package-version chez-scheme-for-racket)) (source #f) ; avoid problematic cycle with racket.scm (native-inputs (cons chez-nanopass-bootstrap (if (%current-target-system) (list zuo chez-scheme-for-racket) (list racket-vm-bc)))) (build-system copy-build-system) (arguments (list #:install-plan #~`(("boot/" "lib/chez-scheme-bootfiles")) #:phases #~(modify-phases %standard-phases (replace 'unpack (let ((unpack (assoc-ref %standard-phases 'unpack))) (lambda args (unpack #:source #$(or (package-source this-package) (package-source racket-vm-bc)))))) (add-after 'unpack 'unpack-nanopass #$unpack-nanopass) (add-after 'unpack-nanopass 'chdir (lambda args (chdir "racket/src/ChezScheme"))) (add-before 'install 'build #$(cond ((%current-target-system) ;; cross-compiling ;; TODO: share more of this with upstream, once we figure out ;; how best to manage running Chez as a cross-compiler and the ;; unfortate cycle with %racket-origin. #~(lambda* (#:key native-inputs inputs (parallel-build? #t) #:allow-other-keys) (invoke "./configure" "--force" ; don't complain about missing bootfiles #$(string-append "-m=" (or (nix-system->native-chez-machine-type) (nix-system->pbarch-machine-type))) "ZUO=zuo" ;; ignore submodules: "ZLIB=-lz" "LZ4=-llz4" "STEXLIB=/GuixNotUsingStex") (apply invoke "make" `(,@(if parallel-build? `("-j" ,(number->string (parallel-job-count))) '()) ,(string-append "SCHEME=" (search-input-file (or native-inputs inputs) "/bin/scheme")) "cross.boot")))) (else ;; bootstrapping #~(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://pkgs.racket-lang.org/package/cs-bootstrap") (synopsis "Chez Scheme boot files bootstrapped by Racket") (description "Chez Scheme is a self-hosting compiler: building it requires ``boot files'' containing the Scheme-implemented portions compiled for the current platform. (Chez can then cross-compile boot files 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.") (license asl2.0))) (define-public chez-scheme-bootstrap-bootfiles (package (name "chez-scheme-bootstrap-bootfiles") (version (package-version chez-scheme)) (source (package-source chez-scheme)) (native-inputs (list chez-nanopass-bootstrap (if (%current-target-system) chez-scheme chez-scheme-for-racket) zuo)) (outputs '("out")) (build-system gnu-build-system) (arguments (list #:configure-flags #~`("--force" ; don't complain about missing bootfiles "ZLIB=-lz" "LZ4=-llz4" "STEXLIB=/GuixNotUsingStex" ; ignore submods "ZUO=zuo" ;; could skip -m= for non-cross non-pbarch builds #$(string-append "-m=" (or (nix-system->native-chez-machine-type) (nix-system->pbarch-machine-type)))) #:make-flags #~(list (string-append "SCHEME=" (search-input-file %build-inputs "/bin/scheme")) #$(if (%current-target-system) "cross.boot" "re.boot")) #:phases #~(modify-phases %standard-phases (add-after 'unpack 'unpack-nanopass #$unpack-nanopass) (replace 'configure #$chez-configure) (delete 'check) (replace 'install (lambda args (mkdir-p (string-append #$output "/lib")) (copy-recursively "boot" (string-append #$output "/lib/chez-scheme-bootfiles"))))))) (home-page "https://cisco.github.io/ChezScheme/") (synopsis "Bootstrapped Chez Scheme boot files") (description "Chez Scheme is a self-hosting compiler: building it requires ``boot files'' containing the Scheme-implemented portions compiled for the current platform. (Chez can then cross-compile bootfiles for all other supported platforms.) This package provides boot files for the released version of Chez Scheme bootstrapped by @code{chez-scheme-for-racket}. Chez Scheme 9.5.4 or any later version can be used for bootstrapping. Guix ultimately uses the Racket package @code{cs-bootstrap} to bootstrap its initial version of Chez Scheme.") (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 "afa607564a5662ffd748e824801277a6b5a3d11c") (revision "2")) (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 "0n6dryv5j7cw2qmsj55wqb0ph901h83a2hl4j891ppxp0xx18nkp")) (file-name (git-file-name name version)) (patches ;; submitted upstream in https://github.com/dybvig/stex/pull/6 (search-patches "stex-copy-from-immutable-store.patch")) (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-epsf)) 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/")) #:modules '((guix build copy-build-system) (guix build utils) (ice-9 popen)) #: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 (let ((pipe (open-pipe* OPEN_BOTH scheme "-q"))) ;; try to not be wrong for cross-compilation ;; (avoid #% reader abbreviation for Guile) (write '(($primitive $target-machine)) pipe) (force-output pipe) (let ((sym (read pipe))) (close-pipe pipe) (symbol->string sym)))) (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 embedded 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 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 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")))))))))))) ;; ;; Other Chez packages: ;; ;; Help function for Chez Scheme to add the current path to ;; CHEZSCHEMELIBDIRS. (define configure-chezschemelibdirs #~(lambda _ (let ((chez-env (getenv "CHEZSCHEMELIBDIRS"))) (setenv "CHEZSCHEMELIBDIRS" (if chez-env (string-append ".:" chez-env) "."))))) ;; Help function to define make flags for some Chez Scheme custom make ;; files. (define (chez-make-flags name version) #~(let ((out #$output)) (list ;; Set 'schemedir' so that libraries are installed in ;; 'lib/chez-scheme' like Chez's 'native-search-paths' expects. (string-append "schemedir=" out "/lib/chez-scheme") (string-append "PREFIX=" out) (string-append "DOCDIR=" out "/share/doc/" #$name "-" #$version)))) (define-public chez-srfi (package (name "chez-srfi") (version "1.0") (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/fedeinthemix/chez-srfi") (commit (string-append "v" version)))) (sha256 (base32 "1vgn984mj2q4w6r2q66h7qklp2hrh85wwh4k9yisga5fi0ps7myf")) (file-name (git-file-name name version)))) (build-system gnu-build-system) (native-inputs (list chez-scheme)) (arguments (list #:make-flags (chez-make-flags name version) #:test-target "test" #:phases #~(modify-phases %standard-phases (replace 'configure #$configure-chezschemelibdirs)))) (home-page "https://github.com/fedeinthemix/chez-srfi") (synopsis "SRFI libraries for Chez Scheme") (description "This package provides a collection of SRFI libraries for Chez Scheme.") (license expat))) (define-public chez-web (let ((commit "5fd177fe53f31f466bf88720d03c95a3711a8bea") (revision "1")) (package (name "chez-web") ;; Release 2.0 is different and doesn't work. (version (git-version "2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/arcfide/ChezWEB") (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 "1dq25qygyncbfq4kwwqqgyyakfqjwhp5q23vrf3bff1p66nyfl3b")))) (build-system gnu-build-system) (native-inputs (list chez-scheme ghostscript (texlive-updmap.cfg (list texlive-charter texlive-context texlive-cweb texlive-metapost)))) (arguments (list #:make-flags #~(list (string-append "PREFIX=" #$output) (string-append "DOCDIR=" #$output "/share/doc/" #$name "-" #$version) ;; lib/chez-scheme/chezweb ??? (string-append "LIBDIR=" #$output "/lib/chezweb") (string-append "TEXDIR=" #$output "/share/texmf-local")) #:tests? #f ; no tests #:phases #~(modify-phases %standard-phases (add-after 'unpack 'fix-tex-input (lambda _ ;; Fix "I can't find file `supp-pdf'." error. (substitute* "chezweb.w" (("supp-pdf") "supp-pdf.mkii")) ;; Recent cweb packages do not include "\acrofalse". Remove ;; it. (substitute* "doc/cwebman.tex" (("\\acrofalse.*") "")))) ;; This package has a custom "bootstrap" script that ;; is meant to be run from the Makefile. (delete 'bootstrap) (replace 'configure (lambda* _ (copy-file "config.mk.template" "config.mk") (substitute* "tangleit" (("\\./cheztangle\\.ss" all) (string-append "scheme --program " all))) (substitute* "weaveit" (("mpost chezweb\\.mp") "mpost --tex=tex chezweb.mp") (("\\./chezweave" all) (string-append "scheme --program " all))) (substitute* "installit" (("-g \\$GROUP -o \\$OWNER") ""))))))) (home-page "https://github.com/arcfide/ChezWEB") (synopsis "Hygienic Literate Programming for Chez Scheme") (description "ChezWEB is a system for doing Knuthian style WEB programming in Scheme.") (license expat)))) (define-public chez-sockets (let ((commit "bce96881c06bd69a6757a6bff139744153924140") (revision "1")) (package (name "chez-sockets") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/arcfide/chez-sockets") (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 "1n5fbwwz51fdzvjackgmnsgh363g9inyxv7kmzi0469cwavwcx5m")))) (build-system gnu-build-system) (native-inputs (list chez-scheme chez-web (texlive-updmap.cfg))) (arguments (list #:tests? #f ; no tests #:phases #~(modify-phases %standard-phases (replace 'configure (lambda* (#:key native-inputs inputs #:allow-other-keys) (let* ((scheme (search-input-file (or native-inputs inputs) "/bin/scheme")) (lib (string-append (dirname scheme) "/../lib")) (header-file (car (find-files lib "scheme\\.h"))) (include-dir (dirname header-file))) (substitute* "Makefile" (("(SCHEMEH=).*$" _ var) (string-append var include-dir)))))) (add-before 'build 'tangle (lambda* (#:key inputs #:allow-other-keys) (setenv "TEXINPUTS" (string-append (getcwd) ":" (assoc-ref inputs "chez-web") "/share/texmf-local/tex/generic:" ":")) ;; just using "make" tries to build the .c files before ;; they are created. (and (invoke "make" "sockets") (invoke "make")))) (replace 'build (lambda args (let ((chez-site (string-append #$output "/lib/chez-scheme/arcfide"))) ;; make sure Chez Scheme can find the shared libraries. (substitute* "sockets.ss" (("(object \")(socket-ffi-values\\.[sd][oy][^\"]*)(\")" _ pre file post) (string-append pre chez-site "/" file post)) (("(\")(sockets-stub\\.[sd][oy][^\"]*)(\")" _ pre file post) (string-append pre chez-site "/" file post))) ;; to compile chez-sockets, the .so files must be ;; installed (because of the absolute path we ;; inserted above). (for-each (lambda (f) (install-file f chez-site)) '("socket-ffi-values.so" "sockets-stub.so")) (invoke "bash" "-c" (format #f "echo '~s' | scheme -q" '(compile-file "sockets.sls")))))) (replace 'install (lambda args (install-file "sockets.so" (string-append #$output "/lib/chez-scheme/arcfide")) (install-file "sockets.pdf" (string-append #$output "/share/doc/" #$name "-" #$version))))))) (home-page "https://github.com/arcfide/chez-sockets") (synopsis "Extensible sockets library for Chez Scheme") (description "Chez-sockets is an extensible sockets library for Chez Scheme.") (license expat)))) (define-public chez-matchable (package (name "chez-matchable") (version "20160306") (home-page "https://github.com/fedeinthemix/chez-matchable") (source (origin (method git-fetch) (uri (git-reference (url home-page) (commit (string-append "v" version)))) (sha256 (base32 "02qn7x348p23z1x5lwhkyj7i8z6mgwpzpnwr8dyina0yzsdkr71s")) (file-name (git-file-name name version)))) (build-system gnu-build-system) (inputs (list chez-srfi)) ; for tests (native-inputs (list chez-scheme)) (arguments (list #:make-flags (chez-make-flags name version) #:test-target "test" #:phases #~(modify-phases %standard-phases (replace 'configure #$configure-chezschemelibdirs)))) (synopsis "Portable hygienic pattern matcher for Scheme") (description "This package provides a superset of the popular Scheme @code{match} package by Andrew Wright, written in fully portable @code{syntax-rules} and thus preserving hygiene.") (license public-domain))) (define-public chez-irregex (package (name "chez-irregex") (version "0.9.4") (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/fedeinthemix/chez-irregex") (commit (string-append "v" version)))) (sha256 (base32 "0jh6piylw545j81llay9wfivgpv6lcnwd81gm4w17lkasslir50q")) (file-name (git-file-name name version)))) (build-system gnu-build-system) (inputs (list chez-matchable)) ; for tests (propagated-inputs (list chez-srfi)) ; for irregex-utils (native-inputs (list chez-scheme)) (arguments (list #:make-flags (chez-make-flags name version) #:test-target "test" #:phases #~(modify-phases %standard-phases (replace 'configure #$configure-chezschemelibdirs)))) (home-page "https://github.com/fedeinthemix/chez-irregex") (synopsis "Portable regular expression library for Scheme") (description "This package provides a portable and efficient R[4567]RS implementation of regular expressions, supporting both POSIX syntax with various (irregular) PCRE extensions, as well as SCSH's SRE syntax, with various aliases for commonly used patterns.") (license bsd-3))) (define-public chez-fmt (package (name "chez-fmt") (version "0.8.11") (source (origin (method url-fetch) (uri (string-append "http://synthcode.com/scheme/fmt/fmt-" version ".tar.gz")) (sha256 (base32 "1zxqlw1jyg85yzclylh8bp2b3fwcy3l3xal68jw837n5illvsjcl")) (file-name (string-append name "-" version ".tar.gz")))) (build-system gnu-build-system) (propagated-inputs (list chez-srfi)) ; for irregex-utils (native-inputs (list chez-scheme)) (arguments (list #:make-flags (chez-make-flags name version) #:test-target "chez-check" #:phases #~(modify-phases %standard-phases (replace 'configure #$configure-chezschemelibdirs) (replace 'build (lambda* (#:key (make-flags '()) #:allow-other-keys) (apply invoke "make" "chez-build" make-flags))) (replace 'install (lambda* (#:key (make-flags '()) #:allow-other-keys) (apply invoke "make" "chez-install" make-flags)))))) (home-page "https://synthcode.com/scheme/fmt") (synopsis "Combinator formatting library for Chez Scheme") (description "This package provides a library of procedures for formatting Scheme objects to text in various ways, and for easily concatenating, composing and extending these formatters efficiently without resorting to capturing and manipulating intermediate strings.") (license bsd-3))) (define-public chez-mit (package (name "chez-mit") (version "0.1") (home-page "https://github.com/fedeinthemix/chez-mit") (source (origin (method git-fetch) (uri (git-reference (url home-page) (commit (string-append "v" version)))) (sha256 (base32 "0c7i3b6i90xk96nmxn1pc9272a4yal4v40dm1a4ybdi87x53zkk0")) (file-name (git-file-name name version)) (snippet ;; Workaround for chez-scheme-for-racket. ;; See: https://github.com/racket/racket/issues/4151 #~(begin (use-modules (guix build utils)) (substitute* "mit/core.sls" (("[(]import ") "(import (only (chezscheme) import)\n") (("[(]define string->uninterned-symbol gensym[)]") (format #f "~s" '(begin (import (only (chezscheme) meta-cond library-exports)) (meta-cond ((memq 'string->uninterned-symbol (library-exports '(chezscheme))) (import (only (chezscheme) string->uninterned-symbol))) (else (define string->uninterned-symbol gensym))))))))))) (build-system gnu-build-system) (inputs (list chez-srfi)) ; for tests (native-inputs (list chez-scheme)) (arguments (list #:make-flags (chez-make-flags name version) #:test-target "test" #:phases #~(modify-phases %standard-phases (replace 'configure #$configure-chezschemelibdirs)))) (synopsis "MIT/GNU Scheme compatibility library for Chez Scheme") (description "This package provides a set of MIT/GNU Scheme compatibility libraries for Chez Scheme. The main goal was to provide the functionality required to port the program @code{Scmutils} to Chez Scheme.") (license gpl3+))) (define-public chez-scmutils (package (name "chez-scmutils") (version "0.1") (home-page "https://github.com/fedeinthemix/chez-scmutils") (source (origin (method git-fetch) (uri (git-reference (url home-page) (commit (string-append "v" version)))) (sha256 (base32 "0lb05wlf8qpgg8y0gdsyaxg1nbfx1qbaqdjvygrp64ndn8fnhq7l")) (file-name (git-file-name name version)))) (build-system gnu-build-system) (inputs (list chez-srfi)) ; for tests (native-inputs (list chez-scheme)) (propagated-inputs (list chez-mit chez-srfi)) (arguments (list #:make-flags (chez-make-flags name version) #:tests? #f ; no test suite #:phases #~(modify-phases %standard-phases (replace 'configure #$configure-chezschemelibdirs) ;; Since the documentation is lacking, we install the source ;; code. For things to work correctly we have to replace ;; relative paths by absolute ones in 'include' forms. This ;; in turn requires us to compile the files in the final ;; destination. (delete 'build) (add-after 'install 'install-src (lambda* (#:key (make-flags '()) #:allow-other-keys) (apply invoke "make" "install-src" make-flags))) (add-after 'install-src 'absolute-path-in-scm-files (lambda* (#:key #:allow-other-keys) (for-each (lambda (file) (substitute* file (("include +\"\\./scmutils") (string-append "include \"" (dirname file))))) (find-files #$output "\\.sls")) (for-each (lambda (file) (substitute* file (("include +\"\\./scmutils/simplify") (string-append "include \"" (dirname file))))) (find-files #$output "fbe-syntax\\.scm")))) (add-after 'absolute-path-in-scm-files 'build (lambda* (#:key (make-flags '()) #:allow-other-keys) (let ((mk-file (car (find-files #$output "Makefile")))) (with-directory-excursion (dirname mk-file) (apply invoke "make" "build" make-flags))))) (add-after 'build 'clean-up (lambda args (for-each delete-file (find-files #$output "Makefile|compile-all\\.ss"))))))) (synopsis "Port of MIT/GNU Scheme Scmutils to Chez Scheme") (description "This package provides a port of the MIT/GNU Scheme Scmutils program to Chez Scheme. The port consists of a set of libraries providing most of the functionality of the original.") (license gpl3+)))


context:
space:
mode: