build: Non-Guix build robustifications. Thanks, rain1!
authorJan Nieuwenhuizen <janneke@gnu.org>
Wed, 19 Jul 2017 12:12:29 +0000 (14:12 +0200)
committerJan Nieuwenhuizen <janneke@gnu.org>
Wed, 26 Jul 2017 09:36:07 +0000 (11:36 +0200)
Fix typo in configure, gracefully switch between M0 vs M1, skip
CC32/i686-unknown-linux-gnu-gcc targets if not available, esp. for
non-Guix usage.

* configure (M1): Declare missing variable.
* make.scm (main): all-go, clean-go: New targets.
* GNUmakefile (PHONY_TARGETS): Add them.
  (.config.make): New target.
* guile/guix/make.scm (%CC32): Set to #f if not found.
  (bin.gcc): Skip if CC not set.
  (check-target?, add-target): Skip if target is not set.

GNUmakefile
configure
guile/guix/make.scm
make.scm

index f7d923c2e84af6891886c132b58b915c81514744..aaf1d20d450f199312013b0b2807b8b138569c23 100644 (file)
@@ -3,8 +3,10 @@ GUILE_FLAGS:=--no-auto-compile -L guile -C guile
 
 include .config.make
 
-PHONY_TARGETS:= all check clean default help
+PHONY_TARGETS:= all all-go check clean clean-go default help
 .PHONY: $(PHONY_TARGETS)
 
 $(PHONY_TARGETS):
        $(GUILE) $(GUILE_FLAGS) -s make.scm $@
+
+.config.make: ./configure
index 8bace5daa88ce83f7bcf27b6f883bb568d3e5e7f..ed42b9d8ea18f9b2275dcca5f31fb7f579c14bf4 100755 (executable)
--- a/configure
+++ b/configure
@@ -219,8 +219,9 @@ Usage: ./configure [OPTION]...
          (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 HEX2 '(0 1))
+    ;;(check-version M1 '(0 1)) ;; FIXME: 0xXX: bump to 0.2
+    (check-version 'nyacc '(0 80 3) #: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?))
@@ -250,6 +251,8 @@ Usage: ./configure [OPTION]...
         (stdout "ARCH:=~a\n" ARCH)
         (stdout "CC:=~a\n" (or CC ""))
         (stdout "CC32:=~a\n" (or CC32 ""))
+        (stdout "HEX2:=~a\n" (or HEX2 ""))
+        (stdout "M1:=~a\n" (or M1 ""))
         (stdout "GUILE:=~a\n" GUILE)
         (stdout "GUILE_FOR_BUILD:=~a\n" GUILE)
         (stdout "GUILE_EFFECTIVE_VERSION:=~a\n" GUILE_EFFECTIVE_VERSION)
index 69931e42ce0ed411c80312af7ec28594602f7530..cac02a6a8a822a22d028bd8b7a1f41263ecf708e 100644 (file)
   #t
   )
 
-(define (PATH-search-path name)
+(define* (PATH-search-path name #:key (default name))
   (or (search-path (string-split (getenv "PATH") #\:) name)
       (and (format (current-error-port) "warning: not found: ~a\n" name)
-           name)))
+           default)))
 
 (define %CC (PATH-search-path "gcc"))
-(define %CC32 (PATH-search-path "i686-unknown-linux-gnu-gcc"))
+(define %CC32 (or (PATH-search-path "i686-unknown-linux-gnu-gcc" #:default #f)
+                  (not (format (current-error-port) "warning: CC32 not found, skipping mlibc-gcc targets\n"))))
 (define %C-FLAGS
   '("--std=gnu99"
     "-O0"
                         (store #:add-file "guile/mes/as-i386.go")
                         (store #:add-file "guile/mes/M1.go")))))
 
-(define %M1 (PATH-search-path "M0")) ; M1 is in unreleased mescc-tools 0.2
+(define %M1 (or (PATH-search-path "M1" #:default #f)
+                (PATH-search-path "M0" #:default #f) ; M1 is in unreleased mescc-tools 0.2
+                (and (format (current-error-port) "error: no macro assembler found, please install mescc-tools\n")
+                     (exit 1))))
+(define %M0-FLAGS
+  '("--LittleEndian"))
 (define %M1-FLAGS
   '("--LittleEndian"
-    ;;"--Architecture=1"
-    ;;"--BaseAddress=0x1000000"
-    ))
+    "--Architecture=1"))
+(if (equal? (basename %M1) "M0")
+    (set! %M1-FLAGS %M0-FLAGS))
+
 (define* (M1.asm #:key (m1 %M1) (m1-flags %M1-FLAGS))
   (method (name "M1")
           (build (lambda (o t)
             (method (LINK.hex2 #:hex2 hex2 #:debug? (eq? libc libc-mes.E))))))
 
 (define* (bin.gcc input-file-name #:key (libc #t) (cc (if libc %CC %CC32)) (dependencies '()) (defines '()) (includes '()))
-  (let* ((base-name (base-name input-file-name ".c"))
-         (suffix (if libc ".gcc" ".mlibc-gcc"))
-         (target-file-name (string-append base-name suffix))
-         (o-target (compile.gcc input-file-name #:cc cc #:libc libc #:defines defines #:includes includes #:dependencies dependencies)))
-    (target (file-name target-file-name)
-            (inputs (list o-target))
-            (method (LINK.gcc #:cc cc #:libc libc)))))
+  (and cc
+       (let* ((base-name (base-name input-file-name ".c"))
+          (suffix (if libc ".gcc" ".mlibc-gcc"))
+          (target-file-name (string-append base-name suffix))
+          (o-target (compile.gcc input-file-name #:cc cc #:libc libc #:defines defines #:includes includes #:dependencies dependencies)))
+     (target (file-name target-file-name)
+             (inputs (list o-target))
+             (method (LINK.gcc #:cc cc #:libc libc))))))
 
 (define* (snarf input-file-name #:key (dependencies '()) (mes? #t))
   (let* ((base-name (base-name input-file-name ".c"))
   (string-prefix? prefix (target-file-name o)))
 
 (define (check-target? o)
-  ((target-prefix? "check-") o))
+  (and o ((target-prefix? "check-") o)))
 
 (define (add-target o)
-  (set! %targets (append %targets (list o)))
+  (and o (set! %targets (append %targets (list o))))
   o)
 (define (get-target o)
   (if (target? o) o
index 3eb642a8ce5a474dacbb2659cc060fdf6b23a5f0..0d6874b323edef6af4f48f3e3e0a156e39b80fc9 100755 (executable)
--- a/make.scm
+++ b/make.scm
@@ -1,37 +1,35 @@
-#! /usr/bin/env guile
+#! /bin/sh
+# -*- scheme -*-
+#exec ${GUILE-guile} --no-auto-compile -L . -L guile -C . -C guile -s "$0" ${1+"$@"}
+exec ${GUILE-guile} -L . -L guile -C . -C guile -s "$0" ${1+"$@"}
 !#
 
-(set! %load-path (cons "guile" %load-path))
-(set! %load-path (cons "../guix" %load-path))
-(set! %load-compiled-path (cons "guile" %load-compiled-path))
-(set! %load-compiled-path (cons "../guix" %load-compiled-path))
-
-(use-modules (guix shell-utils))
+(use-modules (srfi srfi-26))
 
 ;; FIXME: .go dependencies
 ;; workaround: always update .go before calculating hashes
 ;;(use-modules ((mes make) #:select (sytem**)))
-(let* ((scm-files '("guix/make.scm"
-                    "guix/records.scm"
-                    "guix/shell-utils.scm"
-                    "language/c99/compiler.scm"
-                    "mes/as-i386.scm"
-                    "mes/as.scm"
-                    "mes/elf.scm"
-                    "mes/M1.scm")))
+(define %go-files '())
+(let* ((scm-files '("guile/guix/make.scm"
+                    "guile/guix/records.scm"
+                    "guile/guix/shell-utils.scm"
+                    "guile/language/c99/compiler.scm"
+                    "guile/mes/as-i386.scm"
+                    "guile/mes/as.scm"
+                    "guile/mes/elf.scm"
+                    "guile/mes/M1.scm")))
+  (set! %go-files (map (compose (cut string-append <> ".go") (cut string-drop-right <> 4)) scm-files))
   (setenv "srcdir" "guile")
   (setenv "host" %host-type)
-  (with-directory-excursion "guile"
-    (apply system* `("guile"
-                     "--no-auto-compile"
-                     "-L" "."
-                     "-C" "."
-                     "-s"
-                     "../build-aux/compile-all.scm"
-                     ,@scm-files))))
+  (apply system* `("guile"
+                   "--no-auto-compile"
+                   "-L" "." "-L" "guile"
+                   "-C" "." "-C" "guile"
+                   "-s"
+                   "build-aux/compile-all.scm"
+                   ,@scm-files)))
 
 (use-modules (srfi srfi-1)
-             (srfi srfi-26)
              (ice-9 curried-definitions)
              (ice-9 match)
              (guix make))
 (setenv "MES" "src/mes.guile")
 
 (define (main args)
-  (cond ((member "clean" args) (clean))
+  (cond ((member "all-go" args) #t)
+        ((member "clean-go" args) (map delete-file (filter file-exists? %go-files)))
+        ((member "clean" args) (clean))
         ((member "help" args) (format #t "Usage: ./make.scm [TARGET]...
 
 Targets:
     all
+    all-go
     check
     clean
+    clean-go
     help~a
 "
                                       ;;(string-join (map target-file-name %targets) "\n    " 'prefix)