mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-04-30 03:40:34 +02:00
3de80ed52f
* ice-9/boot-9.scm (compile-time-environment): Remove definition from boot-9 -- instead, autoload it and `compile' from (system base compile). * libguile/objcodes.h: * libguile/objcodes.c (scm_objcode_to_program): Add an optional argument, `external', the external list to set on the returned program. * libguile/vm-i-system.c (externals): New instruction, returns the external list. Only used by (compile-time-environment). * libguile/vm.c (scm_load_compiled_with_vm): Adapt to scm_objcode_to_program change. * module/language/scheme/translate.scm (translate): Actually pay attention to the environment passed as an argument. (custom-transformer-table): Expand out (compile-time-environment) to something that can be passed to `compile'. * module/system/base/compile.scm (*current-language*): Instead of hard-coding `scheme' in various places, use a current language fluid, initialized to `scheme'. (compile-file, load-source-file): Adapt to *current-language*. (load-source-file): Ada (scheme-eval): Removed, no one used this. (compiled-file-name): Don't hard-code "scm" and "go"; instead use the %load-extensions and %load-compiled-extensions. (cenv-module, cenv-ghil-env, cenv-externals): Some accessors for compile-time environments. (compile-time-environment): Here we define (compile-time-environment) to something that will return #f; the compiler however produces different code as noted above. (compile): New function, compiles an expression into a thunk, then runs the thunk to get the value. Useful for procedures. The optional second argument can be either a module or a compile-time-environment; in the latter case, we can recompile even with lexical bindings. (compile-in): If the env specifies a module, set that module for the duration of the compilation. * module/system/base/syntax.scm (%compute-initargs): Fix a bug where the default value for a field would always replace a user-supplied value. Whoops. * module/system/il/ghil.scm (ghil-env-dereify): New function, takes the result of ghil-env-reify and turns it back into a GHIL environment. * scripts/compile (compile): Remove some of the tricky error handling, as the library procedures handle this for us. * test-suite/tests/compiler.test: Add a test for the dynamic compilation bits.
239 lines
7.7 KiB
Scheme
239 lines
7.7 KiB
Scheme
;;; High-level compiler interface
|
||
|
||
;; Copyright (C) 2001 Free Software Foundation, Inc.
|
||
|
||
;; This program 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 2, 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 General Public License for more details.
|
||
;;
|
||
;; You should have received a copy of the GNU General Public License
|
||
;; along with this program; see the file COPYING. If not, write to
|
||
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||
;; Boston, MA 02111-1307, USA.
|
||
|
||
;;; Code:
|
||
|
||
(define-module (system base compile)
|
||
#:use-syntax (system base syntax)
|
||
#:use-module (system base language)
|
||
#:use-module ((system il compile) #:select ((compile . compile-il)))
|
||
#:use-module (system il ghil)
|
||
#:use-module (system il glil)
|
||
#:use-module (system vm objcode)
|
||
#:use-module (system vm assemble)
|
||
#:use-module (system vm vm) ;; for compile-time evaluation
|
||
#:use-module (ice-9 regex)
|
||
#:use-module (ice-9 optargs)
|
||
#:export (syntax-error compile-file load-source-file load-file
|
||
*current-language*
|
||
compiled-file-name
|
||
compile-time-environment
|
||
compile read-file-in compile-in
|
||
load/compile)
|
||
#:export-syntax (call-with-compile-error-catch))
|
||
|
||
;;;
|
||
;;; Compiler environment
|
||
;;;
|
||
|
||
(define (syntax-error loc msg exp)
|
||
(throw 'syntax-error-compile-time loc msg exp))
|
||
|
||
(define-macro (call-with-compile-error-catch thunk)
|
||
`(catch 'syntax-error-compile-time
|
||
,thunk
|
||
(lambda (key loc msg exp)
|
||
(if (pair? loc)
|
||
(format (current-error-port)
|
||
"~A:~A: ~A: ~A~%" (car loc) (cdr loc) msg exp)
|
||
(format (current-error-port)
|
||
"unknown location: ~A: ~A~%" msg exp)))))
|
||
|
||
|
||
;;;
|
||
;;; Compiler
|
||
;;;
|
||
|
||
(define *current-language* (make-fluid))
|
||
|
||
(define (call-with-output-file/atomic filename proc)
|
||
(let* ((template (string-append filename ".XXXXXX"))
|
||
(tmp (mkstemp! template)))
|
||
(catch #t
|
||
(lambda ()
|
||
(with-output-to-port tmp
|
||
(lambda () (proc (current-output-port))))
|
||
(rename-file template filename))
|
||
(lambda args
|
||
(delete-file template)
|
||
(apply throw args)))))
|
||
|
||
(define (compile-file file . opts)
|
||
(let ((comp (compiled-file-name file))
|
||
(lang (fluid-ref *current-language*)))
|
||
(catch 'nothing-at-all
|
||
(lambda ()
|
||
(call-with-compile-error-catch
|
||
(lambda ()
|
||
(call-with-output-file/atomic comp
|
||
(lambda (port)
|
||
(let* ((source (read-file-in file lang))
|
||
(objcode (apply compile-in source (current-module)
|
||
lang opts)))
|
||
(if (memq #:c opts)
|
||
(pprint-glil objcode port)
|
||
(uniform-vector-write (objcode->u8vector objcode) port)))))
|
||
(format #t "wrote `~A'\n" comp))))
|
||
(lambda (key . args)
|
||
(format #t "ERROR: during compilation of ~A:\n" file)
|
||
(display "ERROR: ")
|
||
(apply format #t (cadr args) (caddr args))
|
||
(newline)
|
||
(format #t "ERROR: ~A ~A ~A\n" key (car args) (cadddr args))
|
||
(delete-file comp)))))
|
||
|
||
; (let ((c-f compile-file))
|
||
; ;; XXX: Debugging output
|
||
; (set! compile-file
|
||
; (lambda (file . opts)
|
||
; (format #t "compile-file: ~a ~a~%" file opts)
|
||
; (let ((result (apply c-f (cons file opts))))
|
||
; (format #t "compile-file: returned ~a~%" result)
|
||
; result))))
|
||
|
||
(define (load-source-file file . opts)
|
||
(let ((lang (fluid-ref *current-language*)))
|
||
(let ((source (read-file-in file lang)))
|
||
(apply compile-in source (current-module) lang opts))))
|
||
|
||
(define (load-file file . opts)
|
||
(let ((comp (compiled-file-name file)))
|
||
(if (file-exists? comp)
|
||
(load-objcode comp)
|
||
(apply load-source-file file opts))))
|
||
|
||
(define (compiled-file-name file)
|
||
(let ((base (basename file))
|
||
(cext (cond ((or (null? %load-compiled-extensions)
|
||
(string-null? (car %load-compiled-extensions)))
|
||
(warn "invalid %load-compiled-extensions"
|
||
%load-compiled-extensions)
|
||
".go")
|
||
(else (car %load-compiled-extensions)))))
|
||
(let lp ((exts %load-extensions))
|
||
(cond ((null? exts) (string-append base cext))
|
||
((string-null? (car exts)) (lp (cdr exts)))
|
||
((string-suffix? (car exts) base)
|
||
(string-append
|
||
(substring base 0
|
||
(- (string-length base) (string-length (car exts))))
|
||
cext))
|
||
(else (lp (cdr exts)))))))
|
||
|
||
;;; environment := #f
|
||
;;; | MODULE
|
||
;;; | COMPILE-ENV
|
||
;;; compile-env := (MODULE LEXICALS . EXTERNALS)
|
||
(define (cenv-module env)
|
||
(cond ((not env) #f)
|
||
((module? env) env)
|
||
((and (pair? env) (module? (car env))) (car env))
|
||
(else (error "bad environment" env))))
|
||
|
||
(define (cenv-ghil-env env)
|
||
(cond ((not env) (make-ghil-toplevel-env))
|
||
((module? env) (make-ghil-toplevel-env))
|
||
((pair? env)
|
||
(ghil-env-dereify (cadr env)))
|
||
(else (error "bad environment" env))))
|
||
|
||
(define (cenv-externals env)
|
||
(cond ((not env) '())
|
||
((module? env) '())
|
||
((pair? env) (cddr env))
|
||
(else (error "bad environment" env))))
|
||
|
||
(define (compile-time-environment)
|
||
"A special function known to the compiler that, when compiled, will
|
||
return a representation of the lexical environment in place at compile
|
||
time. Useful for supporting some forms of dynamic compilation. Returns
|
||
#f if called from the interpreter."
|
||
#f)
|
||
|
||
(define* (compile x #:optional env)
|
||
(let ((thunk (objcode->program
|
||
(compile-in x env (fluid-ref *current-language*))
|
||
(cenv-externals env))))
|
||
(if (not env)
|
||
(thunk)
|
||
(save-module-excursion
|
||
(lambda ()
|
||
(set-current-module (cenv-module env))
|
||
(thunk))))))
|
||
|
||
|
||
;;;
|
||
;;; Scheme compiler interface
|
||
;;;
|
||
|
||
(define (read-file-in file lang)
|
||
(call-with-input-file file (language-read-file lang)))
|
||
|
||
(define (compile-in x e lang . opts)
|
||
(save-module-excursion
|
||
(lambda ()
|
||
(catch 'result
|
||
(lambda ()
|
||
(and=> (cenv-module e) set-current-module)
|
||
(set! e (cenv-ghil-env e))
|
||
;; expand
|
||
(set! x ((language-expander lang) x e))
|
||
(if (memq #:e opts) (throw 'result x))
|
||
;; translate
|
||
(set! x ((language-translator lang) x e))
|
||
(if (memq #:t opts) (throw 'result x))
|
||
;; compile
|
||
(set! x (apply compile-il x e opts))
|
||
(if (memq #:c opts) (throw 'result x))
|
||
;; assemble
|
||
(apply assemble x e opts))
|
||
(lambda (key val) val)))))
|
||
|
||
;;;
|
||
;;;
|
||
;;;
|
||
|
||
(define (compile-and-load file . opts)
|
||
(let ((comp (object-file-name file)))
|
||
(if (or (not (file-exists? comp))
|
||
(> (stat:mtime (stat file)) (stat:mtime (stat comp))))
|
||
(compile-file file))
|
||
(load-compiled-file comp)))
|
||
|
||
(define (load/compile file . opts)
|
||
(let* ((file (file-full-name file))
|
||
(compiled (object-file-name file)))
|
||
(if (or (not (file-exists? compiled))
|
||
(> (stat:mtime (stat file)) (stat:mtime (stat compiled))))
|
||
(apply compile-file file #f opts))
|
||
(if (memq #:b opts)
|
||
(apply vm-trace (the-vm) (load-objcode compiled) opts)
|
||
((the-vm) (load-objcode compiled)))))
|
||
|
||
(define (file-full-name filename)
|
||
(let* ((port (current-load-port))
|
||
(oldname (and port (port-filename port))))
|
||
(if (and oldname
|
||
(> (string-length filename) 0)
|
||
(not (char=? (string-ref filename 0) #\/))
|
||
(not (string=? (dirname oldname) ".")))
|
||
(string-append (dirname oldname) "/" filename)
|
||
filename)))
|
||
|
||
(fluid-set! *current-language* (lookup-language 'scheme))
|