X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Feval.lisp;h=6e8b10fea029a335ed0a6d4fed5e71e3fffe70a3;hb=86210c4e406c1b2ff10cc3bac0e71435867db48b;hp=0d71c401954e39fb8c07b857c7a4ae82dfe060ca;hpb=959057baab99d4328fc386aee3fcc812f5fcb3ed;p=sbcl.git

diff --git a/src/code/eval.lisp b/src/code/eval.lisp
index 0d71c40..6e8b10f 100644
--- a/src/code/eval.lisp
+++ b/src/code/eval.lisp
@@ -12,25 +12,25 @@
 (in-package "SB!IMPL")
 
 ;;; general case of EVAL (except in that it can't handle toplevel
-;;; EVAL-WHEN magic properly): Delegate to the byte compiler.
+;;; EVAL-WHEN magic properly): Delegate to #'COMPILE.
 (defun %eval (expr)
   (funcall (compile (gensym "EVAL-TMPFUN-")
 		    `(lambda ()
 
-		       ;; SPEED=0,DEBUG=1 => byte-compile
-		       (declare (optimize (speed 0) (debug 1))) 
+		       ;; The user can reasonably expect that the
+		       ;; interpreter will be safe.
+		       (declare (optimize (safety 3)))
 
-		       ;; Other than that, basically we care about
-		       ;; compilation speed, compilation speed, and
-		       ;; compilation speed. (There are cases where
-		       ;; the user wants something else, but we don't
-		       ;; know enough to guess that; and if he is
-		       ;; unhappy about our guessed emphasis, he
-		       ;; should explicitly compile his code, with
-		       ;; explicit declarations to tell us what to
-		       ;; emphasize.)
-		       (declare (optimize (space 1) (safety 1)))
-		       (declare (optimize (compilation-speed 3)))
+		       ;; It's also good if the interpreter doesn't
+		       ;; spend too long thinking about each input
+		       ;; form, since if the user'd wanted the
+		       ;; tradeoff to favor quality of compiled code
+		       ;; over compilation speed, he'd've explicitly
+		       ;; asked for compilation.
+		       (declare (optimize (compilation-speed 2)))
+
+		       ;; Other properties are relatively unimportant.
+		       (declare (optimize (speed 1) (debug 1) (space 1)))
 
 		       ,expr))))
 
@@ -55,7 +55,7 @@
 	(eval (first i))
 	(return (eval (first i))))))
 
-;;; Pick off a few easy cases, and the various top-level EVAL-WHEN
+;;; Pick off a few easy cases, and the various top level EVAL-WHEN
 ;;; magical cases, and call %EVAL for the rest. 
 (defun eval (original-exp)
   #!+sb-doc
@@ -112,8 +112,8 @@
 		     (set (first args) (eval (second args)))))
 		(let ((symbol (first name)))
 		  (case (info :variable :kind symbol)
-		    ;; FIXME: I took out the *TOP-LEVEL-AUTO-DECLARE*
-		    ;; test here, and removed the *TOP-LEVEL-AUTO-DECLARE*
+		    ;; FIXME: I took out the *TOPLEVEL-AUTO-DECLARE*
+		    ;; test here, and removed the *TOPLEVEL-AUTO-DECLARE*
 		    ;; variable; the code should now act as though that
 		    ;; variable is NIL. This should be tested..
 		    (:special)
@@ -121,14 +121,14 @@
 	   ((progn)
 	    (eval-progn-body (rest exp)))
 	   ((eval-when)
-	    ;; FIXME: DESTRUCTURING-BIND returns
-	    ;; DEFMACRO-LL-ARG-COUNT-ERROR instead of PROGRAM-ERROR
-	    ;; when there's something wrong with the syntax here (e.g.
-	    ;; missing SITUATIONS). This could be fixed by
-	    ;; hand-crafting clauses to catch and report each
-	    ;; possibility, but it would probably be cleaner to write
-	    ;; a new macro DESTRUCTURING-BIND-PROGRAM-SYNTAX which
-	    ;; does DESTRUCTURING-BIND and promotes any mismatch to
+	    ;; FIXME: DESTRUCTURING-BIND returns ARG-COUNT-ERROR
+	    ;; instead of PROGRAM-ERROR when there's something wrong
+	    ;; with the syntax here (e.g. missing SITUATIONS). This
+	    ;; could be fixed by hand-crafting clauses to catch and
+	    ;; report each possibility, but it would probably be
+	    ;; cleaner to write a new macro
+	    ;; DESTRUCTURING-BIND-PROGRAM-SYNTAX which does
+	    ;; DESTRUCTURING-BIND and promotes any mismatch to
 	    ;; PROGRAM-ERROR, then to use it here and in (probably
 	    ;; dozens of) other places where the same problem arises.
 	    (destructuring-bind (eval-when situations &rest body) exp
@@ -156,39 +156,6 @@
 		(%eval original-exp))))))
       (t
        exp))))
-
-;;; Given a function, return three values:
-;;; 1] A lambda expression that could be used to define the function,
-;;;    or NIL if the definition isn't available.
-;;; 2] NIL if the function was definitely defined in a null lexical
-;;;    environment, and T otherwise.
-;;; 3] Some object that \"names\" the function. Although this is
-;;;    allowed to be any object, CMU CL always returns a valid
-;;;    function name or a string.
-;;;
-;;; If interpreted, use the interpreter interface. Otherwise, see
-;;; whether it was compiled with COMPILE. If that fails, check for an
-;;; inline expansion.
-(defun function-lambda-expression (fun)
-  (declare (type function fun))
-  (let* ((fun (%function-self fun))
-	 (name (%function-name fun))
-	 (code (sb!di::function-code-header fun))
-	 (info (sb!kernel:%code-debug-info code)))
-    (if info
-	(let ((source (first (sb!c::compiled-debug-info-source info))))
-	  (cond ((and (eq (sb!c::debug-source-from source) :lisp)
-		      (eq (sb!c::debug-source-info source) fun))
-		 (values (second (svref (sb!c::debug-source-name source) 0))
-			 nil name))
-		((stringp name)
-		 (values nil t name))
-		(t
-		 (let ((exp (info :function :inline-expansion name)))
-		   (if exp
-		       (values exp nil name)
-		       (values nil t name))))))
-	(values nil t name))))
 
 ;;; miscellaneous full function definitions of things which are
 ;;; ordinarily handled magically by the compiler