From: Nikodemus Siivola <nikodemus@random-state.net>
Date: Mon, 13 Sep 2004 08:36:29 +0000 (+0000)
Subject: 0.8.14.14: Two commits for the price of one
X-Git-Url: http://repo.macrolet.net/gitweb/?a=commitdiff_plain;h=fb92835b1dc240b7998b30ab0691bf6f60be7905;p=sbcl.git

0.8.14.14: Two commits for the price of one
            * Clean up indentation of IR1-CONVERT
            * NEWS entry about single stepping.
---

diff --git a/CREDITS b/CREDITS
index d93bbae..3f59ff6 100644
--- a/CREDITS
+++ b/CREDITS
@@ -675,7 +675,8 @@ Rudi Schlatte:
 Nikodemus Siivola:
   He provided build fixes, in particular to tame the SunOS toolchain,
   implemented package locks, ported the linkage-table code from CMUCL,
-  and has fixed many (stream-related and other) bugs besides.
+  reimplemented STEP, and has fixed many (stream-related and other) bugs 
+  besides.
 
 Juho Snellman:
   He provided several performance enhancements, including a better hash
diff --git a/NEWS b/NEWS
index 095aec7..e7a9cc0 100644
--- a/NEWS
+++ b/NEWS
@@ -3,6 +3,8 @@ changes in sbcl-0.8.15 relative to sbcl-0.8.14:
     SB-INT:*AFTER-SAVE-INITIALIZATIONS* have been renamed
     SB-EXT:*SAVE-HOOKS* and SB-EXT:*INIT-HOOKS*, and are now
     part of the supported interface.
+  * new feature: Single-stepping of code compiled with DEBUG 2 or higher
+    and (> DEBUG (MAX SPACE SPEED)) is now possible.
   * new feature: saving cores with foreign code loaded is now
     supported on x86/FreeBSD, x86/Linux, and sparc/SunOS. (based
     on Timothy Moore's work for CMUCL)
diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp
index 16f919b..07e2ce2 100644
--- a/src/compiler/ir1tran.lisp
+++ b/src/compiler/ir1tran.lisp
@@ -478,50 +478,51 @@
     (ir1-error-bailout (start next result form)
       (let ((*current-path* (or (gethash form *source-paths*)
 				(cons form *current-path*))))
-	(if (step-form-p form)
-	    (ir1-convert-step start next result form)
-	(if (atom form)
-	    (cond ((and (symbolp form) (not (keywordp form)))
-		   (ir1-convert-var start next result form))
-		  ((leaf-p form)
-		   (reference-leaf start next result form))
-		  (t
-		   (reference-constant start next result form)))
-	    (let ((opname (car form)))
-	      (cond ((or (symbolp opname) (leaf-p opname))
-		     (let ((lexical-def (if (leaf-p opname)
-                                            opname
-                                            (lexenv-find opname funs))))
-		       (typecase lexical-def
-			 (null
-                          (ir1-convert-global-functoid start next result
-                                                       form))
-			 (functional
-			  (ir1-convert-local-combination start next result
-							 form
-							 lexical-def))
-			 (global-var
-			  (ir1-convert-srctran start next result
-                                               lexical-def form))
-			 (t
-			  (aver (and (consp lexical-def)
-				     (eq (car lexical-def) 'macro)))
-			  (ir1-convert start next result
-				       (careful-expand-macro (cdr lexical-def)
-							     form))))))
-		    ((or (atom opname) (not (eq (car opname) 'lambda)))
-		     (compiler-error "illegal function call"))
-		    (t
-		     ;; implicitly (LAMBDA ..) because the LAMBDA
-		     ;; expression is the CAR of an executed form
-		     (ir1-convert-combination start next result
-					      form
-					      (ir1-convert-lambda
-					       opname
-					       :debug-name (debug-namify
-							    "LAMBDA CAR "
-							    opname)
-					       :allow-debug-catch-tag t)))))))))
+	(cond ((step-form-p form)
+               (ir1-convert-step start next result form))
+              ((atom form)
+               (cond ((and (symbolp form) (not (keywordp form)))
+                      (ir1-convert-var start next result form))
+                     ((leaf-p form)
+                      (reference-leaf start next result form))
+                     (t
+                      (reference-constant start next result form))))
+              (t
+               (let ((opname (car form)))
+                 (cond ((or (symbolp opname) (leaf-p opname))
+                        (let ((lexical-def (if (leaf-p opname)
+                                               opname
+                                               (lexenv-find opname funs))))
+                          (typecase lexical-def
+                            (null
+                             (ir1-convert-global-functoid start next result
+                                                          form))
+                            (functional
+                             (ir1-convert-local-combination start next result
+                                                            form
+                                                            lexical-def))
+                            (global-var
+                             (ir1-convert-srctran start next result
+                                                  lexical-def form))
+                            (t
+                             (aver (and (consp lexical-def)
+                                        (eq (car lexical-def) 'macro)))
+                             (ir1-convert start next result
+                                          (careful-expand-macro (cdr lexical-def)
+                                                                form))))))
+                       ((or (atom opname) (not (eq (car opname) 'lambda)))
+                        (compiler-error "illegal function call"))
+                       (t
+                        ;; implicitly (LAMBDA ..) because the LAMBDA
+                        ;; expression is the CAR of an executed form
+                        (ir1-convert-combination start next result
+                                                 form
+                                                 (ir1-convert-lambda
+                                                  opname
+                                                  :debug-name (debug-namify
+                                                               "LAMBDA CAR "
+                                                               opname)
+                                                  :allow-debug-catch-tag t)))))))))
     (values))
 
   ;; Generate a reference to a manifest constant, creating a new leaf
diff --git a/version.lisp-expr b/version.lisp-expr
index 4930318..a912b9b 100644
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -17,4 +17,4 @@
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
-"0.8.14.13"
+"0.8.14.14"