compilation enviroments are always modules; simplifications & refactorings

* module/ice-9/boot-9.scm (make-fresh-user-module): New public function,
  makes an anonymous beautified module.

* module/language/objcode/spec.scm: We used to have some things in here
  that allowed lexical variable names and values to be a part of the
  environment, but no more. Now an environment is just a module. If you
  want to "inject" free variables into code, just use lambda.

* module/language/scheme/compile-tree-il.scm (compile-tree-il): Same
  here. Also, rely on the fact that an environment *will* be a module --
  because (system base compile) guarantees that for us.

* module/language/scheme/spec.scm (scheme): In the reader, rely on the
  environment being a module. Define a #:make-default-environment
  handler, which returns a beautified module, augmented with a fresh
  definition for current-reader, so that side effects to current-reader
  are restricted to the compilation unit.

* module/language/tree-il/analyze.scm
  (report-possibly-unbound-variables):
* module/language/tree-il/compile-glil.scm (compile-glil):
* module/language/tree-il/optimize.scm (optimize!): The environment will
  be a module.

* module/system/base/language.scm (<language>): New field,
  `make-default-environment'. Defaults to `make-fresh-user-module'.
  (default-environment): New accessor, returns a default environment for
  a language.

* module/system/repl/common.scm (repl-compile): Always compile relative
  to the current module, because a module is always acceptable as an
  environment.

* module/system/base/compile.scm (compile-file, compile-and-load): Both
  of these have a new keyword argument, #:env. For `compile-file', it
  defaults to the default environment of the source language, and for
  `compile-and-load', to the current module.
  (read-and-compile): If there are no expressions read, pass the joiner
  its default environment (via `default-environment joint').

module/language/scheme/compile-tree-il.scm

@@ -1,6 +1,6 @@
 ;;; Guile Scheme specification
 
-;; Copyright (C) 2001 Free Software Foundation, Inc.
+;; Copyright (C) 2001, 2009 Free Software Foundation, Inc.
 
 ;;;; This library is free software; you can redistribute it and/or
 ;;;; modify it under the terms of the GNU Lesser General Public
@@ -24,40 +24,11 @@
 
 ;;; 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-lexicals env)
-  (cond ((not env) '())
-        ((module? env) '())
-        ((pair? env) (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 (make-cenv module lexicals externals)
-  (cons module (cons lexicals externals)))
-
-(define (location x)
-  (and (pair? x)
-       (let ((props (source-properties x)))
-	 (and (not (null? props))
-              props))))
 
 (define (compile-tree-il x e opts)
   (save-module-excursion
    (lambda ()
-     (and=> (cenv-module e) set-current-module)
+     (set-current-module e)
      (let* ((x (sc-expand x 'c '(compile load eval)))
-            (cenv (make-cenv (current-module)
-                             (cenv-lexicals e) (cenv-externals e))))
+            (cenv (current-module)))
        (values x cenv cenv)))))

module/language/scheme/spec.scm

@@ -41,11 +41,7 @@
   #:reader      (lambda (port env)
                   ;; Use the binding of current-reader from the environment.
                   ;; FIXME: Handle `read-options' as well?
-                  ((or (and=> (and=> (module-variable 
-                                      (cond ((pair? env) (car env))
-                                            (env)
-                                            (else (current-module)))
-                                      'current-reader)
+                  ((or (and=> (and=> (module-variable env 'current-reader)
                                      variable-ref)
                               fluid-ref)
                        read)
@@ -55,4 +51,13 @@
   #:decompilers `((tree-il . ,decompile-tree-il))
   #:evaluator	(lambda (x module) (primitive-eval x))
   #:printer	write
-  )
+  #:make-default-environment
+                (lambda ()
+                  ;; Ideally we'd duplicate the whole module hierarchy so that `set!',
+                  ;; `fluid-set!', etc. don't have any effect in the current environment.
+                  (let ((m (make-fresh-user-module)))
+                    ;; Provide a separate `current-reader' fluid so that
+                    ;; compile-time changes to `current-reader' are
+                    ;; limited to the current compilation unit.
+                    (module-define! m 'current-reader (make-fluid))
+                    m)))