diff options
Diffstat (limited to 'module/scripts/compile.scm')
-rw-r--r-- | module/scripts/compile.scm | 257 |
1 files changed, 257 insertions, 0 deletions
diff --git a/module/scripts/compile.scm b/module/scripts/compile.scm new file mode 100644 index 000000000..d86f2f2bc --- /dev/null +++ b/module/scripts/compile.scm @@ -0,0 +1,257 @@ +;;; Compile --- Command-line Guile Scheme compiler -*- coding: iso-8859-1 -*- + +;; Copyright 2005,2008-2011,2013-2015,2017-2018 Free Software Foundation, Inc. +;; +;; This program is free software; you can redistribute it and/or +;; modify it under the terms of the GNU Lesser General Public License +;; as published by the Free Software Foundation; either version 3, or +;; (at your option) any later version. +;; +;; This program 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 +;; Lesser General Public License for more details. +;; +;; You should have received a copy of the GNU Lesser General Public +;; License along with this software; see the file COPYING.LESSER. If +;; not, write to the Free Software Foundation, Inc., 51 Franklin +;; Street, Fifth Floor, Boston, MA 02110-1301 USA + +;;; Author: Ludovic Courtès <ludo@gnu.org> +;;; Author: Andy Wingo <wingo@pobox.com> + +;;; Commentary: + +;; Usage: compile [ARGS] +;; +;; A command-line interface to the Guile compiler. + +;;; Code: + +(define-module (scripts compile) + #:use-module ((system base language) #:select (lookup-language)) + #:use-module ((system base compile) #:select (compile-file)) + #:use-module (system base target) + #:use-module (system base message) + #:use-module (system base optimize) + #:use-module (srfi srfi-1) + #:use-module (srfi srfi-13) + #:use-module (srfi srfi-37) + #:use-module (ice-9 format) + #:use-module (ice-9 match) + #:export (compile)) + +(define %summary "Compile a file.") + + +(define (fail . messages) + (format (current-error-port) "error: ~{~a~}~%" messages) + (exit 1)) + +(define %options + ;; Specifications of the command-line options. + (list (option '(#\h "help") #f #f + (lambda (opt name arg result) + (alist-cons 'help? #t result))) + (option '("version") #f #f + (lambda (opt name arg result) + (show-version) + (exit 0))) + + (option '(#\L "load-path") #t #f + (lambda (opt name arg result) + (let ((load-path (assoc-ref result 'load-path))) + (alist-cons 'load-path (cons arg load-path) + result)))) + (option '(#\o "output") #t #f + (lambda (opt name arg result) + (if (assoc-ref result 'output-file) + (fail "`-o' option cannot be specified more than once") + (alist-cons 'output-file arg result)))) + (option '(#\x) #t #f + (lambda (opt name arg result) + (set! %load-extensions (cons arg %load-extensions)) + result)) + + (option '(#\W "warn") #t #f + (lambda (opt name arg result) + (if (string=? arg "help") + (begin + (show-warning-help) + (exit 0)) + (let ((warnings (assoc-ref result 'warnings))) + (alist-cons 'warnings + (cons (string->symbol arg) warnings) + (alist-delete 'warnings result)))))) + + (option '(#\O "optimize") #t #f + (lambda (opt name arg result) + (define (return val) + (alist-cons 'optimizations val result)) + (define (return-option name val) + (let ((kw (symbol->keyword + (string->symbol (string-append name "?"))))) + (unless (assq kw (available-optimizations)) + (fail "Unknown optimization pass `~a'" name)) + (return (list kw val)))) + (cond + ((string=? arg "help") + (show-optimization-help) + (exit 0)) + ((equal? arg "0") (return (optimizations-for-level 0))) + ((equal? arg "1") (return (optimizations-for-level 1))) + ((equal? arg "2") (return (optimizations-for-level 2))) + ((equal? arg "3") (return (optimizations-for-level 3))) + ((string-prefix? "no-" arg) + (return-option (substring arg 3) #f)) + (else + (return-option arg #t))))) + (option '(#\f "from") #t #f + (lambda (opt name arg result) + (if (assoc-ref result 'from) + (fail "`--from' option cannot be specified more than once") + (alist-cons 'from (string->symbol arg) result)))) + (option '(#\t "to") #t #f + (lambda (opt name arg result) + (if (assoc-ref result 'to) + (fail "`--to' option cannot be specified more than once") + (alist-cons 'to (string->symbol arg) result)))) + (option '(#\T "target") #t #f + (lambda (opt name arg result) + (if (assoc-ref result 'target) + (fail "`--target' option cannot be specified more than once") + (alist-cons 'target arg result)))))) + +(define (parse-args args) + "Parse argument list @var{args} and return an alist with all the relevant +options." + (args-fold args %options + (lambda (opt name arg result) + (format (current-error-port) "~A: unrecognized option~%" name) + (exit 1)) + (lambda (file result) + (let ((input-files (assoc-ref result 'input-files))) + (alist-cons 'input-files (cons file input-files) + result))) + + ;; default option values + '((input-files) + (load-path) + (warnings unsupported-warning)))) + +(define (show-version) + (format #t "compile (GNU Guile) ~A~%" (version)) + (format #t "Copyright (C) 2018 Free Software Foundation, Inc. +License LGPLv3+: GNU LGPL version 3 or later <http://gnu.org/licenses/lgpl.html>. +This is free software: you are free to change and redistribute it. +There is NO WARRANTY, to the extent permitted by law.~%")) + +(define (show-warning-help) + (format #t "The available warning types are:~%~%") + (for-each (lambda (wt) + (format #t " ~22A ~A~%" + (format #f "`~A'" (warning-type-name wt)) + (warning-type-description wt))) + %warning-types) + (format #t "~%")) + +(define (show-optimization-help) + (format #t "The available optimizations are:~%~%") + (let lp ((options (available-optimizations))) + (match options + (() #t) + (((kw level) . options) + (let ((name (string-trim-right (symbol->string (keyword->symbol kw)) + #\?))) + (format #t " -O~a~%" name) + (lp options))))) + (format #t "~%") + (format #t "To disable an optimization, prepend it with `no-', for example~%") + (format #t "`-Ono-cse.'~%~%") + (format #t "You may also specify optimization levels as `-O0', `-O1',~%") + (format #t "`-O2', or `-O3'. Currently `-O0' turns off all optimizations,~%") + (format #t "`-O1' turns on partial evaluation, and `-O2' and `-O3' turn on~%") + (format #t "everything. The default is equivalent to `-O2'.") + (format #t "~%")) + + +(define (compile . args) + (let* ((options (parse-args args)) + (help? (assoc-ref options 'help?)) + (compile-opts `(#:warnings + ,(assoc-ref options 'warnings) + ,@(append-map + (lambda (opt) + (match opt + (('optimizations . opts) opts) + (_ '()))) + options))) + (from (or (assoc-ref options 'from) 'scheme)) + (to (or (assoc-ref options 'to) 'bytecode)) + (target (or (assoc-ref options 'target) %host-type)) + (input-files (assoc-ref options 'input-files)) + (output-file (assoc-ref options 'output-file)) + (load-path (assoc-ref options 'load-path))) + (if (or help? (null? input-files)) + (begin + (format #t "Usage: compile [OPTION] FILE... +Compile each Guile source file FILE into a Guile object. + + -h, --help print this help message + + -L, --load-path=DIR add DIR to the front of the module load path + -o, --output=OFILE write output to OFILE + -x EXTENSION add EXTENSION to the set of source file extensions + + -W, --warn=WARNING emit warnings of type WARNING; use `--warn=help' + for a list of available warnings + -O, --optimize=OPT specify optimization passes to run; use `-Ohelp' + for a list of available optimizations + + -f, --from=LANG specify a source language other than `scheme' + -t, --to=LANG specify a target language other than `bytecode' + -T, --target=TRIPLET produce bytecode for host TRIPLET + +Note that auto-compilation will be turned off. + +Report bugs to <~A>.~%" + %guile-bug-report-address) + (exit 0))) + + ;; Load FROM and TO before we have changed the load path. That way, when + ;; cross-compiling Guile itself, we can be sure we're loading our own + ;; language modules and not those of the Guile being compiled, which may + ;; have incompatible .go files. + (lookup-language from) + (lookup-language to) + + (set! %load-path (append load-path %load-path)) + (set! %load-should-auto-compile #f) + + (if (and output-file + (or (null? input-files) + (not (null? (cdr input-files))))) + (fail "`-o' option can only be specified " + "when compiling a single file")) + + ;; Install a SIGINT handler. As a side effect, this gives unwind + ;; handlers an opportunity to run upon SIGINT; this includes that of + ;; 'call-with-output-file/atomic', called by 'compile-file', which + ;; removes the temporary output file. + (sigaction SIGINT + (lambda args + (fail "interrupted by the user"))) + + (for-each (lambda (file) + (format #t "wrote `~A'\n" + (with-fluids ((*current-warning-prefix* "")) + (with-target target + (lambda () + (compile-file file + #:output-file output-file + #:from from + #:to to + #:opts compile-opts)))))) + input-files))) + +(define main compile) |