0.pre7.137:

[sbcl.git] / src / pcl / boot.lisp

diff --git a/src/pcl/boot.lisp b/src/pcl/boot.lisp
index 866f813..747a555 100644 (file)
--- a/src/pcl/boot.lisp
+++ b/src/pcl/boot.lisp
@@ -105,17 +105,14 @@ bootstrapping.
 ;;; early definition. Do this in a way that makes sure that if we
 ;;; redefine one of the early definitions the redefinition will take
 ;;; effect. This makes development easier.
 ;;; early definition. Do this in a way that makes sure that if we
 ;;; redefine one of the early definitions the redefinition will take
 ;;; effect. This makes development easier.

-(eval-when (:load-toplevel :execute)
-  

 (dolist (fns *!early-functions*)
   (let ((name (car fns))
        (early-name (cadr fns)))
     (setf (gdefinition name)
 (dolist (fns *!early-functions*)
   (let ((name (car fns))
        (early-name (cadr fns)))
     (setf (gdefinition name)

-            (set-function-name
+            (set-fun-name

              (lambda (&rest args)
               (apply (fdefinition early-name) args))
              name))))
              (lambda (&rest args)
               (apply (fdefinition early-name) args))
              name))))

-) ; EVAL-WHEN

 
 ;;; *!GENERIC-FUNCTION-FIXUPS* is used by !FIX-EARLY-GENERIC-FUNCTIONS
 ;;; to convert the few functions in the bootstrap which are supposed
 
 ;;; *!GENERIC-FUNCTION-FIXUPS* is used by !FIX-EARLY-GENERIC-FUNCTIONS
 ;;; to convert the few functions in the bootstrap which are supposed

@@ -134,12 +131,12 @@ bootstrapping.
       (standard-generic-function t t)
       real-get-method))
     (ensure-generic-function-using-class
       (standard-generic-function t t)
       real-get-method))
     (ensure-generic-function-using-class

-     ((generic-function function-name
+     ((generic-function fun-name

                        &key generic-function-class environment
                        &allow-other-keys)
       (generic-function t)
       real-ensure-gf-using-class--generic-function)
                        &key generic-function-class environment
                        &allow-other-keys)
       (generic-function t)
       real-ensure-gf-using-class--generic-function)

-     ((generic-function function-name
+     ((generic-function fun-name

                        &key generic-function-class environment
                        &allow-other-keys)
       (null t)
                        &key generic-function-class environment
                        &allow-other-keys)
       (null t)

@@ -159,14 +156,11 @@ bootstrapping.
       (generic-function standard-method-combination t)
       standard-compute-effective-method))))
 \f
       (generic-function standard-method-combination t)
       standard-compute-effective-method))))
 \f

-(defmacro defgeneric (function-name lambda-list &body options)
-  (expand-defgeneric function-name lambda-list options))
-
-(defun expand-defgeneric (function-name lambda-list options)
+(defmacro defgeneric (fun-name lambda-list &body options)

   (let ((initargs ())
        (methods ()))
     (flet ((duplicate-option (name)
   (let ((initargs ())
        (methods ()))
     (flet ((duplicate-option (name)

-            (error 'sb-kernel:simple-program-error
+            (error 'simple-program-error

                    :format-control "The option ~S appears more than once."
                    :format-arguments (list name)))
           (expand-method-definition (qab) ; QAB = qualifiers, arglist, body
                    :format-control "The option ~S appears more than once."
                    :format-arguments (list name)))
           (expand-method-definition (qab) ; QAB = qualifiers, arglist, body

@@ -174,12 +168,7 @@ bootstrapping.
                    (arglist (elt qab arglist-pos))
                    (qualifiers (subseq qab 0 arglist-pos))
                    (body (nthcdr (1+ arglist-pos) qab)))
                    (arglist (elt qab arglist-pos))
                    (qualifiers (subseq qab 0 arglist-pos))
                    (body (nthcdr (1+ arglist-pos) qab)))

-              (when (not (equal (cadr (getf initargs :method-combination))
-                                qualifiers))
-                (error "bad method specification in DEFGENERIC ~A~%~
-                        -- qualifier mismatch for lambda list ~A"
-                       function-name arglist))
-              `(defmethod ,function-name ,@qualifiers ,arglist ,@body))))
+              `(defmethod ,fun-name ,@qualifiers ,arglist ,@body))))

       (macrolet ((initarg (key) `(getf initargs ,key)))
        (dolist (option options)
          (let ((car-option (car option)))
       (macrolet ((initarg (key) `(getf initargs ,key)))
        (dolist (option options)
          (let ((car-option (car option)))

@@ -192,7 +181,7 @@ bootstrapping.
                   (setf (initarg car-option)
                         `',(cdr option))))
              ((:documentation :generic-function-class :method-class)
                   (setf (initarg car-option)
                         `',(cdr option))))
              ((:documentation :generic-function-class :method-class)

-              (unless (sb-int:proper-list-of-length-p option 2)
+              (unless (proper-list-of-length-p option 2)

                 (error "bad list length for ~S" option))
               (if (initarg car-option)
                   (duplicate-option car-option)
                 (error "bad list length for ~S" option))
               (if (initarg car-option)
                   (duplicate-option car-option)

@@ -202,7 +191,7 @@ bootstrapping.
              (t
               ;; ANSI requires that unsupported things must get a
               ;; PROGRAM-ERROR.
              (t
               ;; ANSI requires that unsupported things must get a
               ;; PROGRAM-ERROR.

-              (error 'sb-kernel:simple-program-error
+              (error 'simple-program-error

                      :format-control "unsupported option ~S"
                      :format-arguments (list option))))))
 
                      :format-control "unsupported option ~S"
                      :format-arguments (list option))))))
 

@@ -211,27 +200,26 @@ bootstrapping.
                `',(initarg :declarations))))
       `(progn
         (eval-when (:compile-toplevel :load-toplevel :execute)
                `',(initarg :declarations))))
       `(progn
         (eval-when (:compile-toplevel :load-toplevel :execute)

-          (compile-or-load-defgeneric ',function-name))
-         (load-defgeneric ',function-name ',lambda-list ,@initargs)
+          (compile-or-load-defgeneric ',fun-name))
+         (load-defgeneric ',fun-name ',lambda-list ,@initargs)

         ,@(mapcar #'expand-method-definition methods)
         ,@(mapcar #'expand-method-definition methods)

-        `,(function ,function-name)))))
-
-(defun compile-or-load-defgeneric (function-name)
-  (sb-kernel:proclaim-as-function-name function-name)
-  (sb-kernel:note-name-defined function-name :function)
-  (unless (eq (sb-int:info :function :where-from function-name) :declared)
-    (setf (sb-int:info :function :where-from function-name) :defined)
-    (setf (sb-int:info :function :type function-name)
+        `,(function ,fun-name)))))
+
+(defun compile-or-load-defgeneric (fun-name)
+  (sb-kernel:proclaim-as-fun-name fun-name)
+  (sb-kernel:note-name-defined fun-name :function)
+  (unless (eq (info :function :where-from fun-name) :declared)
+    (setf (info :function :where-from fun-name) :defined)
+    (setf (info :function :type fun-name)

          (sb-kernel:specifier-type 'function))))
 
          (sb-kernel:specifier-type 'function))))
 

-(defun load-defgeneric (function-name lambda-list &rest initargs)
-  (when (fboundp function-name)
-    (sb-kernel::style-warn "redefining ~S in DEFGENERIC" function-name))
+(defun load-defgeneric (fun-name lambda-list &rest initargs)
+  (when (fboundp fun-name)
+    (sb-kernel::style-warn "redefining ~S in DEFGENERIC" fun-name))

   (apply #'ensure-generic-function
   (apply #'ensure-generic-function

-        function-name
+        fun-name

         :lambda-list lambda-list
         :lambda-list lambda-list

-        :definition-source `((defgeneric ,function-name)
-                             ,*load-truename*)
+        :definition-source `((defgeneric ,fun-name) ,*load-truename*)

         initargs))
 \f
 (defmacro defmethod (&rest args &environment env)
         initargs))
 \f
 (defmacro defmethod (&rest args &environment env)

@@ -340,8 +328,8 @@ bootstrapping.
                                       (class-name (class-of proto-method))
                                       'standard-method)
                                   initargs-form
                                       (class-name (class-of proto-method))
                                       'standard-method)
                                   initargs-form

-                                  (getf (getf initargs ':plist)
-                                        ':pv-table-symbol))))))))
+                                  (getf (getf initargs :plist)
+                                        :pv-table-symbol))))))))

 
 (defun interned-symbol-p (x)
   (and (symbolp x) (symbol-package x)))
 
 (defun interned-symbol-p (x)
   (and (symbolp x) (symbol-package x)))

@@ -351,18 +339,18 @@ bootstrapping.
                                 initargs-form &optional pv-table-symbol)
   (let (fn
        fn-lambda)
                                 initargs-form &optional pv-table-symbol)
   (let (fn
        fn-lambda)

-    (if (and (interned-symbol-p (sb-int:function-name-block-name name))
+    (if (and (interned-symbol-p (fun-name-block-name name))

             (every #'interned-symbol-p qualifiers)
             (every #'interned-symbol-p qualifiers)

-            (every #'(lambda (s)
-                       (if (consp s)
-                           (and (eq (car s) 'eql)
-                                (constantp (cadr s))
-                                (let ((sv (eval (cadr s))))
-                                  (or (interned-symbol-p sv)
-                                      (integerp sv)
-                                      (and (characterp sv)
-                                           (standard-char-p sv)))))
-                           (interned-symbol-p s)))
+            (every (lambda (s)
+                     (if (consp s)
+                         (and (eq (car s) 'eql)
+                              (constantp (cadr s))
+                              (let ((sv (eval (cadr s))))
+                                (or (interned-symbol-p sv)
+                                    (integerp sv)
+                                    (and (characterp sv)
+                                         (standard-char-p sv)))))
+                         (interned-symbol-p s)))

                    specializers)
             (consp initargs-form)
             (eq (car initargs-form) 'list*)
                    specializers)
             (consp initargs-form)
             (eq (car initargs-form) 'list*)

@@ -376,7 +364,7 @@ bootstrapping.
                                     `(,(car specl) ,(eval (cadr specl)))
                                   specl))
                               specializers))
                                     `(,(car specl) ,(eval (cadr specl)))
                                   specl))
                               specializers))

-              (mname `(,(if (eq (cadr initargs-form) ':function)
+              (mname `(,(if (eq (cadr initargs-form) :function)

                             'method 'fast-method)
                        ,name ,@qualifiers ,specls))
               (mname-sym (intern (let ((*print-pretty* nil)
                             'method 'fast-method)
                        ,name ,@qualifiers ,specls))
               (mname-sym (intern (let ((*print-pretty* nil)

@@ -385,29 +373,29 @@ bootstrapping.
                                        ;; force symbols to be printed
                                        ;; with explicit package
                                        ;; prefixes.)
                                        ;; force symbols to be printed
                                        ;; with explicit package
                                        ;; prefixes.)

-                                       (*package* sb-int:*keyword-package*))
+                                       (*package* *keyword-package*))

                                    (format nil "~S" mname)))))
                                    (format nil "~S" mname)))))

-         `(eval-when (:load-toplevel :execute)
-           (defun ,mname-sym ,(cadr fn-lambda)
-             ,@(cddr fn-lambda))
-           ,(make-defmethod-form-internal
-             name qualifiers `',specls
-             unspecialized-lambda-list method-class-name
-             `(list* ,(cadr initargs-form)
-                     #',mname-sym
-                     ,@(cdddr initargs-form))
-             pv-table-symbol)))
-      (make-defmethod-form-internal
-       name qualifiers
-         `(list ,@(mapcar #'(lambda (specializer)
-                              (if (consp specializer)
-                                  ``(,',(car specializer)
-                                     ,,(cadr specializer))
-                                  `',specializer))
-                           specializers))
-         unspecialized-lambda-list method-class-name
-         initargs-form
-         pv-table-symbol))))
+         `(progn
+            (defun ,mname-sym ,(cadr fn-lambda)
+              ,@(cddr fn-lambda))
+            ,(make-defmethod-form-internal
+              name qualifiers `',specls
+              unspecialized-lambda-list method-class-name
+              `(list* ,(cadr initargs-form)
+                      #',mname-sym
+                      ,@(cdddr initargs-form))
+              pv-table-symbol)))
+       (make-defmethod-form-internal
+        name qualifiers
+        `(list ,@(mapcar (lambda (specializer)
+                           (if (consp specializer)
+                               ``(,',(car specializer)
+                                  ,,(cadr specializer))
+                               `',specializer))
+                         specializers))
+        unspecialized-lambda-list method-class-name
+        initargs-form
+        pv-table-symbol))))

 
 (defun make-defmethod-form-internal
     (name qualifiers specializers-form unspecialized-lambda-list
 
 (defun make-defmethod-form-internal
     (name qualifiers specializers-form unspecialized-lambda-list

@@ -552,7 +540,7 @@ bootstrapping.
                  ;; These declarations seem to be used by PCL to pass
                  ;; information to itself; when I tried to delete 'em
                  ;; ca. 0.6.10 it didn't work. I'm not sure how
                  ;; These declarations seem to be used by PCL to pass
                  ;; information to itself; when I tried to delete 'em
                  ;; ca. 0.6.10 it didn't work. I'm not sure how

-                 ;; they work, but note the (VARIABLE-DECLARATION '%CLASS ..)
+                 ;; they work, but note the (VAR-DECLARATION '%CLASS ..)

                  ;; expression in CAN-OPTIMIZE-ACCESS1. -- WHN 2000-12-30
                  ,@(remove nil
                            (mapcar (lambda (a s) (and (symbolp s)
                  ;; expression in CAN-OPTIMIZE-ACCESS1. -- WHN 2000-12-30
                  ,@(remove nil
                            (mapcar (lambda (a s) (and (symbolp s)

@@ -596,8 +584,7 @@ bootstrapping.
                   (declare (ignorable ,@required-parameters))
                   ,class-declarations
                   ,@declarations
                   (declare (ignorable ,@required-parameters))
                   ,class-declarations
                   ,@declarations

-                  (block ,(sb-int:function-name-block-name
-                           generic-function-name)
+                  (block ,(fun-name-block-name generic-function-name)

                     ,@real-body)))
               (constant-value-p (and (null (cdr real-body))
                                      (constantp (car real-body))))
                     ,@real-body)))
               (constant-value-p (and (null (cdr real-body))
                                      (constantp (car real-body))))

@@ -710,7 +697,7 @@ bootstrapping.
                `(not (null .next-method.))))
      ,@body))
 
                `(not (null .next-method.))))
      ,@body))
 

-(defstruct method-call
+(defstruct (method-call (:copier nil))

   (function #'identity :type function)
   call-method-args)
 
   (function #'identity :type function)
   call-method-args)
 

@@ -731,7 +718,7 @@ bootstrapping.
                             `(list ,@required-args+rest-arg))
                        (method-call-call-method-args ,method-call)))
 
                             `(list ,@required-args+rest-arg))
                        (method-call-call-method-args ,method-call)))
 

-(defstruct fast-method-call
+(defstruct (fast-method-call (:copier nil))

   (function #'identity :type function)
   pv-cell
   next-method-call
   (function #'identity :type function)
   pv-cell
   next-method-call

@@ -748,7 +735,7 @@ bootstrapping.
                (fast-method-call-next-method-call ,method-call)
                ,@required-args+rest-arg))
 
                (fast-method-call-next-method-call ,method-call)
                ,@required-args+rest-arg))
 

-(defstruct fast-instance-boundp
+(defstruct (fast-instance-boundp (:copier nil))

   (index 0 :type fixnum))
 
 #-sb-fluid (declaim (sb-ext:freeze-type fast-instance-boundp))
   (index 0 :type fixnum))
 
 #-sb-fluid (declaim (sb-ext:freeze-type fast-instance-boundp))

@@ -809,7 +796,22 @@ bootstrapping.
   (unless (constantp restp)
     (error "The RESTP argument is not constant."))
   (setq restp (eval restp))
   (unless (constantp restp)
     (error "The RESTP argument is not constant."))
   (setq restp (eval restp))

-  `(progn
+  `(locally
+
+     ;; In sbcl-0.6.11.43, the compiler would issue bogus warnings
+     ;; about type mismatches in unreachable code when we
+     ;; macroexpanded the GET-SLOTS-OR-NIL expressions here and
+     ;; byte-compiled the code. GET-SLOTS-OR-NIL is now an inline
+     ;; function instead of a macro, which seems sufficient to solve
+     ;; the problem all by itself (probably because of some quirk in
+     ;; the relative order of expansion and type inference) but we
+     ;; also use overkill by NOTINLINEing GET-SLOTS-OR-NIL, because it
+     ;; looks as though (1) inlining isn't that much of a win anyway,
+     ;; and (2a) once you miss the FAST-METHOD-CALL clause you're
+     ;; going to be slow anyway, but (2b) code bloat still hurts even
+     ;; when it's off the critical path.
+     (declare (notinline get-slots-or-nil))
+

      (trace-emf-call ,emf ,restp (list ,@required-args+rest-arg))
      (cond ((typep ,emf 'fast-method-call)
             (invoke-fast-method-call ,emf ,@required-args+rest-arg))
      (trace-emf-call ,emf ,restp (list ,@required-args+rest-arg))
      (cond ((typep ,emf 'fast-method-call)
             (invoke-fast-method-call ,emf ,@required-args+rest-arg))

@@ -912,22 +914,22 @@ bootstrapping.
     (fast-method-call (let* ((arg-info (gf-arg-info gf))
                             (nreq (arg-info-number-required arg-info))
                             (restp (arg-info-applyp arg-info)))
     (fast-method-call (let* ((arg-info (gf-arg-info gf))
                             (nreq (arg-info-number-required arg-info))
                             (restp (arg-info-applyp arg-info)))

-                       #'(lambda (&rest args)
-                           (trace-emf-call emf t args)
-                           (apply (fast-method-call-function emf)
-                                  (fast-method-call-pv-cell emf)
-                                  (fast-method-call-next-method-call emf)
-                                  (if restp
-                                      (let* ((rest-args (nthcdr nreq args))
-                                             (req-args (ldiff args
-                                                              rest-args)))
-                                        (nconc req-args rest-args))
-                                      args)))))
-    (method-call #'(lambda (&rest args)
-                    (trace-emf-call emf t args)
-                    (apply (method-call-function emf)
-                           args
-                           (method-call-call-method-args emf))))
+                       (lambda (&rest args)
+                         (trace-emf-call emf t args)
+                         (apply (fast-method-call-function emf)
+                                (fast-method-call-pv-cell emf)
+                                (fast-method-call-next-method-call emf)
+                                (if restp
+                                    (let* ((rest-args (nthcdr nreq args))
+                                           (req-args (ldiff args
+                                                            rest-args)))
+                                      (nconc req-args rest-args))
+                                    args)))))
+    (method-call (lambda (&rest args)
+                  (trace-emf-call emf t args)
+                  (apply (method-call-function emf)
+                         args
+                         (method-call-call-method-args emf))))

     (function emf)))
 \f
 (defmacro bind-fast-lexical-method-macros ((args rest-arg next-method-call)
     (function emf)))
 \f
 (defmacro bind-fast-lexical-method-macros ((args rest-arg next-method-call)

@@ -966,8 +968,8 @@ bootstrapping.
              (null closurep)
              (null applyp))
         `(let () ,@body))
              (null closurep)
              (null applyp))
         `(let () ,@body))

-        ((and (null closurep)
-              (null applyp))
+       ((and (null closurep)
+             (null applyp))

         ;; OK to use MACROLET, and all args are mandatory
         ;; (else APPLYP would be true).
         `(call-next-method-bind
         ;; OK to use MACROLET, and all args are mandatory
         ;; (else APPLYP would be true).
         `(call-next-method-bind

@@ -1021,14 +1023,14 @@ bootstrapping.
                                                      ,(cadr var)))))))
                   (rest `((,var ,args-tail)))
                   (key (cond ((not (consp var))
                                                      ,(cadr var)))))))
                   (rest `((,var ,args-tail)))
                   (key (cond ((not (consp var))

-                              `((,var (get-key-arg ,(sb-int:keywordicate var)
+                              `((,var (get-key-arg ,(keywordicate var)

                                                    ,args-tail))))
                              ((null (cddr var))
                               (multiple-value-bind (keyword variable)
                                   (if (consp (car var))
                                       (values (caar var)
                                               (cadar var))
                                                    ,args-tail))))
                              ((null (cddr var))
                               (multiple-value-bind (keyword variable)
                                   (if (consp (car var))
                                       (values (caar var)
                                               (cadar var))

-                                      (values (sb-int:keywordicate (car var))
+                                      (values (keywordicate (car var))

                                               (car var)))
                                 `((,key (get-key-arg1 ',keyword ,args-tail))
                                   (,variable (if (consp ,key)
                                               (car var)))
                                 `((,key (get-key-arg1 ',keyword ,args-tail))
                                   (,variable (if (consp ,key)

@@ -1039,7 +1041,7 @@ bootstrapping.
                                   (if (consp (car var))
                                       (values (caar var)
                                               (cadar var))
                                   (if (consp (car var))
                                       (values (caar var)
                                               (cadar var))

-                                      (values (sb-int:keywordicate (car var))
+                                      (values (keywordicate (car var))

                                               (car var)))
                                 `((,key (get-key-arg1 ',keyword ,args-tail))
                                   (,(caddr var) ,key)
                                               (car var)))
                                 `((,key (get-key-arg1 ',keyword ,args-tail))
                                   (,(caddr var) ,key)

@@ -1071,7 +1073,7 @@ bootstrapping.
        (next-method-p-p nil))     ; flag indicating that NEXT-METHOD-P
                                   ; should be in the method definition
     (flet ((walk-function (form context env)
        (next-method-p-p nil))     ; flag indicating that NEXT-METHOD-P
                                   ; should be in the method definition
     (flet ((walk-function (form context env)

-            (cond ((not (eq context ':eval)) form)
+            (cond ((not (eq context :eval)) form)

                   ;; FIXME: Jumping to a conclusion from the way it's used
                   ;; above, perhaps CONTEXT should be called SITUATION
                   ;; (after the term used in the ANSI specification of
                   ;; FIXME: Jumping to a conclusion from the way it's used
                   ;; above, perhaps CONTEXT should be called SITUATION
                   ;; (after the term used in the ANSI specification of

@@ -1097,8 +1099,9 @@ bootstrapping.
                   ((and (memq (car form)
                                '(slot-value set-slot-value slot-boundp))
                         (constantp (caddr form)))
                   ((and (memq (car form)
                                '(slot-value set-slot-value slot-boundp))
                         (constantp (caddr form)))

-                     (let ((parameter
-                            (can-optimize-access form required-parameters env)))
+                     (let ((parameter (can-optimize-access form
+                                                          required-parameters
+                                                          env)))

                       (let ((fun (ecase (car form)
                                    (slot-value #'optimize-slot-value)
                                    (set-slot-value #'optimize-set-slot-value)
                       (let ((fun (ecase (car form)
                                    (slot-value #'optimize-slot-value)
                                    (set-slot-value #'optimize-set-slot-value)

@@ -1129,7 +1132,7 @@ bootstrapping.
                next-method-p-p)))))
 
 (defun generic-function-name-p (name)
                next-method-p-p)))))
 
 (defun generic-function-name-p (name)

-  (and (sb-int:legal-function-name-p name)
+  (and (legal-fun-name-p name)

        (gboundp name)
        (if (eq *boot-state* 'complete)
           (standard-generic-function-p (gdefinition name))
        (gboundp name)
        (if (eq *boot-state* 'complete)
           (standard-generic-function-p (gdefinition name))

@@ -1190,10 +1193,9 @@ bootstrapping.
 (defun load-defmethod
     (class name quals specls ll initargs &optional pv-table-symbol)
   (setq initargs (copy-tree initargs))
 (defun load-defmethod
     (class name quals specls ll initargs &optional pv-table-symbol)
   (setq initargs (copy-tree initargs))

-  (let ((method-spec (or (getf initargs ':method-spec)
+  (let ((method-spec (or (getf initargs :method-spec)

                         (make-method-spec name quals specls))))
                         (make-method-spec name quals specls))))

-    (setf (getf initargs ':method-spec) method-spec)
-    (record-definition 'method method-spec)
+    (setf (getf initargs :method-spec) method-spec)

     (load-defmethod-internal class name quals specls
                             ll initargs pv-table-symbol)))
 
     (load-defmethod-internal class name quals specls
                             ll initargs pv-table-symbol)))
 

@@ -1201,7 +1203,7 @@ bootstrapping.
     (method-class gf-spec qualifiers specializers lambda-list
                  initargs pv-table-symbol)
   (when pv-table-symbol
     (method-class gf-spec qualifiers specializers lambda-list
                  initargs pv-table-symbol)
   (when pv-table-symbol

-    (setf (getf (getf initargs ':plist) :pv-table-symbol)
+    (setf (getf (getf initargs :plist) :pv-table-symbol)

          pv-table-symbol))
   (when (and (eq *boot-state* 'complete)
             (fboundp gf-spec))
          pv-table-symbol))
   (when (and (eq *boot-state* 'complete)
             (fboundp gf-spec))

@@ -1238,12 +1240,12 @@ bootstrapping.
   `(method ,gf-spec ,@qualifiers ,unparsed-specializers))
 
 (defun initialize-method-function (initargs &optional return-function-p method)
   `(method ,gf-spec ,@qualifiers ,unparsed-specializers))
 
 (defun initialize-method-function (initargs &optional return-function-p method)

-  (let* ((mf (getf initargs ':function))
-        (method-spec (getf initargs ':method-spec))
-        (plist (getf initargs ':plist))
-        (pv-table-symbol (getf plist ':pv-table-symbol))
+  (let* ((mf (getf initargs :function))
+        (method-spec (getf initargs :method-spec))
+        (plist (getf initargs :plist))
+        (pv-table-symbol (getf plist :pv-table-symbol))

         (pv-table nil)
         (pv-table nil)

-        (mff (getf initargs ':fast-function)))
+        (mff (getf initargs :fast-function)))

     (flet ((set-mf-property (p v)
             (when mf
               (setf (method-function-get mf p) v))
     (flet ((set-mf-property (p v)
             (when mf
               (setf (method-function-get mf p) v))

@@ -1251,7 +1253,7 @@ bootstrapping.
               (setf (method-function-get mff p) v))))
       (when method-spec
        (when mf
               (setf (method-function-get mff p) v))))
       (when method-spec
        (when mf

-         (setq mf (set-function-name mf method-spec)))
+         (setq mf (set-fun-name mf method-spec)))

        (when mff
          (let ((name `(,(or (get (car method-spec) 'fast-sym)
                             (setf (get (car method-spec) 'fast-sym)
        (when mff
          (let ((name `(,(or (get (car method-spec) 'fast-sym)
                             (setf (get (car method-spec) 'fast-sym)

@@ -1267,7 +1269,7 @@ bootstrapping.
                                                   (car method-spec))
                                           *pcl-package*)))
                         ,@(cdr method-spec))))
                                                   (car method-spec))
                                           *pcl-package*)))
                         ,@(cdr method-spec))))

-           (set-function-name mff name)
+           (set-fun-name mff name)

            (unless mf
              (set-mf-property :name name)))))
       (when plist
            (unless mf
              (set-mf-property :name name)))))
       (when plist

@@ -1287,16 +1289,17 @@ bootstrapping.
 \f
 (defun analyze-lambda-list (lambda-list)
   (flet (;; FIXME: Is this redundant with SB-C::MAKE-KEYWORD-FOR-ARG?
 \f
 (defun analyze-lambda-list (lambda-list)
   (flet (;; FIXME: Is this redundant with SB-C::MAKE-KEYWORD-FOR-ARG?

-        (parse-keyword-argument (arg)
+        (parse-key-arg (arg)

           (if (listp arg)
               (if (listp (car arg))
                   (caar arg)
           (if (listp arg)
               (if (listp (car arg))
                   (caar arg)

-                  (sb-int:keywordicate (car arg)))
-              (sb-int:keywordicate arg))))
+                  (keywordicate (car arg)))
+              (keywordicate arg))))

     (let ((nrequired 0)
          (noptional 0)
          (keysp nil)
          (restp nil)
     (let ((nrequired 0)
          (noptional 0)
          (keysp nil)
          (restp nil)

+          (nrest 0)

          (allow-other-keys-p nil)
          (keywords ())
          (keyword-parameters ())
          (allow-other-keys-p nil)
          (keywords ())
          (keyword-parameters ())

@@ -1317,9 +1320,13 @@ bootstrapping.
            (ecase state
              (required  (incf nrequired))
              (optional  (incf noptional))
            (ecase state
              (required  (incf nrequired))
              (optional  (incf noptional))

-             (key       (push (parse-keyword-argument x) keywords)
+             (key       (push (parse-key-arg x) keywords)

                         (push x keyword-parameters))
                         (push x keyword-parameters))

-             (rest      ()))))
+             (rest      (incf nrest)))))
+      (when (and restp (zerop nrest))
+        (error "Error in lambda-list:~%~
+                After &REST, a DEFGENERIC lambda-list ~
+                must be followed by at least one variable."))

       (values nrequired noptional keysp restp allow-other-keys-p
              (reverse keywords)
              (reverse keyword-parameters)))))
       (values nrequired noptional keysp restp allow-other-keys-p
              (reverse keywords)
              (reverse keyword-parameters)))))

@@ -1327,7 +1334,7 @@ bootstrapping.
 (defun keyword-spec-name (x)
   (let ((key (if (atom x) x (car x))))
     (if (atom key)
 (defun keyword-spec-name (x)
   (let ((key (if (atom x) x (car x))))
     (if (atom key)

-       (intern (symbol-name key) sb-int:*keyword-package*)
+       (keywordicate key)

        (car key))))
 
 (defun ftype-declaration-from-lambda-list (lambda-list name)
        (car key))))
 
 (defun ftype-declaration-from-lambda-list (lambda-list name)

@@ -1335,16 +1342,16 @@ bootstrapping.
                                  keywords keyword-parameters)
       (analyze-lambda-list lambda-list)
     (declare (ignore keyword-parameters))
                                  keywords keyword-parameters)
       (analyze-lambda-list lambda-list)
     (declare (ignore keyword-parameters))

-    (let* ((old (sb-int:info :function :type name)) ;FIXME:FDOCUMENTATION instead?
-          (old-ftype (if (sb-kernel:function-type-p old) old nil))
-          (old-restp (and old-ftype (sb-kernel:function-type-rest old-ftype)))
+    (let* ((old (info :function :type name)) ;FIXME:FDOCUMENTATION instead?
+          (old-ftype (if (sb-kernel:fun-type-p old) old nil))
+          (old-restp (and old-ftype (sb-kernel:fun-type-rest old-ftype)))

           (old-keys (and old-ftype
                          (mapcar #'sb-kernel:key-info-name
           (old-keys (and old-ftype
                          (mapcar #'sb-kernel:key-info-name

-                                 (sb-kernel:function-type-keywords
+                                 (sb-kernel:fun-type-keywords

                                   old-ftype))))
                                   old-ftype))))

-          (old-keysp (and old-ftype (sb-kernel:function-type-keyp old-ftype)))
+          (old-keysp (and old-ftype (sb-kernel:fun-type-keyp old-ftype)))

           (old-allowp (and old-ftype
           (old-allowp (and old-ftype

-                           (sb-kernel:function-type-allowp old-ftype)))
+                           (sb-kernel:fun-type-allowp old-ftype)))

           (keywords (union old-keys (mapcar #'keyword-spec-name keywords))))
       `(function ,(append (make-list nrequired :initial-element t)
                          (when (plusp noptional)
           (keywords (union old-keys (mapcar #'keyword-spec-name keywords))))
       `(function ,(append (make-list nrequired :initial-element t)
                          (when (plusp noptional)

@@ -1354,8 +1361,8 @@ bootstrapping.
                            '(&rest t))
                          (when (or keysp old-keysp)
                            (append '(&key)
                            '(&rest t))
                          (when (or keysp old-keysp)
                            (append '(&key)

-                                   (mapcar #'(lambda (key)
-                                               `(,key t))
+                                   (mapcar (lambda (key)
+                                             `(,key t))

                                            keywords)
                                    (when (or allow-other-keys-p old-allowp)
                                      '(&allow-other-keys)))))
                                            keywords)
                                    (when (or allow-other-keys-p old-allowp)
                                      '(&allow-other-keys)))))

@@ -1363,45 +1370,44 @@ bootstrapping.
 
 (defun defgeneric-declaration (spec lambda-list)
   (when (consp spec)
 
 (defun defgeneric-declaration (spec lambda-list)
   (when (consp spec)

-    (setq spec (get-setf-function-name (cadr spec))))
+    (setq spec (get-setf-fun-name (cadr spec))))

   `(ftype ,(ftype-declaration-from-lambda-list lambda-list spec) ,spec))
 \f
 ;;;; early generic function support
 
 (defvar *!early-generic-functions* ())
 
   `(ftype ,(ftype-declaration-from-lambda-list lambda-list spec) ,spec))
 \f
 ;;;; early generic function support
 
 (defvar *!early-generic-functions* ())
 

-(defun ensure-generic-function (function-name
+(defun ensure-generic-function (fun-name

                                &rest all-keys
                                &key environment
                                &allow-other-keys)
   (declare (ignore environment))
                                &rest all-keys
                                &key environment
                                &allow-other-keys)
   (declare (ignore environment))

-  (let ((existing (and (gboundp function-name)
-                      (gdefinition function-name))))
+  (let ((existing (and (gboundp fun-name)
+                      (gdefinition fun-name))))

     (if (and existing
             (eq *boot-state* 'complete)
             (null (generic-function-p existing)))
     (if (and existing
             (eq *boot-state* 'complete)
             (null (generic-function-p existing)))

-       (generic-clobbers-function function-name)
+       (generic-clobbers-function fun-name)

        (apply #'ensure-generic-function-using-class
        (apply #'ensure-generic-function-using-class

-              existing function-name all-keys))))
+              existing fun-name all-keys))))

 
 

-(defun generic-clobbers-function (function-name)
-  (error 'sb-kernel:simple-program-error
-        :format-control
-        "~S already names an ordinary function or a macro."
-        :format-arguments (list function-name)))
+(defun generic-clobbers-function (fun-name)
+  (error 'simple-program-error
+        :format-control "~S already names an ordinary function or a macro."
+        :format-arguments (list fun-name)))

 
 (defvar *sgf-wrapper*
   (boot-make-wrapper (early-class-size 'standard-generic-function)
                     'standard-generic-function))
 
 (defvar *sgf-slots-init*
 
 (defvar *sgf-wrapper*
   (boot-make-wrapper (early-class-size 'standard-generic-function)
                     'standard-generic-function))
 
 (defvar *sgf-slots-init*

-  (mapcar #'(lambda (canonical-slot)
-             (if (memq (getf canonical-slot :name) '(arg-info source))
-                 +slot-unbound+
-                 (let ((initfunction (getf canonical-slot :initfunction)))
-                   (if initfunction
-                       (funcall initfunction)
-                       +slot-unbound+))))
+  (mapcar (lambda (canonical-slot)
+           (if (memq (getf canonical-slot :name) '(arg-info source))
+               +slot-unbound+
+               (let ((initfunction (getf canonical-slot :initfunction)))
+                 (if initfunction
+                     (funcall initfunction)
+                     +slot-unbound+))))

          (early-collect-inheritance 'standard-generic-function)))
 
 (defvar *sgf-method-class-index*
          (early-collect-inheritance 'standard-generic-function)))
 
 (defvar *sgf-method-class-index*

@@ -1428,16 +1434,17 @@ bootstrapping.
   (!bootstrap-slot-index 'standard-generic-function 'dfun-state))
 
 (defstruct (arg-info
   (!bootstrap-slot-index 'standard-generic-function 'dfun-state))
 
 (defstruct (arg-info

-            (:conc-name nil)
-            (:constructor make-arg-info ()))
+           (:conc-name nil)
+           (:constructor make-arg-info ())
+           (:copier nil))

   (arg-info-lambda-list :no-lambda-list)
   arg-info-precedence
   arg-info-metatypes
   arg-info-number-optional
   arg-info-key/rest-p
   (arg-info-lambda-list :no-lambda-list)
   arg-info-precedence
   arg-info-metatypes
   arg-info-number-optional
   arg-info-key/rest-p

-  arg-info-keywords ;nil       no keyword or rest allowed
-                   ;(k1 k2 ..) each method must accept these keyword arguments
-                   ;T    must have &key or &rest
+  arg-info-keys   ;nil        no &KEY or &REST allowed
+                 ;(k1 k2 ..) Each method must accept these &KEY arguments.
+                 ;T          must have &KEY or &REST

 
   gf-info-simple-accessor-type ; nil, reader, writer, boundp
   (gf-precompute-dfun-and-emf-p nil) ; set by set-arg-info
 
   gf-info-simple-accessor-type ; nil, reader, writer, boundp
   (gf-precompute-dfun-and-emf-p nil) ; set by set-arg-info

@@ -1459,7 +1466,7 @@ bootstrapping.
   (length (arg-info-metatypes arg-info)))
 
 (defun arg-info-nkeys (arg-info)
   (length (arg-info-metatypes arg-info)))
 
 (defun arg-info-nkeys (arg-info)

-  (count-if #'(lambda (x) (neq x t)) (arg-info-metatypes arg-info)))
+  (count-if (lambda (x) (neq x t)) (arg-info-metatypes arg-info)))

 
 ;;; Keep pages clean by not setting if the value is already the same.
 (defmacro esetf (pos val)
 
 ;;; Keep pages clean by not setting if the value is already the same.
 (defmacro esetf (pos val)

@@ -1482,7 +1489,7 @@ bootstrapping.
       (setq lambda-list (gf-lambda-list gf)))
     (when (or lambda-list-p
              (and first-p
       (setq lambda-list (gf-lambda-list gf)))
     (when (or lambda-list-p
              (and first-p

-                  (eq (arg-info-lambda-list arg-info) ':no-lambda-list)))
+                  (eq (arg-info-lambda-list arg-info) :no-lambda-list)))

       (multiple-value-bind (nreq nopt keysp restp allow-other-keys-p keywords)
          (analyze-lambda-list lambda-list)
        (when (and methods (not first-p))
       (multiple-value-bind (nreq nopt keysp restp allow-other-keys-p keywords)
          (analyze-lambda-list lambda-list)
        (when (and methods (not first-p))

@@ -1505,7 +1512,7 @@ bootstrapping.
        (esetf (arg-info-metatypes arg-info) (make-list nreq))
        (esetf (arg-info-number-optional arg-info) nopt)
        (esetf (arg-info-key/rest-p arg-info) (not (null (or keysp restp))))
        (esetf (arg-info-metatypes arg-info) (make-list nreq))
        (esetf (arg-info-number-optional arg-info) nopt)
        (esetf (arg-info-key/rest-p arg-info) (not (null (or keysp restp))))

-       (esetf (arg-info-keywords arg-info)
+       (esetf (arg-info-keys arg-info)

               (if lambda-list-p
                   (if allow-other-keys-p t keywords)
                   (arg-info-key/rest-p arg-info)))))
               (if lambda-list-p
                   (if allow-other-keys-p t keywords)
                   (arg-info-key/rest-p arg-info)))))

@@ -1526,20 +1533,20 @@ bootstrapping.
              method
              gf
              (apply #'format nil string args)))
              method
              gf
              (apply #'format nil string args)))

-          (compare (x y)
+          (comparison-description (x y)

             (if (> x y) "more" "fewer")))
       (let ((gf-nreq (arg-info-number-required arg-info))
            (gf-nopt (arg-info-number-optional arg-info))
            (gf-key/rest-p (arg-info-key/rest-p arg-info))
             (if (> x y) "more" "fewer")))
       (let ((gf-nreq (arg-info-number-required arg-info))
            (gf-nopt (arg-info-number-optional arg-info))
            (gf-key/rest-p (arg-info-key/rest-p arg-info))

-           (gf-keywords (arg-info-keywords arg-info)))
+           (gf-keywords (arg-info-keys arg-info)))

        (unless (= nreq gf-nreq)
          (lose
           "the method has ~A required arguments than the generic function."
        (unless (= nreq gf-nreq)
          (lose
           "the method has ~A required arguments than the generic function."

-          (compare nreq gf-nreq)))
+          (comparison-description nreq gf-nreq)))

        (unless (= nopt gf-nopt)
          (lose
        (unless (= nopt gf-nopt)
          (lose

-          "the method has ~S optional arguments than the generic function."
-          (compare nopt gf-nopt)))
+          "the method has ~A optional arguments than the generic function."
+          (comparison-description nopt gf-nopt)))

        (unless (eq (or keysp restp) gf-key/rest-p)
          (error
           "The method and generic function differ in whether they accept~%~
        (unless (eq (or keysp restp) gf-key/rest-p)
          (error
           "The method and generic function differ in whether they accept~%~

@@ -1547,8 +1554,8 @@ bootstrapping.
        (when (consp gf-keywords)
          (unless (or (and restp (not keysp))
                      allow-other-keys-p
        (when (consp gf-keywords)
          (unless (or (and restp (not keysp))
                      allow-other-keys-p

-                     (every #'(lambda (k) (memq k keywords)) gf-keywords))
-           (lose "the method does not accept each of the keyword arguments~%~
+                     (every (lambda (k) (memq k keywords)) gf-keywords))
+           (lose "the method does not accept each of the &KEY arguments~%~

                   ~S."
                  gf-keywords)))))))
 
                   ~S."
                  gf-keywords)))))))
 

@@ -1632,7 +1639,8 @@ bootstrapping.
 ;;;    CAR    -   a list of the early methods on this early gf
 ;;;    CADR   -   the early discriminator code for this method
 (defun ensure-generic-function-using-class (existing spec &rest keys
 ;;;    CAR    -   a list of the early methods on this early gf
 ;;;    CADR   -   the early discriminator code for this method
 (defun ensure-generic-function-using-class (existing spec &rest keys

-                                           &key (lambda-list nil lambda-list-p)
+                                           &key (lambda-list nil
+                                                             lambda-list-p)

                                            &allow-other-keys)
   (declare (ignore keys))
   (cond ((and existing (early-gf-p existing))
                                            &allow-other-keys)
   (declare (ignore keys))
   (cond ((and existing (early-gf-p existing))

@@ -1651,7 +1659,7 @@ bootstrapping.
 
 (defun make-early-gf (spec &optional lambda-list lambda-list-p function)
   (let ((fin (allocate-funcallable-instance *sgf-wrapper* *sgf-slots-init*)))
 
 (defun make-early-gf (spec &optional lambda-list lambda-list-p function)
   (let ((fin (allocate-funcallable-instance *sgf-wrapper* *sgf-slots-init*)))

-    (set-funcallable-instance-function
+    (set-funcallable-instance-fun

      fin
      (or function
         (if (eq spec 'print-object)
      fin
      (or function
         (if (eq spec 'print-object)

@@ -1668,7 +1676,7 @@ bootstrapping.
                         fin
                         'source
                         *load-truename*)
                         fin
                         'source
                         *load-truename*)

-    (set-function-name fin spec)
+    (set-fun-name fin spec)

     (let ((arg-info (make-arg-info)))
       (setf (early-gf-arg-info fin) arg-info)
       (when lambda-list-p
     (let ((arg-info (make-arg-info)))
       (setf (early-gf-arg-info fin) arg-info)
       (when lambda-list-p

@@ -1714,7 +1722,7 @@ bootstrapping.
   (let ((arg-info (if (eq *boot-state* 'complete)
                      (gf-arg-info gf)
                      (early-gf-arg-info gf))))
   (let ((arg-info (if (eq *boot-state* 'complete)
                      (gf-arg-info gf)
                      (early-gf-arg-info gf))))

-    (if (eq ':no-lambda-list (arg-info-lambda-list arg-info))
+    (if (eq :no-lambda-list (arg-info-lambda-list arg-info))

        (let ((methods (if (eq *boot-state* 'complete)
                           (generic-function-methods gf)
                           (early-gf-methods gf))))
        (let ((methods (if (eq *boot-state* 'complete)
                           (generic-function-methods gf)
                           (early-gf-methods gf))))

@@ -1748,11 +1756,15 @@ bootstrapping.
         (setf (getf ,all-keys :method-combination)
               (find-method-combination (class-prototype ,gf-class)
                                        (car combin)
         (setf (getf ,all-keys :method-combination)
               (find-method-combination (class-prototype ,gf-class)
                                        (car combin)

-                                       (cdr combin)))))))
+                                       (cdr combin)))))
+    (let ((method-class (getf ,all-keys :method-class '.shes-not-there.)))
+      (unless (eq method-class '.shes-not-there.)
+        (setf (getf ,all-keys :method-class)
+                (find-class method-class t ,env))))))

 
 (defun real-ensure-gf-using-class--generic-function
        (existing
 
 (defun real-ensure-gf-using-class--generic-function
        (existing

-       function-name
+       fun-name

        &rest all-keys
        &key environment (lambda-list nil lambda-list-p)
             (generic-function-class 'standard-generic-function gf-class-p)
        &rest all-keys
        &key environment (lambda-list nil lambda-list-p)
             (generic-function-class 'standard-generic-function gf-class-p)

@@ -1764,11 +1776,11 @@ bootstrapping.
   (prog1
       (apply #'reinitialize-instance existing all-keys)
     (when lambda-list-p
   (prog1
       (apply #'reinitialize-instance existing all-keys)
     (when lambda-list-p

-      (proclaim (defgeneric-declaration function-name lambda-list)))))
+      (proclaim (defgeneric-declaration fun-name lambda-list)))))

 
 (defun real-ensure-gf-using-class--null
        (existing
 
 (defun real-ensure-gf-using-class--null
        (existing

-       function-name
+       fun-name

        &rest all-keys
        &key environment (lambda-list nil lambda-list-p)
             (generic-function-class 'standard-generic-function)
        &rest all-keys
        &key environment (lambda-list nil lambda-list-p)
             (generic-function-class 'standard-generic-function)

@@ -1776,13 +1788,13 @@ bootstrapping.
   (declare (ignore existing))
   (real-ensure-gf-internal generic-function-class all-keys environment)
   (prog1
   (declare (ignore existing))
   (real-ensure-gf-internal generic-function-class all-keys environment)
   (prog1

-      (setf (gdefinition function-name)
+      (setf (gdefinition fun-name)

            (apply #'make-instance generic-function-class
            (apply #'make-instance generic-function-class

-                  :name function-name all-keys))
+                  :name fun-name all-keys))

     (when lambda-list-p
     (when lambda-list-p

-      (proclaim (defgeneric-declaration function-name lambda-list)))))
+      (proclaim (defgeneric-declaration fun-name lambda-list)))))

 \f
 \f

-(defun get-generic-function-info (gf)
+(defun get-generic-fun-info (gf)

   ;; values   nreq applyp metatypes nkeys arg-info
   (multiple-value-bind (applyp metatypes arg-info)
       (let* ((arg-info (if (early-gf-p gf)
   ;; values   nreq applyp metatypes nkeys arg-info
   (multiple-value-bind (applyp metatypes arg-info)
       (let* ((arg-info (if (early-gf-p gf)

@@ -1793,7 +1805,7 @@ bootstrapping.
                metatypes
                arg-info))
     (values (length metatypes) applyp metatypes
                metatypes
                arg-info))
     (values (length metatypes) applyp metatypes

-           (count-if #'(lambda (x) (neq x t)) metatypes)
+           (count-if (lambda (x) (neq x t)) metatypes)

            arg-info)))
 
 (defun early-make-a-method (class qualifiers arglist specializers initargs doc
            arg-info)))
 
 (defun early-make-a-method (class qualifiers arglist specializers initargs doc

@@ -1809,17 +1821,17 @@ bootstrapping.
     ;; Note that the use of not symbolp in this call to every should be
     ;; read as 'classp' we can't use classp itself because it doesn't
     ;; exist yet.
     ;; Note that the use of not symbolp in this call to every should be
     ;; read as 'classp' we can't use classp itself because it doesn't
     ;; exist yet.

-    (if (every #'(lambda (s) (not (symbolp s))) specializers)
+    (if (every (lambda (s) (not (symbolp s))) specializers)

        (setq parsed specializers
        (setq parsed specializers

-             unparsed (mapcar #'(lambda (s)
-                                  (if (eq s t) t (class-name s)))
+             unparsed (mapcar (lambda (s)
+                                (if (eq s t) t (class-name s)))

                               specializers))
        (setq unparsed specializers
              parsed ()))
     (list :early-method                  ;This is an early method dammit!
 
                               specializers))
        (setq unparsed specializers
              parsed ()))
     (list :early-method                  ;This is an early method dammit!
 

-         (getf initargs ':function)
-         (getf initargs ':fast-function)
+         (getf initargs :function)
+         (getf initargs :fast-function)

 
          parsed                  ;The parsed specializers. This is used
                                  ;by early-method-specializers to cache
 
          parsed                  ;The parsed specializers. This is used
                                  ;by early-method-specializers to cache

@@ -1962,12 +1974,10 @@ bootstrapping.
       (real-get-method generic-function qualifiers specializers errorp)))
 
 (defun !fix-early-generic-functions ()
       (real-get-method generic-function qualifiers specializers errorp)))
 
 (defun !fix-early-generic-functions ()

-  (sb-int:/show "entering !FIX-EARLY-GENERIC-FUNCTIONS")

   (let ((accessors nil))
     ;; Rearrange *!EARLY-GENERIC-FUNCTIONS* to speed up
     ;; FIX-EARLY-GENERIC-FUNCTIONS.
     (dolist (early-gf-spec *!early-generic-functions*)
   (let ((accessors nil))
     ;; Rearrange *!EARLY-GENERIC-FUNCTIONS* to speed up
     ;; FIX-EARLY-GENERIC-FUNCTIONS.
     (dolist (early-gf-spec *!early-generic-functions*)

-      (sb-int:/show early-gf-spec)

       (when (every #'early-method-standard-accessor-p
                   (early-gf-methods (gdefinition early-gf-spec)))
        (push early-gf-spec accessors)))
       (when (every #'early-method-standard-accessor-p
                   (early-gf-methods (gdefinition early-gf-spec)))
        (push early-gf-spec accessors)))

@@ -1990,21 +2000,21 @@ bootstrapping.
                           standard-class-p
                           funcallable-standard-class-p
                           specializerp)))
                           standard-class-p
                           funcallable-standard-class-p
                           specializerp)))

-      (sb-int:/show spec)
+      (/show spec)

       (setq *!early-generic-functions*
            (cons spec
                  (delete spec *!early-generic-functions* :test #'equal))))
 
     (dolist (early-gf-spec *!early-generic-functions*)
       (setq *!early-generic-functions*
            (cons spec
                  (delete spec *!early-generic-functions* :test #'equal))))
 
     (dolist (early-gf-spec *!early-generic-functions*)

-      (sb-int:/show early-gf-spec)
+      (/show early-gf-spec)

       (let* ((gf (gdefinition early-gf-spec))
       (let* ((gf (gdefinition early-gf-spec))

-            (methods (mapcar #'(lambda (early-method)
-                                 (let ((args (copy-list (fifth
-                                                         early-method))))
-                                   (setf (fourth args)
-                                         (early-method-specializers
-                                          early-method t))
-                                   (apply #'real-make-a-method args)))
+            (methods (mapcar (lambda (early-method)
+                               (let ((args (copy-list (fifth
+                                                       early-method))))
+                                 (setf (fourth args)
+                                       (early-method-specializers
+                                        early-method t))
+                                 (apply #'real-make-a-method args)))

                              (early-gf-methods gf))))
        (setf (generic-function-method-class gf) *the-class-standard-method*)
        (setf (generic-function-method-combination gf)
                              (early-gf-methods gf))))
        (setf (generic-function-method-class gf) *the-class-standard-method*)
        (setf (generic-function-method-combination gf)

@@ -2012,46 +2022,46 @@ bootstrapping.
        (set-methods gf methods)))
 
     (dolist (fn *!early-functions*)
        (set-methods gf methods)))
 
     (dolist (fn *!early-functions*)

-      (sb-int:/show fn)
+      (/show fn)

       (setf (gdefinition (car fn)) (fdefinition (caddr fn))))
 
     (dolist (fixup *!generic-function-fixups*)
       (setf (gdefinition (car fn)) (fdefinition (caddr fn))))
 
     (dolist (fixup *!generic-function-fixups*)

-      (sb-int:/show fixup)
+      (/show fixup)

       (let* ((fspec (car fixup))
             (gf (gdefinition fspec))
       (let* ((fspec (car fixup))
             (gf (gdefinition fspec))

-            (methods (mapcar #'(lambda (method)
-                                 (let* ((lambda-list (first method))
-                                        (specializers (second method))
-                                        (method-fn-name (third method))
-                                        (fn-name (or method-fn-name fspec))
-                                        (fn (fdefinition fn-name))
-                                        (initargs
-                                         (list :function
-                                               (set-function-name
-                                                #'(lambda (args next-methods)
-                                                    (declare (ignore
-                                                              next-methods))
-                                                    (apply fn args))
-                                                `(call ,fn-name)))))
-                                   (declare (type function fn))
-                                   (make-a-method 'standard-method
-                                                  ()
-                                                  lambda-list
-                                                  specializers
-                                                  initargs
-                                                  nil)))
+            (methods (mapcar (lambda (method)
+                               (let* ((lambda-list (first method))
+                                      (specializers (second method))
+                                      (method-fn-name (third method))
+                                      (fn-name (or method-fn-name fspec))
+                                      (fn (fdefinition fn-name))
+                                      (initargs
+                                       (list :function
+                                             (set-fun-name
+                                              (lambda (args next-methods)
+                                                (declare (ignore
+                                                          next-methods))
+                                                (apply fn args))
+                                              `(call ,fn-name)))))
+                                 (declare (type function fn))
+                                 (make-a-method 'standard-method
+                                                ()
+                                                lambda-list
+                                                specializers
+                                                initargs
+                                                nil)))

                              (cdr fixup))))
        (setf (generic-function-method-class gf) *the-class-standard-method*)
        (setf (generic-function-method-combination gf)
              *standard-method-combination*)
        (set-methods gf methods))))
                              (cdr fixup))))
        (setf (generic-function-method-class gf) *the-class-standard-method*)
        (setf (generic-function-method-combination gf)
              *standard-method-combination*)
        (set-methods gf methods))))

-  (sb-int:/show "leaving !FIX-EARLY-GENERIC-FUNCTIONS"))
+  (/show "leaving !FIX-EARLY-GENERIC-FUNCTIONS"))

 \f
 ;;; PARSE-DEFMETHOD is used by DEFMETHOD to parse the &REST argument
 ;;; into the 'real' arguments. This is where the syntax of DEFMETHOD
 ;;; is really implemented.
 (defun parse-defmethod (cdr-of-form)
 \f
 ;;; PARSE-DEFMETHOD is used by DEFMETHOD to parse the &REST argument
 ;;; into the 'real' arguments. This is where the syntax of DEFMETHOD
 ;;; is really implemented.
 (defun parse-defmethod (cdr-of-form)

-  ;;(declare (values name qualifiers specialized-lambda-list body))
+  (declare (list cdr-of-form))

   (let ((name (pop cdr-of-form))
        (qualifiers ())
        (spec-ll ()))
   (let ((name (pop cdr-of-form))
        (qualifiers ())
        (spec-ll ()))

@@ -2062,6 +2072,7 @@ bootstrapping.
     (values name qualifiers spec-ll cdr-of-form)))
 
 (defun parse-specializers (specializers)
     (values name qualifiers spec-ll cdr-of-form)))
 
 (defun parse-specializers (specializers)

+  (declare (list specializers))

   (flet ((parse (spec)
           (let ((result (specializer-from-type spec)))
             (if (specializerp result)
   (flet ((parse (spec)
           (let ((result (specializer-from-type spec)))
             (if (specializerp result)

@@ -2097,7 +2108,7 @@ bootstrapping.
              gf (method-generic-function method)
              temp (and gf (generic-function-name gf))
              name (if temp
              gf (method-generic-function method)
              temp (and gf (generic-function-name gf))
              name (if temp

-                      (intern-function-name
+                      (intern-fun-name

                         (make-method-spec temp
                                           (method-qualifiers method)
                                           (unparse-specializers
                         (make-method-spec temp
                                           (method-qualifiers method)
                                           (unparse-specializers

@@ -2115,9 +2126,9 @@ bootstrapping.
                 (and
                   (setq method (get-method gf quals specls errorp))
                   (setq name
                 (and
                   (setq method (get-method gf quals specls errorp))
                   (setq name

-                        (intern-function-name (make-method-spec gf-spec
-                                                                quals
-                                                                specls))))))))
+                        (intern-fun-name (make-method-spec gf-spec
+                                                           quals
+                                                           specls))))))))

     (values gf method name)))
 \f
 (defun extract-parameters (specialized-lambda-list)
     (values gf method name)))
 \f
 (defun extract-parameters (specialized-lambda-list)

@@ -2152,17 +2163,12 @@ bootstrapping.
           (values nil arglist nil))
          ((memq arg lambda-list-keywords)
           (unless (memq arg '(&optional &rest &key &allow-other-keys &aux))
           (values nil arglist nil))
          ((memq arg lambda-list-keywords)
           (unless (memq arg '(&optional &rest &key &allow-other-keys &aux))

-            ;; Warn about non-standard lambda-list-keywords, but then
-            ;; go on to treat them like a standard lambda-list-keyword
-            ;; what with the warning its probably ok.
-            ;;
-            ;; FIXME: This shouldn't happen now that this is maintained
-            ;; as part of SBCL, should it? Perhaps this is now
-            ;; "internal error: unrecognized lambda-list keyword ~S"?
-            (warn "Unrecognized lambda-list keyword ~S in arglist.~%~
-                   Assuming that the symbols following it are parameters,~%~
-                   and not allowing any parameter specializers to follow it."
-                  arg))
+            ;; Now, since we try to conform to ANSI, non-standard
+             ;; lambda-list-keywords should be treated as errors.
+            (error 'simple-program-error
+                    :format-control "unrecognized lambda-list keyword ~S ~
+                     in arglist.~%"
+                   :format-arguments (list arg)))

           ;; When we are at a lambda-list keyword, the parameters
           ;; don't include the lambda-list keyword; the lambda-list
           ;; does include the lambda-list keyword; and no
           ;; When we are at a lambda-list keyword, the parameters
           ;; don't include the lambda-list keyword; the lambda-list
           ;; does include the lambda-list keyword; and no

@@ -2170,6 +2176,13 @@ bootstrapping.
           ;; keywords (at least for now).
           (multiple-value-bind (parameters lambda-list)
               (parse-specialized-lambda-list (cdr arglist) t)
           ;; keywords (at least for now).
           (multiple-value-bind (parameters lambda-list)
               (parse-specialized-lambda-list (cdr arglist) t)

+            (when (eq arg '&rest)
+              ;; check, if &rest is followed by a var ...
+              (when (or (null lambda-list)
+                        (memq (car lambda-list) lambda-list-keywords))
+                (error "Error in lambda-list:~%~
+                         After &REST, a DEFMETHOD lambda-list ~
+                         must be followed by at least one variable.")))

             (values parameters
                     (cons arg lambda-list)
                     ()
             (values parameters
                     (cons arg lambda-list)
                     ()

@@ -2190,8 +2203,7 @@ bootstrapping.
                     (cons (if (listp arg) (cadr arg) t) specializers)
                     (cons (if (listp arg) (car arg) arg) required)))))))
 \f
                     (cons (if (listp arg) (cadr arg) t) specializers)
                     (cons (if (listp arg) (car arg) arg) required)))))))
 \f

-(eval-when (:load-toplevel :execute)
-  (setq *boot-state* 'early))
+(setq *boot-state* 'early)

 \f
 ;;; FIXME: In here there was a #-CMU definition of SYMBOL-MACROLET
 ;;; which used %WALKER stuff. That suggests to me that maybe the code
 \f
 ;;; FIXME: In here there was a #-CMU definition of SYMBOL-MACROLET
 ;;; which used %WALKER stuff. That suggests to me that maybe the code

@@ -2208,17 +2220,17 @@ bootstrapping.
           (and (symbolp instance)
                `((declare (%variable-rebinding ,in ,instance)))))
        ,in
           (and (symbolp instance)
                `((declare (%variable-rebinding ,in ,instance)))))
        ,in

-       (symbol-macrolet ,(mapcar #'(lambda (slot-entry)
-                                    (let ((variable-name
-                                           (if (symbolp slot-entry)
-                                               slot-entry
-                                               (car slot-entry)))
-                                          (slot-name
-                                           (if (symbolp slot-entry)
-                                               slot-entry
-                                               (cadr slot-entry))))
-                                      `(,variable-name
-                                         (slot-value ,in ',slot-name))))
+       (symbol-macrolet ,(mapcar (lambda (slot-entry)
+                                  (let ((var-name
+                                         (if (symbolp slot-entry)
+                                             slot-entry
+                                             (car slot-entry)))
+                                        (slot-name
+                                         (if (symbolp slot-entry)
+                                             slot-entry
+                                             (cadr slot-entry))))
+                                    `(,var-name
+                                      (slot-value ,in ',slot-name))))

                                 slots)
                        ,@body))))
 
                                 slots)
                        ,@body))))
 

@@ -2232,10 +2244,9 @@ bootstrapping.
           (and (symbolp instance)
                `((declare (%variable-rebinding ,in ,instance)))))
        ,in
           (and (symbolp instance)
                `((declare (%variable-rebinding ,in ,instance)))))
        ,in

-       (symbol-macrolet ,(mapcar #'(lambda (slot-entry)
-                                  (let ((variable-name (car slot-entry))
+       (symbol-macrolet ,(mapcar (lambda (slot-entry)
+                                  (let ((var-name (car slot-entry))

                                         (accessor-name (cadr slot-entry)))
                                         (accessor-name (cadr slot-entry)))

-                                    `(,variable-name
-                                       (,accessor-name ,in))))
-                              slots)
+                                    `(,var-name (,accessor-name ,in))))
+                                slots)

          ,@body))))
          ,@body))))