core: eval_apply profile.
[mes.git] / configure
index 8bace5daa88ce83f7bcf27b6f883bb568d3e5e7f..5cf1789ad1a56b1628b824d6c6ebbb5af70ca17e 100755 (executable)
--- a/configure
+++ b/configure
@@ -1,62 +1,67 @@
 #! /bin/sh
 # -*- scheme -*-
 unset LANG LC_ALL
-echo -n "checking for guile..."
-GUILE=$(type -p ${GUILE-guile} 2>/dev/null|tail -n 1|sed 's,^.* ,,')
-export GUILE
-if [ -x "$GUILE" ]; then
-    echo " $GUILE"
+guile=$(command -v ${GUILE-guile})
+guix=$(command -v ${GUIX-guix})
+if [ -n "$guix" ] ; then
+    install="guix environment -l .guix.scm"
 else
-    pm=$({ guix --help || dpkg --help; }|head -n 1|sed 's,.*Usage: \([^ ]*\).*,\1,g')
-#-paredit:'})(
-    case "$pm" in dpkg) message="sudo apt-get install guile-2.0";; *) message="guix environment guix.scm";; esac
+    install="sudo apt-get install guile-2.2-dev"
+fi
+if [ -z "$guile" ]; then
     cat <<EOF
-Missing dependencies, run
 
-    $pm
+Missing dependencies: ${GUILE-guile}, please install Guile 2.2 or later; run
+    $install
 EOF
-    exit 1
+exit 1
 fi
-exec ${GUILE} --no-auto-compile -L $(pwd) -C $(pwd) -e 'main' -s "$0" ${1+"$@"}
+GUILE=$guile
+export GUILE
+exec ${guile} -L . --no-auto-compile -e '(configure)' -s "$0" ${1+"$@"}
 !#
 
-;;; Mes --- Maxwell Equations of Software
-;;; Copyright © 2016,2017 Jan Nieuwenhuizen <janneke@gnu.org>
+;;; GNU Mes --- Maxwell Equations of Software
+;;; Copyright © 2016,2017,2018 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
 ;;;
-;;; configure: This file is part of Mes.
+;;; configure: This file is part of GNU Mes.
 ;;;
-;;; Mes is free software; you can redistribute it and/or modify it
+;;; GNU Mes 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.
 ;;;
-;;; Mes is distributed in the hope that it will be useful, but
+;;; GNU Mes 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 Mes.  If not, see <http://www.gnu.org/licenses/>.
-
-(define (main args)
-  ((@@ (configure) main) args))
+;;; along with GNU Mes.  If not, see <http://www.gnu.org/licenses/>.
 
 (define-module (configure)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-9)
+  #:use-module (srfi srfi-9 gnu)
+  #:use-module (srfi srfi-26)
   #:use-module (ice-9 and-let-star)
   #:use-module (ice-9 curried-definitions)
   #:use-module (ice-9 getopt-long)
   #:use-module (ice-9 match)
   #:use-module (ice-9 optargs)
   #:use-module (ice-9 popen)
-  #:use-module (ice-9 rdelim))
+  #:use-module (ice-9 rdelim)
+  #:use-module (ice-9 regex)
+  #:export (main))
+
+(define* (PATH-search-path name #:key (default name) warn?)
+  (or (search-path (string-split (getenv "PATH") #\:) name)
+      (and (and warn? (format (current-error-port) "warning: not found: ~a\n" name))
+           default)))
 
 (define *shell* "sh")
 (define PACKAGE "mes")
-(define VERSION "0.8")
-(define PREFIX "/usr/local")
-(define GUILE_EFFECTIVE_VERSION (effective-version))
-(define GUILE (or (getenv "guile") "guile"))
-(define SYSCONFDIR "$(PREFIX)/etc")
+(define VERSION "0.18")
 
 ;;; Utility
 (define (logf port string . rest)
@@ -70,10 +75,10 @@ exec ${GUILE} --no-auto-compile -L $(pwd) -C $(pwd) -e 'main' -s "$0" ${1+"$@"}
 (define (stdout string . rest)
   (apply logf (cons* (current-output-port) string rest)))
 
-(define *verbose?* #f)
+(define %verbose? #f)
 
 (define (verbose string . rest)
-  (if *verbose?* (apply stderr (cons string rest))))
+  (if %verbose? (apply stderr (cons string rest))))
 
 (define (gulp-pipe command)
   (let* ((port (open-pipe* OPEN_READ *shell* "-c" command))
@@ -105,7 +110,49 @@ exec ${GUILE} --no-auto-compile -L $(pwd) -C $(pwd) -e 'main' -s "$0" ${1+"$@"}
 (define (tuple<= a b)
   (or (equal? a b) (tuple< a b)))
 
+(define (conjoin . predicates)
+  (lambda (. arguments)
+    (every (cut apply <> arguments) predicates)))
+
+(define (char->char from to char)
+  (if (eq? char from) to char))
+
+(define (string-replace-char string from to)
+  (string-map (cut char->char from to <>) string))
+
 ;;; Configure
+
+(define-immutable-record-type <dependency>
+  (make-depedency name version-expected optional? version-option commands file-name)
+  dependency?
+  (name dependency-name)
+  (version-expected dependency-version-expected)
+  (version-option dependency-version-option)
+  (optional? dependency-optional?)
+  (commands dependency-commands)
+  (file-name dependency-file-name)
+  (version-found dependency-version-found))
+
+(define* (make-dep name #:optional (version '(0))
+                   #:key optional? (version-option "--version") (commands (list name)) file-name)
+  (let* ((env-var (getenv (name->shell-name name)))
+         (commands (if env-var (cons env-var commands) commands)))
+   (make-depedency name version optional? version-option commands file-name)))
+
+(define (find-dep name deps)
+  (find (compose (cut equal? <> name) dependency-name) deps))
+
+(define (file-name name deps)
+  (and=> (find-dep name deps) dependency-file-name))
+
+(define (variable-name dependency)
+  (and=>
+   (dependency-name dependency)
+   name->shell-name))
+
+(define (name->shell-name name)
+  (string-upcase (string-replace-char name #\- #\_)))
+
 (define (version->string version)
   ((->string '.) version))
 
@@ -119,62 +166,45 @@ exec ${GUILE} --no-auto-compile -L $(pwd) -C $(pwd) -e 'main' -s "$0" ${1+"$@"}
                                        (char-set-complement (char-set #\.)))))
             (map string->number version)))
 
-(define optional '())
-(define required '())
-(define* (check-version name expected
-                        #:key
-                        optional?
-                        (deb #f)
-                        (version-option '--version)
-                        (compare tuple<=)
-                        (command name))
-  (stderr "checking for ~a~a..." name
-          (if (null? expected) ""
-              (format #f " [~a]" (version->string expected))))
-  (let* ((output (gulp-pipe (format #f "~a ~a 2>&1" command version-option)))
-         (actual (string->version output))
-         (pass? (and actual (compare expected actual))))
-    (stderr "~a ~a\n" (if pass? (if (pair? actual) "" " yes")
-                          (if actual " no, found" "")) (version->string actual))
-    (or pass?
-        (if (not (pair? name)) (begin (if optional? (set! optional (cons (or deb name) optional))
-                                          (set! required (cons (or deb name) required)))
-                                      pass?)
-            (check-version (cdr name) expected deb version-option compare)))))
-
-(define* (check-pkg-config package expected #:optional (deb #f))
-  (check-version (format #f "pkg-config --modversion ~a" package) expected deb))
-
-(define (check-compile-header-c header)
-  (and (= 0 (system (format #f "echo '#include ~s' | gcc -E - > /dev/null 2>&1" header)))
-       'yes))
-
-(define (check-compile-header-c++ header)
-  (and (= 0 (system (format #f "echo '#include ~s' | gcc --language=c++ --std=c++11 -E - > /dev/null 2>&1" header)))
-       'yes))
+(define (check-program-version dependency)
+  (let ((name (dependency-name dependency))
+        (expected (dependency-version-expected dependency))
+        (version-option (dependency-version-option dependency))
+        (commands (dependency-commands dependency)))
+    (let loop ((commands commands))
+      (if (null? commands) dependency
+          (let ((command (car commands)))
+            (stdout "checking for ~a~a... " command
+                    (if (null? expected) ""
+                        (format #f " [~a]" (version->string expected))))
+            (let* ((output (gulp-pipe (format #f "~a ~a 2>&1" command version-option)))
+                   (actual (string->version output))
+                   (pass? (and actual (tuple< expected actual)))
+                   (dependency (set-field dependency (dependency-version-found) actual)))
+              (stdout "~a ~a\n" (if pass? (if (pair? actual) "" " yes")
+                                    (if actual " no, found" "no")) (version->string actual))
+              (if pass? (let ((file-name (or (PATH-search-path command)
+                                             (dependency-file-name dependency))))
+                          (set-field dependency (dependency-file-name) file-name))
+                  (loop (cdr commands)))))))))
 
-(define* (check-header-c header deb #:optional (check check-compile-header-c))
-  (stderr "checking for ~a..." header)
-  (let ((result (check header)))
-    (stderr " ~a\n" (if result result "no"))
-    (if (not result)
-        (set! required (cons deb required)))))
+(define (check-file dependency)
+  (stdout "checking for ~a... " (dependency-name dependency))
+  (let ((file-name (and (file-exists? (dependency-file-name dependency))
+                        (dependency-file-name dependency))))
+    (stdout "~a\n" (or file-name ""))
+    (set-field dependency (dependency-file-name) file-name)))
 
-(define* (check-header-c++ header deb #:optional (check check-compile-header-c++))
-  (check-header-c header deb check))
+(define* (check-header-c dependency  #:optional (check check-compile-header-c))
+  (let ((name (dependency-name dependency)))
+    (stderr "checking for ~a..." name)
+    (let ((result (check name)))
+      (stderr " ~a\n" (if result "yes" "no"))
+      (if result (set-field dependency (dependency-file-name) name)
+          dependency-file-name))))
 
-(define guix?
-  (and (zero? (system "guix --version 1>/dev/null 2>/dev/null")) 1))
-;;;
-
-(define CC (or (getenv "CC") "gcc"))
-(define BUILD_TRIPLET %host-type)
-(define ARCH (car (string-split BUILD_TRIPLET #\-)))
-(define CC32 (or (getenv "CC32")
-                 (if (member ARCH '("i686" "arm")) (string-append BUILD_TRIPLET "-" CC)
-                     "i686-unknown-linux-gnu-gcc")))
-(define HEX2 (or (getenv "HEX2") "hex2"))
-(define M1 (or (getenv "M1") "M0"))
+(define (check-compile-header-c header)
+  (zero? (system (format #f "echo '#include ~s' | gcc -E - > /dev/null 2>&1" header))))
 
 (define (parse-opts args)
   (let* ((option-spec
@@ -182,86 +212,303 @@ exec ${GUILE} --no-auto-compile -L $(pwd) -C $(pwd) -e 'main' -s "$0" ${1+"$@"}
             (host (value #t))
             (help (single-char #\h))
             (prefix (value #t))
+            (bindir (value #t))
+            (datadir (value #t))
+            (docdir (value #t))
+            (libdir (value #t))
+            (srcdir (value #t))
             (sysconfdir (value #t))
             (verbose (single-char #\v))
+            (with-cheating)
             (with-courage)
-            ;;ignore
-            (enable-fast-install)))
-         (options (getopt-long args option-spec))
-         (help? (option-ref options 'help #f))
-         (files (option-ref options '() '()))
-         (prefix (option-ref options '() PREFIX))
-         (usage? (and (not help?) #f)))
-    (if (pair? files)
-        (stderr "ignoring files: ~a\n" files))
-    (or (and (or help? usage?)
-             ((or (and usage? stderr) stdout) "\
-Usage: ./configure [OPTION]...
+            (infodir (value #t))
+            (mandir (value #t))
+            (disable-silent-rules)
+            (enable-silent-rules)
+
+            (enable-fast-install)       ; Ignored for Guix
+            (includedir (value #t))     ; Ignored for Debian
+            (mandir (value #t))         ; Ignored for Debian
+            (localstatedir (value #t))  ; Ignored for Debian
+            (libdir (value #t))         ; Ignored for Debian
+            (libexecdir (value #t))     ; Ignored for Debian
+            (runstatedir (value #t))    ; Ignored for Debian
+            (disable-maintainer-mode)   ; Ignored for Debian
+            (disable-dependency-tracking) ; Ignored for Debian
+            )))
+
+    (getopt-long args option-spec)))
+
+(define* (print-help #:optional (port (current-output-port)))
+  (format port "\
+`configure' configures ~a ~a to adapt to many kinds of systems.
+
+Usage: ./configure [OPTION]... [VAR=VALUE]
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Options:
   -h, --help           display this help
       --build=BUILD    configure for building on BUILD [guessed]
+      --disable-silent-rules
+                       verbose build output [BUILD_DEBUG=1]
       --host=HOST      cross-compile to build programs to run on HOST [BUILD]
-  --prefix=DIR         install in PREFIX [~a]
-  --sysconfdir=DIR     read-only single-machine data [PREFIX/etc]
   -v, --verbose        be verbose
   --with-courage       assert being courageous to configure for unsupported platform
-" PREFIX)
-             (exit (or (and usage? 2) 0)))
-        options)))
+  --with-cheating      cheat using Guile instead of Mes
+
+Installation directories:
+  --prefix=DIR         install in prefix DIR [~a]
+  --infodir=DIR        info documentation [PREFIX/share/info]
+  --mandir=DIR         man pages [PREFIX/share/man]
+
+Ignored for Guix:
+  --enable-fast-install
+
+Ignored for Debian:
+  --disable-dependency-tracking
+  --disable-maintainer-mode
+  --includedir=DIR
+  --libdir=DIR
+  --libexecdir=DIR
+  --localstatedir=DIR
+  --runstatedir=DIR
+
+Some influential environment variables:
+  CC                C compiler command
+  CFLAGS            C compiler flags
+  CC32              x86 C compiler command
+  CC64_CFLAGS       x86_64 C compiler flags
+  CC64              x86_64 C compiler command
+  CC32_CFLAGS       x86 C compiler flags
+  GUILE             guile command
+  GUILE_TOOLS       guile-tools command
+  MES_CFLAGS        MesCC flags
+  MES_SEED          location of mes-seed
+  MESCC_TOOLS_SEED  location of mescc-tools-seed
+  TCC               tcc C compiler command
+  TINYCC_PREFIX     location of tinycc [for tests/test2]
+  TINYCC_SEED       location of tinycc-seed
+" PACKAGE VERSION (getenv "prefix")))
 
 (define (main args)
   (let* ((options (parse-opts args))
-         (build-triplet (option-ref options 'build BUILD_TRIPLET))
-         (host-triplet (option-ref options 'host BUILD_TRIPLET))
-         (prefix (option-ref options 'prefix PREFIX))
-         (sysconfdir (option-ref options 'sysconfdir SYSCONFDIR))
-         (verbose? (option-ref options 'verbose #f))
+         (build-type (option-ref options 'build %host-type))
+
+         (arch (car (string-split build-type #\-)))
+         (host-type (option-ref options 'host %host-type))(prefix "/usr/local")
+
+         (prefix "/usr/local")
+         (prefix (option-ref options 'prefix prefix))
+         (infodir (option-ref options 'infodir "${prefix}/share/info"))
+         (mandir (option-ref options 'infodir "${prefix}/share/man"))
+         (sysconfdir (option-ref options 'sysconfdir "${prefix}/etc"))
+
+         (bindir (option-ref options 'bindir "${prefix}/bin"))
+         (datadir (option-ref options 'datadir "${prefix}/share"))
+         (docdir (option-ref options 'docdir "${datadir}/doc/mes-${VERSION}"))
+         (libdir (option-ref options 'libdir "${prefix}/lib"))
+         (moduledir "${datadir}/mes/module")
+         (moduledir/ (gulp-pipe (string-append "echo " prefix "/share/mes/module/")))
+         (guile-effective-version (effective-version))
+         (guile-site-dir (if (equal? prefix ".") (canonicalize-path ".")
+                             (string-append "${prefix}/share/guile/site/" guile-effective-version)))
+         (guile-site-ccache-dir (if (equal? prefix ".") (canonicalize-path ".")
+                                    (string-append "${prefix}/lib/guile/" guile-effective-version "/site-ccache")))
+
+         (srcdir (dirname (car (command-line))))
+         (srcdest (if (equal? srcdir ".") ""
+                      (string-append srcdir "/")))
+         (abs-top-srcdir (canonicalize-path srcdir))
+         (abs-top-builddir (canonicalize-path (getcwd)))
+         (top-builddir (if (equal? srcdir ".") "."
+                           abs-top-builddir))
+
+         (with-cheating? (option-ref options 'with-cheating #f))
          (with-courage? (option-ref options 'with-courage #f))
-         (make? #f))
-    (set! *verbose?* verbose?)
-    (check-version 'guile '(2 0))
-    (check-version HEX2 '(0 0))
-    (check-version 'nyacc '(0 78 0) #:command (string-append GUILE " -c '(use-modules (nyacc lalr)) (display *nyacc-version*)'"))
-
-    (check-version 'bash '(4 0))
-    (when (and (not (member ARCH '("i686" "x86_64"))) (not with-courage?))
-          (stderr "platform not supported: ~a, try --with-courage\n" ARCH)
-          (exit 1))
-    (if (not (check-version CC '(4 8) #:optional? #t))
-        (set! CC #f))
-    (when CC
-      (check-header-c "stdio.h" "libc-dev")
-      (check-header-c "limits.h" "linux-headers"))
-    (if (not (check-version CC32 '(4 8) #:optional? #t))
-        (set! CC32 #f))
-    (set! make? (check-version 'make '(4 0) #:optional? #t))
-    (check-version 'perl '(5))
-
-    (when (pair? required)
-      (stderr "\nMissing dependencies [~a], run\n\n" ((->string ", ") required))
-      (if guix?
-          (stderr "    guix environment -l guix.scm\n")
-          (stderr "    sudo apt-get install ~a\n" ((->string " ") required)))
-      (exit 1))
-    (with-output-to-file ".config.make"
-      (lambda ()
-        (stdout "build:=~a\n" build-triplet)
-        (stdout "host:=~a\n" host-triplet)
-        (stdout "srcdir:=.\n")
-        (stdout "ARCH:=~a\n" ARCH)
-        (stdout "CC:=~a\n" (or CC ""))
-        (stdout "CC32:=~a\n" (or CC32 ""))
-        (stdout "GUILE:=~a\n" GUILE)
-        (stdout "GUILE_FOR_BUILD:=~a\n" GUILE)
-        (stdout "GUILE_EFFECTIVE_VERSION:=~a\n" GUILE_EFFECTIVE_VERSION)
-        (stdout "GUIX_P:=~a\n" (if guix? guix? ""))
-        (stdout "HEX2:=~a\n" (or HEX2 ""))
-        (stdout "PACKAGE:=~a\n" PACKAGE)
-        (stdout "VERSION:=~a\n" VERSION)
-        (stdout "PREFIX:=~a\n" (gulp-pipe (string-append "echo " prefix)))
-        (stdout "SYSCONFDIR:=~a\n" sysconfdir)))
-    (format (current-output-port)
-            "\nRun:
+         (disable-silent-rules? (option-ref options 'disable-silent-rules #f))
+         (enable-silent-rules? (option-ref options 'enable-silent-rules #f))
+         (vars (filter (cut string-index <> #\=) (option-ref options '() '())))
+         (help? (option-ref options 'help #f)))
+    (when help?
+      (print-help)
+      (exit 0))
+    (set! %verbose? (option-ref options 'verbose #f))
+    (when %verbose?
+      (stderr "configure args=~s\n" args))
+    (for-each (lambda (v) (apply setenv (string-split v #\=))) vars)
+    (let* ((mes-seed (or (getenv "MES_SEED")
+                         (string-append srcdest "../mes-seed")))
+           (tinycc-prefix (or (getenv "TINYCC_PREFIX")
+                              (string-append srcdest "../tinycc-prefix")))
+           (tinycc-seed (or (getenv "TINYCC_SEED")
+                            (string-append srcdest "../tinycc-seed")))
+           (mescc-tools-seed (or (getenv "MESCC_TOOLS_SEED")
+                                 (string-append srcdest "../mescc-tools-seed")))
+           (deps (fold (lambda (program results)
+                         (cons (check-program-version program) results))
+                       '()
+                       (list (make-dep "guile" '(2 0) #:commands '("guile-2.2" "guile-2.0" "guile-2" "guile"))
+                             (make-dep "guix" '(0 13) #:optional? #t)
+                             (make-dep "bash" '(2 0) #:optional? #t)
+                             (make-dep "guile-tools" '(2 0))
+                             (make-dep "mes-seed" '(0 18) #:optional? #t
+                                       #:commands (list (string-append mes-seed "/refresh.sh"))
+                                       #:file-name mes-seed)
+                             (make-dep "tinycc-seed" '(0 18) #:optional? #t
+                                       #:commands (list (string-append tinycc-seed "/refresh.sh"))
+                                       #:file-name tinycc-seed)
+                             (make-dep "cc" '(2 95) #:commands '("gcc"))
+                             (make-dep "make" '(4))
+                             (make-dep "cc32" '(2 95)
+                                       #:optional? #t
+                                       #:commands '("i686-unknown-linux-gnu-gcc"))
+                             (make-dep "cc64" '(2 95)
+                                       #:optional? #t
+                                       #:commands '("gcc"))
+                             (make-dep "M1" '(0 3))
+                             (make-dep "blood-elf" '(0 1))
+                             (make-dep "hex2" '(0 3))
+                             (make-dep "tcc" '(0 9 26) #:optional? #t #:version-option "-v")
+                             (make-dep "makeinfo" '(5) #:optional? #t)
+                             (make-dep "dot" '(2) #:version-option "-V" #:optional? #t)
+                             (make-dep "help2man" '(1 47) #:optional? #t)
+                             (make-dep "perl" '(5) #:optional? #t)
+                             (make-dep "git" '(2) #:optional? #t))))
+           (deps (cons (check-program-version (make-dep "nyacc" '(0 86 0) #:commands (list (string-append (file-name "guile" deps) " -c '(use-modules (nyacc lalr)) (display *nyacc-version*)'")) #:file-name #t))
+                       deps))
+           (deps (if (file-name "cc" deps)
+                     (cons* (check-header-c (make-dep "stdio.h"))
+                            (check-header-c (make-dep "limits.h"))
+                            deps)
+                     deps))
+           (deps (cons (check-file (make-dep "mescc-tools-seed" '(0) #:optional? #t
+                                             #:file-name mescc-tools-seed))
+                       deps))
+           (deps (cons (check-file (make-dep "tinycc-prefix" '(0) #:optional? #t
+                                             #:file-name tinycc-prefix))
+                       deps))
+           (missing (filter (conjoin (negate dependency-file-name)
+                                     (negate dependency-optional?)) deps)))
+
+      (define* (substitute file-name pairs
+                           #:key (target (if (string-suffix? ".in" file-name)
+                                             (string-drop-right file-name 3) file-name)))
+        (system* "mkdir" "-p" (dirname target))
+        (with-output-to-file target
+          (lambda _
+            (display
+             (fold (lambda (o result)
+                     (regexp-substitute/global #f (car o) result 'pre (cdr o) 'post))
+                   (with-input-from-file file-name read-string) pairs)))))
+
+      (when (and (not (member arch '("i686" "x86_64"))) (not with-courage?))
+        (stderr "platform not supported: ~a, try --with-courage\n" arch)
+        (exit 1))
+      (when (pair? missing)
+        (stderr "\nMissing dependencies: ~a\n" (string-join (map dependency-name missing)))
+        (exit 1))
+      (let ((git (find-dep "git" deps)))
+        (when (and git
+                   (not (file-exists? ".git")))
+          ;; Debian wants to run `make clean' from a tarball
+          (and (zero? (system* "git" "init"))
+               (zero? (system* "git" "add" "."))
+               (zero? (system* "git" "commit" "--allow-empty" "-m" "Import mes")))))
+      (with-output-to-file ".config.make"
+        (lambda _
+          (stdout "PACKAGE:=~a\n" PACKAGE)
+          (stdout "VERSION:=~a\n" VERSION)
+
+          (stdout "arch:=~a\n" arch)
+          (stdout "build:=~a\n" build-type)
+          (stdout "host:=~a\n" host-type)
+
+          (stdout "top_builddir:=~a\n" top-builddir)
+          (stdout "abs_top_builddir:=~a\n" abs-top-builddir)
+          (stdout "abs_top_srcdir:=~a\n" abs-top-srcdir)
+
+          (stdout "srcdest:=~a\n" srcdest)
+          (stdout "srcdir:=~a\n" srcdir)
+
+          (stdout "prefix:=~a\n" (gulp-pipe (string-append "echo " prefix)))
+          (stdout "datadir:=~a\n" datadir)
+          (stdout "docdir:=~a\n" docdir)
+
+          (stdout "bindir:=~a\n" bindir)
+          (stdout "guile_site_ccache_dir:=~a\n" guile-site-ccache-dir)
+          (stdout "guile_site_dir:=~a\n" guile-site-dir)
+          (stdout "infodir:=~a\n" infodir)
+          (stdout "libdir:=~a\n" libdir)
+          (stdout "mandir:=~a\n" mandir)
+          (stdout "moduledir:=~a\n" moduledir)
+          (stdout "sysconfdir:=~a\n" sysconfdir)
+
+          (for-each (lambda (o)
+                      (stdout "~a:=~a\n" (variable-name o) (or (dependency-file-name o) "")))
+                    deps)
+          (stdout "GUILE_EFFECTIVE_VERSION:=~a\n" (effective-version))
+
+          (when disable-silent-rules?
+            (stdout "V:=1\n"))
+
+          (when with-cheating?
+            (stdout "MES:=guile\n"))
+
+          (for-each (lambda (o)
+                      (stdout "~a:=~a\n" o (or (getenv o) "")))
+                    '(
+                      "CFLAGS"
+                      "CC32_CFLAGS"
+                      "CC64_CFLAGS"
+                      "HEX2FLAGS"
+                      "M1FLAGS"
+                      "MES_CFLAGS"
+                      ))))
+
+      (let ((pairs `(("@srcdest@" . ,srcdest)
+                     ("@srcdir@" . ,srcdir)
+                     ("@abs_top_srcdir@" . ,abs-top-srcdir)
+                     ("@abs_top_builddir@" . ,abs-top-builddir)
+                     ("@top_builddir@" . ,top-builddir)
+                     ("@BASH@" . ,(file-name "bash" deps))
+                     ("@GUILE@" . ,(file-name "guile" deps))
+                     ("@MES@" . ,(file-name "guile" deps))
+                     ("@prefix@" . ,prefix)
+                     ("@guile_site_dir@" . ,guile-site-dir)
+                     ("@guile_site_ccache_dir@" . ,guile-site-ccache-dir)
+                     ("@VERSION@" . ,VERSION)
+                     ("@arch@" . ,arch)
+                     ("mes/module/" . ,(string-append moduledir/)))))
+        (for-each (lambda (o)
+                    (let* ((src (string-append srcdest o))
+                           (target (string-drop-right o 3))
+                           (target (if (not (string-prefix? "build-aux/" target)) target
+                                       (string-drop target (string-length "build-aux/")))))
+                      (substitute src pairs #:target target)))
+                  '(
+                    "build-aux/GNUmakefile.in"
+                    "build-aux/build.sh.in"
+                    "build-aux/check.sh.in"
+                    "build-aux/install.sh.in"
+                    "build-aux/pre-inst-env.in"
+                    "build-aux/uninstall.sh.in"
+                    "mes/module/mes/boot-0.scm.in"
+                    "scripts/mescc.in"
+                    )))
+      (chmod "build.sh" #o755)
+      (chmod "check.sh" #o755)
+      (chmod "install.sh" #o755)
+      (chmod "pre-inst-env" #o755)
+      (chmod "uninstall.sh" #o755)
+      (chmod "scripts/mescc" #o755)
+      (let ((make (and=> (file-name "make" deps) basename)))
+        (format (current-output-port)
+                "\nRun:
   ~a            to build mes
   ~a help       for help on other targets\n"
-            (if make? "make" "./make.scm")
-            (if make? "make" "./make.scm"))))
+                (or make "./build.sh")
+                (or make "./build.sh"))))))