X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcompiler%2Fmain.lisp;h=d1c14a3acee57a9117bbd8f4ac05685de012391f;hb=fa8962d732057015fbb9a2f8a08ea8d5299b50dd;hp=5078353926faef079d974844f66210338d4d0e93;hpb=212ef8043aeaceaa627f2924e04554fbc37b8ee1;p=sbcl.git

diff --git a/src/compiler/main.lisp b/src/compiler/main.lisp
index 5078353..d1c14a3 100644
--- a/src/compiler/main.lisp
+++ b/src/compiler/main.lisp
@@ -101,18 +101,13 @@
 	       sb!xc:*compile-file-pathname*
 	       sb!xc:*compile-file-truename*))
 
-;;; the values of *PACKAGE* and policy when compilation started
-(defvar *initial-package*)
-(defvar *initial-cookie*)
-(defvar *initial-interface-cookie*)
-
-;;; The source-info structure for the current compilation. This is null
-;;; globally to indicate that we aren't currently in any identifiable
-;;; compilation.
+;;; the SOURCE-INFO structure for the current compilation. This is
+;;; null globally to indicate that we aren't currently in any
+;;; identifiable compilation.
 (defvar *source-info* nil)
 
-;;; True if we are within a WITH-COMPILATION-UNIT form (which normally
-;;; causes nested uses to be no-ops).
+;;; This is true if we are within a WITH-COMPILATION-UNIT form (which
+;;; normally causes nested uses to be no-ops).
 (defvar *in-compilation-unit* nil)
 
 ;;; Count of the number of compilation units dynamically enclosed by
@@ -384,7 +379,7 @@
 	  (entry-analyze component)
 	  (ir2-convert component)
 
-	  (when (policy nil (>= speed cspeed))
+	  (when (policy nil (>= speed compilation-speed))
 	    (maybe-mumble "copy ")
 	    (copy-propagate component))
 
@@ -463,7 +458,7 @@
 (defun byte-compiling ()
   (if (eq *byte-compiling* :maybe)
       (or (eq *byte-compile* t)
-	  (policy nil (zerop speed) (<= debug 1)))
+	  (policy nil (and (zerop speed) (<= debug 1))))
       (and *byte-compile* *byte-compiling*)))
 
 ;;; Delete components with no external entry points before we try to
@@ -492,7 +487,7 @@
 	    (:maybe
 	     (dolist (fun (component-lambdas component) t)
 	       (unless (policy (lambda-bind fun)
-			       (zerop speed) (<= debug 1))
+			       (and (zerop speed) (<= debug 1)))
 		 (return nil)))))))
 
     (when sb!xc:*compile-print*
@@ -806,16 +801,13 @@
 ;;; rebinding around each file.
 ;;;
 ;;; FIXME: Since we now do the standard ANSI thing of only one file
-;;; per compile (unlike the CMU CL extended COMPILE-FILE) can't this
-;;; complexity (including ADVANCE-SOURCE-FILE) go away?
+;;; per compile (unlike the CMU CL extended COMPILE-FILE) this code is
+;;; becoming stale, and the remaining bits of it (and the related code
+;;; in ADVANCE-SOURCE-FILE) can go away.
 (defun get-source-stream (info)
   (declare (type source-info info))
   (cond ((source-info-stream info))
 	(t
-	 (setq *package* *initial-package*)
-	 (setq *default-cookie* (copy-cookie *initial-cookie*))
-	 (setq *default-interface-cookie*
-	       (copy-cookie *initial-interface-cookie*))
 	 (let* ((finfo (first (source-info-current-file info)))
 		(name (file-info-name finfo)))
 	   (setq sb!xc:*compile-file-truename* name)
@@ -893,8 +885,8 @@
 ;;; *TOP-LEVEL-LAMBDAS* instead.
 (defun convert-and-maybe-compile (form path)
   (declare (list path))
-  (let* ((*lexenv* (make-lexenv :cookie *default-cookie*
-				:interface-cookie *default-interface-cookie*))
+  (let* ((*lexenv* (make-lexenv :policy *policy*
+				:interface-policy *interface-policy*))
 	 (tll (ir1-top-level form path nil)))
     (cond ((eq *block-compile* t) (push tll *top-level-lambdas*))
 	  (t (compile-top-level (list tll) nil)))))
@@ -916,23 +908,22 @@
 
 ;;; Process a top-level use of LOCALLY. We parse declarations and then
 ;;; recursively process the body.
-;;;
-;;; Binding *DEFAULT-xxx-COOKIE* is pretty much of a hack, since it
-;;; causes LOCALLY to "capture" enclosed proclamations. It is
-;;; necessary because CONVERT-AND-MAYBE-COMPILE uses the value of
-;;; *DEFAULT-COOKIE* as the policy. The need for this hack is due to
-;;; the quirk that there is no way to represent in a cookie that an
-;;; optimize quality came from the default.
-;;; FIXME: Ideally, something should be done so that DECLAIM inside LOCALLY
-;;; works OK. Failing that, at least we could issue a warning instead
-;;; of silently screwing up.
 (defun process-top-level-locally (form path)
   (declare (list path))
   (multiple-value-bind (forms decls) (sb!sys:parse-body (cdr form) nil)
     (let* ((*lexenv*
 	    (process-decls decls nil nil (make-continuation)))
-	   (*default-cookie* (lexenv-cookie *lexenv*))
-	   (*default-interface-cookie* (lexenv-interface-cookie *lexenv*)))
+	   ;; Binding *xxx-POLICY* is pretty much of a hack, since it
+	   ;; causes LOCALLY to "capture" enclosed proclamations. It
+	   ;; is necessary because CONVERT-AND-MAYBE-COMPILE uses the
+	   ;; value of *POLICY* as the policy. The need for this hack
+	   ;; is due to the quirk that there is no way to represent in
+	   ;; a POLICY that an optimize quality came from the default.
+	   ;; FIXME: Ideally, something should be done so that DECLAIM
+	   ;; inside LOCALLY works OK. Failing that, at least we could
+	   ;; issue a warning instead of silently screwing up.
+	   (*policy* (lexenv-policy *lexenv*))
+	   (*interface-policy* (lexenv-interface-policy *lexenv*)))
       (process-top-level-progn forms path))))
 
 ;;; Force any pending top-level forms to be compiled and dumped so
@@ -1357,12 +1348,8 @@
 	 #+nil (*compiler-note-count* 0)
 	 (*block-compile* *block-compile-argument*)
 	 (*package* (sane-package))
-	 (*initial-package* (sane-package))
-	 (*initial-cookie* *default-cookie*)
-	 (*initial-interface-cookie* *default-interface-cookie*)
-	 (*default-cookie* (copy-cookie *initial-cookie*))
-	 (*default-interface-cookie*
-	  (copy-cookie *initial-interface-cookie*))
+	 (*policy* *policy*)
+	 (*interface-policy* *interface-policy*)
 	 (*lexenv* (make-null-lexenv))
 	 (*converting-for-interpreter* nil)
 	 (*source-info* info)