0.pre8.93:

	Antonio Martinez pointed out that an EQUAL test is needed for
		generalized function name lookup.
	(FORMAT NIL "~S ~S" '1W '1WW) => "|1W| 1WW" seems to be
		correct after all.

diff --git a/src/code/cold-error.lisp b/src/code/cold-error.lisp
index 4c62556..32f71ad 100644 (file)
--- a/src/code/cold-error.lisp
+++ b/src/code/cold-error.lisp
@@ -32,7 +32,7 @@
          (*break-on-signals* nil))
       (when (typep condition old-bos)
        (/noshow0 "doing BREAK in because of *BREAK-ON-SIGNALS*")
-       (break "~A~%BREAK was entered because of *BREAK-ON-SIGNALS* (now NIL)."
+       (break "~A~%BREAK was entered because of *BREAK-ON-SIGNALS* (now rebound to NIL)."
               condition)))
     (loop
       (unless *handler-clusters*

diff --git a/src/code/macroexpand.lisp b/src/code/macroexpand.lisp
index fc570d1..f351784 100644 (file)
--- a/src/code/macroexpand.lisp
+++ b/src/code/macroexpand.lisp
@@ -15,7 +15,7 @@
 
 (defun sb!xc:special-operator-p (symbol)
   #!+sb-doc
-  "If the symbol globally names a special form, returns T, otherwise NIL."
+  "If the symbol globally names a special form, return T, otherwise NIL."
   (declare (symbol symbol))
   (eq (info :function :kind symbol) :special-form))
 
@@ -31,7 +31,7 @@
 (declaim (ftype (function (t &optional (or null sb!c::lexenv))) sb!xc:macroexpand-1))
 (defun sb!xc:macroexpand-1 (form &optional env)
   #!+sb-doc
-  "If form is a macro (or symbol macro), expands it once. Returns two values,
+  "If form is a macro (or symbol macro), expand it once. Return two values,
    the expanded form and a T-or-NIL flag indicating whether the form was, in
    fact, a macro. ENV is the lexical environment to expand in, which defaults
    to the null environment."

diff --git a/src/code/print.lisp b/src/code/print.lisp
index 91f200f..0acd176 100644 (file)
--- a/src/code/print.lisp
+++ b/src/code/print.lisp
@@ -397,16 +397,16 @@
                  (check-for-circularity object t)
                ;; initialization of the circulation detect noise ...
               (if (eq initiate :initiate)
-                 (let ((*circularity-hash-table*
-                        (make-hash-table :test 'eq)))
-                   (check-it (make-broadcast-stream))
-                   (let ((*circularity-counter* 0))
-                     (check-it stream)))
-                 ;; otherwise
-                 (if marker
-                   (when (handle-circularity marker stream)
-                     (print-it stream))
-                   (print-it stream))))))
+                  (let ((*circularity-hash-table*
+                         (make-hash-table :test 'eq)))
+                    (check-it (make-broadcast-stream))
+                    (let ((*circularity-counter* 0))
+                      (check-it stream)))
+                  ;; otherwise
+                  (if marker
+                      (when (handle-circularity marker stream)
+                        (print-it stream))
+                      (print-it stream))))))
     (cond (;; Maybe we don't need to bother with circularity detection.
           (or (not *print-circle*)
               (uniquely-identified-by-print-p object))
@@ -682,7 +682,6 @@
              :initial-element 36))
 (declaim (type (simple-array (unsigned-byte 8) (#.char-code-limit))
               *digit-bases*))
-
 (dotimes (i 36)
   (let ((char (digit-char i 36)))
     (setf (aref *digit-bases* (char-code char)) i)))
@@ -830,6 +829,9 @@
       (return t)
 
      MARKER ; number marker in a numeric number...
+      ;; ("What," you may ask, "is a 'number marker'?" It's something
+      ;; that a conforming implementation might use in number syntax.
+      ;; See ANSI 2.3.1.1 "Potential Numbers as Tokens".)
       (when (test letter) (advance OTHER nil))
       (go DIGIT))))
 \f

diff --git a/src/code/profile.lisp b/src/code/profile.lisp
index 87eab0b..0a257b3 100644 (file)
--- a/src/code/profile.lisp
+++ b/src/code/profile.lisp
@@ -47,7 +47,11 @@
 ;;; We associate a PROFILE-INFO structure with each profiled function
 ;;; name. This holds the functions that we call to manipulate the
 ;;; closure which implements the encapsulation.
-(defvar *profiled-fun-name->info* (make-hash-table))
+(defvar *profiled-fun-name->info*
+  (make-hash-table
+   ;; EQL testing isn't good enough for generalized function names
+   ;; like (SETF FOO).
+   :test 'equal))
 (defstruct (profile-info (:copier nil))
   (name              (missing-arg) :read-only t)
   (encapsulated-fun  (missing-arg) :type function :read-only t)

diff --git a/version.lisp-expr b/version.lisp-expr
index dd4d9e6..9319e47 100644 (file)
--- 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.pre8.92"
+"0.pre8.93"