0.pre7.102:

	changed some "#'(LAMBDA " stuff to "(LAMBDA " (changing only
		a few this time because when I changed more, things
		started breaking)
	fixed FIXME at head of primordial-extensions.lisp (since it's
		trivial now that EVAL-WHEN works)

diff --git a/src/assembly/assemfile.lisp b/src/assembly/assemfile.lisp
index 7de12e5..10fe4d8 100644 (file)
--- a/src/assembly/assemfile.lisp
+++ b/src/assembly/assemfile.lisp
@@ -94,14 +94,13 @@
       (if (and (consp code) (consp (car code)) (eq (caar code) 'declare))
          (decls (pop code))
          (return)))
-    `(let (,@(mapcar
-             #'(lambda (reg)
-                 `(,(reg-spec-name reg)
-                   (make-random-tn
-                    :kind :normal
-                    :sc (sc-or-lose ',(reg-spec-sc reg))
-                    :offset ,(reg-spec-offset reg))))
-             regs))
+    `(let ,(mapcar (lambda (reg)
+                    `(,(reg-spec-name reg)
+                      (make-random-tn
+                       :kind :normal
+                       :sc (sc-or-lose ',(reg-spec-sc reg))
+                       :offset ,(reg-spec-offset reg))))
+                  regs)
        ,@(decls)
        (sb!assem:assemble (*code-segment* ',name)
         ,name
@@ -135,30 +134,30 @@
       `(define-vop ,(if (atom name) (list name) name)
         (:args ,@(mapcar #'arg-or-res-spec args))
         ,@(let ((index -1))
-            (mapcar #'(lambda (arg)
-                        `(:temporary (:sc ,(reg-spec-sc arg)
-                                          :offset ,(reg-spec-offset arg)
-                                          :from (:argument ,(incf index))
-                                          :to (:eval 2))
-                                     ,(reg-spec-temp arg)))
+            (mapcar (lambda (arg)
+                      `(:temporary (:sc ,(reg-spec-sc arg)
+                                    :offset ,(reg-spec-offset arg)
+                                    :from (:argument ,(incf index))
+                                    :to (:eval 2))
+                                   ,(reg-spec-temp arg)))
                     args))
-        ,@(mapcar #'(lambda (temp)
-                      `(:temporary (:sc ,(reg-spec-sc temp)
-                                        :offset ,(reg-spec-offset temp)
-                                        :from (:eval 1)
-                                        :to (:eval 3))
-                                   ,(reg-spec-name temp)))
+        ,@(mapcar (lambda (temp)
+                    `(:temporary (:sc ,(reg-spec-sc temp)
+                                  :offset ,(reg-spec-offset temp)
+                                  :from (:eval 1)
+                                  :to (:eval 3))
+                                 ,(reg-spec-name temp)))
                   temps)
         ,@call-temps
         (:vop-var ,vop)
         ,@(let ((index -1))
-            (mapcar #'(lambda (res)
-                        `(:temporary (:sc ,(reg-spec-sc res)
-                                          :offset ,(reg-spec-offset res)
-                                          :from (:eval 2)
-                                          :to (:result ,(incf index))
-                                          :target ,(reg-spec-name res))
-                                     ,(reg-spec-temp res)))
+            (mapcar (lambda (res)
+                      `(:temporary (:sc ,(reg-spec-sc res)
+                                    :offset ,(reg-spec-offset res)
+                                    :from (:eval 2)
+                                    :to (:result ,(incf index))
+                                    :target ,(reg-spec-name res))
+                                   ,(reg-spec-temp res)))
                     results))
         (:results ,@(mapcar #'arg-or-res-spec results))
         (:ignore ,@(mapcar #'reg-spec-name temps)
@@ -166,23 +165,23 @@
                           (mapcar #'cdr
                                   (remove :ignore call-temps
                                           :test-not #'eq :key #'car))))
-        ,@(remove-if #'(lambda (x)
-                         (member x '(:return-style :cost)))
+        ,@(remove-if (lambda (x)
+                       (member x '(:return-style :cost)))
                      options
                      :key #'car)
         (:generator ,cost
-          ,@(mapcar #'(lambda (arg)
-                        #!+(or hppa alpha) `(move ,(reg-spec-name arg)
-                                                  ,(reg-spec-temp arg))
-                        #!-(or hppa alpha) `(move ,(reg-spec-temp arg)
-                                                  ,(reg-spec-name arg)))
+          ,@(mapcar (lambda (arg)
+                      #!+(or hppa alpha) `(move ,(reg-spec-name arg)
+                                                ,(reg-spec-temp arg))
+                      #!-(or hppa alpha) `(move ,(reg-spec-temp arg)
+                                                ,(reg-spec-name arg)))
                     args)
           ,@call-sequence
-          ,@(mapcar #'(lambda (res)
-                        #!+(or hppa alpha) `(move ,(reg-spec-temp res)
-                                                  ,(reg-spec-name res))
-                        #!-(or hppa alpha) `(move ,(reg-spec-name res)
-                                                  ,(reg-spec-temp res)))
+          ,@(mapcar (lambda (res)
+                      #!+(or hppa alpha) `(move ,(reg-spec-temp res)
+                                                ,(reg-spec-name res))
+                      #!-(or hppa alpha) `(move ,(reg-spec-name res)
+                                                ,(reg-spec-temp res)))
                     results))))))
 
 (def!macro define-assembly-routine (name&options vars &body code)
@@ -191,7 +190,7 @@
          (values name&options nil)
        (values (car name&options)
                (cdr name&options)))
-    (let ((regs (mapcar #'(lambda (var) (apply #'parse-reg-spec var)) vars)))
+    (let ((regs (mapcar (lambda (var) (apply #'parse-reg-spec var)) vars)))
       (if *do-assembly*
          (emit-assemble name options regs code)
          (emit-vop name options regs)))))

diff --git a/src/code/array.lisp b/src/code/array.lisp
index c061ddb..f2b646a 100644 (file)
--- a/src/code/array.lisp
+++ b/src/code/array.lisp
@@ -61,11 +61,11 @@
 
 (eval-when (:compile-toplevel :execute)
   (sb!xc:defmacro pick-vector-type (type &rest specs)
-    `(cond ,@(mapcar #'(lambda (spec)
-                        `(,(if (eq (car spec) t)
-                               t
-                               `(subtypep ,type ',(car spec)))
-                          ,@(cdr spec)))
+    `(cond ,@(mapcar (lambda (spec)
+                      `(,(if (eq (car spec) t)
+                             t
+                             `(subtypep ,type ',(car spec)))
+                        ,@(cdr spec)))
                     specs))))
 
 ;;; These functions are used in the implementation of MAKE-ARRAY for

diff --git a/src/code/macros.lisp b/src/code/macros.lisp
index fe11e84..bc9ba0e 100644 (file)
--- a/src/code/macros.lisp
+++ b/src/code/macros.lisp
@@ -105,8 +105,8 @@ the usual naming convention (names like *FOO*) for special variables"
        ;; want bindings which are constant in some sense other than
        ;; EQL, I suggest either just using DEFVAR (which is usually
        ;; appropriate, despite the un-mnemonic name), or defining
-       ;; something like SB-INT:DEFCONSTANT-EQX (which is occasionally
-       ;; more appropriate). -- WHN 2000-11-03
+       ;; something like the DEFCONSTANT-EQX macro used in SBCL (which
+       ;; is occasionally more appropriate). -- WHN 2001-12-21
        (unless (eql value
                    (info :variable :constant-value name))
         (cerror "Go ahead and change the value."

diff --git a/src/code/primordial-extensions.lisp b/src/code/primordial-extensions.lisp
index 304c771..db95431 100644 (file)
--- a/src/code/primordial-extensions.lisp
+++ b/src/code/primordial-extensions.lisp
@@ -47,7 +47,8 @@
 ;;; interpreter to go away, which is waiting for sbcl-0.7.x..
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (defconstant +empty-ht-slot+ '%empty-ht-slot%))
-(defconstant +empty-ht-slot+ '#.+empty-ht-slot+) ; egads.. See FIXME above.
+;;; We shouldn't need this mess now that EVAL-WHEN works.
+#+nil (defconstant +empty-ht-slot+ '#.+empty-ht-slot+) ; egads.. See FIXME above.
 ;;; KLUDGE: Using a private symbol still leaves us vulnerable to users
 ;;; getting nonconforming behavior by messing around with
 ;;; DO-ALL-SYMBOLS. That seems like a fairly obscure problem, so for

diff --git a/version.lisp-expr b/version.lisp-expr
index b431767..a044495 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -18,4 +18,4 @@
 ;;; for internal versions, especially for internal versions off the
 ;;; main CVS branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
 
-"0.pre7.101"
+"0.pre7.102"