src/pcl/defs.lisp

   1 ;;;; This software is part of the SBCL system. See the README file for
   2 ;;;; more information.
   3
   4 ;;;; This software is derived from software originally released by Xerox
   5 ;;;; Corporation. Copyright and release statements follow. Later modifications
   6 ;;;; to the software are in the public domain and are provided with
   7 ;;;; absolutely no warranty. See the COPYING and CREDITS files for more
   8 ;;;; information.
   9
  10 ;;;; copyright information from original PCL sources:
  11 ;;;;
  12 ;;;; Copyright (c) 1985, 1986, 1987, 1988, 1989, 1990 Xerox Corporation.
  13 ;;;; All rights reserved.
  14 ;;;;
  15 ;;;; Use and copying of this software and preparation of derivative works based
  16 ;;;; upon this software are permitted. Any distribution of this software or
  17 ;;;; derivative works must comply with all applicable United States export
  18 ;;;; control laws.
  19 ;;;;
  20 ;;;; This software is made available AS IS, and Xerox Corporation makes no
  21 ;;;; warranty about the software, its performance or its conformity to any
  22 ;;;; specification.
  23
  24 (in-package "SB-PCL")
  25 \f
  26 ;;; (These are left over from the days when PCL was an add-on package
  27 ;;; for a pre-CLOS Common Lisp. They shouldn't happen in a normal
  28 ;;; build, of course, but they might happen if someone is experimenting
  29 ;;; and debugging, and it's probably worth complaining if they do,
  30 ;;; so we've left 'em in.)
  31 (when (eq **boot-state** 'complete)
  32   (error "Trying to load (or compile) PCL in an environment in which it~%~
  33           has already been loaded. This doesn't work, you will have to~%~
  34           get a fresh lisp (reboot) and then load PCL."))
  35 (when **boot-state**
  36   (cerror "Try loading (or compiling) PCL anyways."
  37           "Trying to load (or compile) PCL in an environment in which it~%~
  38            has already been partially loaded. This may not work, you may~%~
  39            need to get a fresh lisp (reboot) and then load PCL."))
  40 \f
  41 #-sb-fluid (declaim (inline gdefinition))
  42 (defun gdefinition (spec)
  43   ;; This is null layer right now, but once FDEFINITION stops bypasssing
  44   ;; fwrappers/encapsulations we can do that here.
  45   (fdefinition spec))
  46
  47 (defun (setf gdefinition) (new-value spec)
  48   ;; This is almost a null layer right now, but once (SETF
  49   ;; FDEFINITION) stops bypasssing fwrappers/encapsulations we can do
  50   ;; that here.
  51   (sb-c::note-name-defined spec :function) ; FIXME: do we need this? Why?
  52   (setf (fdefinition spec) new-value))
  53 \f
  54 ;;;; type specifier hackery
  55
  56 ;;; internal to this file
  57 (defun coerce-to-class (class &optional make-forward-referenced-class-p)
  58   (if (symbolp class)
  59       (or (find-class class (not make-forward-referenced-class-p))
  60           (ensure-class class))
  61       class))
  62
  63 ;;; interface
  64 (defun specializer-from-type (type &aux args)
  65   (when (symbolp type)
  66     (return-from specializer-from-type (find-class type)))
  67   (when (consp type)
  68     (setq args (cdr type) type (car type)))
  69   (cond ((symbolp type)
  70          (or (ecase type
  71                (class    (coerce-to-class (car args)))
  72                (prototype (make-instance 'class-prototype-specializer
  73                                          :object (coerce-to-class (car args))))
  74                (class-eq (class-eq-specializer (coerce-to-class (car args))))
  75                (eql      (intern-eql-specializer (car args))))))
  76         ;; FIXME: do we still need this?
  77         ((and (null args) (typep type 'classoid))
  78          (or (classoid-pcl-class type)
  79              (ensure-non-standard-class (classoid-name type) type)))
  80         ((specializerp type) type)))
  81
  82 ;;; interface
  83 (defun type-from-specializer (specl)
  84   (cond ((eq specl t)
  85          t)
  86         ((consp specl)
  87          (unless (member (car specl) '(class prototype class-eq eql))
  88            (error "~S is not a legal specializer type." specl))
  89          specl)
  90         ((progn
  91            (when (symbolp specl)
  92              ;;maybe (or (find-class specl nil) (ensure-class specl)) instead?
  93              (setq specl (find-class specl)))
  94            (or (not (eq **boot-state** 'complete))
  95                (specializerp specl)))
  96          (specializer-type specl))
  97         (t
  98          (error "~S is neither a type nor a specializer." specl))))
  99
 100 (defun type-class (type)
 101   (declare (special *the-class-t*))
 102   (setq type (type-from-specializer type))
 103   (if (atom type)
 104       (if (eq type t)
 105           *the-class-t*
 106           (error "bad argument to TYPE-CLASS"))
 107       (case (car type)
 108         (eql (class-of (cadr type)))
 109         (prototype (class-of (cadr type))) ;?
 110         (class-eq (cadr type))
 111         (class (cadr type)))))
 112
 113 (defun class-eq-type (class)
 114   (specializer-type (class-eq-specializer class)))
 115
 116 ;;; internal to this file..
 117 ;;;
 118 ;;; These functions are a pale imitation of their namesake. They accept
 119 ;;; class objects or types where they should.
 120 (defun *normalize-type (type)
 121   (cond ((consp type)
 122          (if (member (car type) '(not and or))
 123              `(,(car type) ,@(mapcar #'*normalize-type (cdr type)))
 124              (if (null (cdr type))
 125                  (*normalize-type (car type))
 126                  type)))
 127         ((symbolp type)
 128          (let ((class (find-class type nil)))
 129            (if class
 130                (let ((type (specializer-type class)))
 131                  (if (listp type) type `(,type)))
 132                `(,type))))
 133         ((or (not (eq **boot-state** 'complete))
 134              (specializerp type))
 135          (specializer-type type))
 136         (t
 137          (error "~S is not a type." type))))
 138
 139 ;;; internal to this file...
 140 (defun convert-to-system-type (type)
 141   (case (car type)
 142     ((not and or) `(,(car type) ,@(mapcar #'convert-to-system-type
 143                                           (cdr type))))
 144     ((class class-eq) ; class-eq is impossible to do right
 145      (layout-classoid (class-wrapper (cadr type))))
 146     (eql type)
 147     (t (if (null (cdr type))
 148            (car type)
 149            type))))
 150
 151 ;;; Writing the missing NOT and AND clauses will improve the quality
 152 ;;; of code generated by GENERATE-DISCRIMINATION-NET, but calling
 153 ;;; SUBTYPEP in place of just returning (VALUES NIL NIL) can be very
 154 ;;; slow. *SUBTYPEP is used by PCL itself, and must be fast.
 155 ;;;
 156 ;;; FIXME: SB-KERNEL has fast-and-not-quite-precise type code for use
 157 ;;; in the compiler. Could we share some of it here?
 158 (defvar *in-*subtypep* nil)
 159
 160 (defun *subtypep (type1 type2)
 161   (if (equal type1 type2)
 162       (values t t)
 163       (if (eq **boot-state** 'early)
 164           (values (eq type1 type2) t)
 165           (let ((*in-*subtypep* t))
 166             (setq type1 (*normalize-type type1))
 167             (setq type2 (*normalize-type type2))
 168             (case (car type2)
 169               (not
 170                (values nil nil)) ; XXX We should improve this.
 171               (and
 172                (values nil nil)) ; XXX We should improve this.
 173               ((eql wrapper-eq class-eq class)
 174                (multiple-value-bind (app-p maybe-app-p)
 175                    (specializer-applicable-using-type-p type2 type1)
 176                  (values app-p (or app-p (not maybe-app-p)))))
 177               (t
 178                (subtypep (convert-to-system-type type1)
 179                          (convert-to-system-type type2))))))))
 180 \f
 181 (defvar *built-in-class-symbols* ())
 182 (defvar *built-in-wrapper-symbols* ())
 183
 184 (defun get-built-in-class-symbol (class-name)
 185   (or (cadr (assq class-name *built-in-class-symbols*))
 186       (let ((symbol (make-class-symbol class-name)))
 187         (push (list class-name symbol) *built-in-class-symbols*)
 188         symbol)))
 189
 190 (defun get-built-in-wrapper-symbol (class-name)
 191   (or (cadr (assq class-name *built-in-wrapper-symbols*))
 192       (let ((symbol (make-wrapper-symbol class-name)))
 193         (push (list class-name symbol) *built-in-wrapper-symbols*)
 194         symbol)))
 195 \f
 196 (defvar *standard-method-combination*)
 197 \f
 198 (defun plist-value (object name)
 199   (getf (object-plist object) name))
 200
 201 (defun (setf plist-value) (new-value object name)
 202   (if new-value
 203       (setf (getf (object-plist object) name) new-value)
 204       (progn
 205         (remf (object-plist object) name)
 206         nil)))
 207 \f
 208 ;;;; built-in classes
 209
 210 ;;; Grovel over SB-KERNEL::*BUILT-IN-CLASSES* in order to set
 211 ;;; SB-PCL:*BUILT-IN-CLASSES*.
 212 (/show "about to set up SB-PCL::*BUILT-IN-CLASSES*")
 213 (defvar *built-in-classes*
 214   (labels ((direct-supers (class)
 215              (/noshow "entering DIRECT-SUPERS" (classoid-name class))
 216              (if (typep class 'built-in-classoid)
 217                  (built-in-classoid-direct-superclasses class)
 218                  (let ((inherits (layout-inherits
 219                                   (classoid-layout class))))
 220                    (/noshow inherits)
 221                    (list (svref inherits (1- (length inherits)))))))
 222            (direct-subs (class)
 223              (/noshow "entering DIRECT-SUBS" (classoid-name class))
 224              (collect ((res))
 225                (let ((subs (classoid-subclasses class)))
 226                  (/noshow subs)
 227                  (when subs
 228                    (dohash ((sub v) subs)
 229                      (declare (ignore v))
 230                      (/noshow sub)
 231                      (when (member class (direct-supers sub) :test #'eq)
 232                        (res sub)))))
 233                (res))))
 234     (mapcar (lambda (kernel-bic-entry)
 235               (/noshow "setting up" kernel-bic-entry)
 236               (let* ((name (car kernel-bic-entry))
 237                      (class (find-classoid name))
 238                      (prototype-form
 239                       (getf (cdr kernel-bic-entry) :prototype-form)))
 240                 (/noshow name class)
 241                 `(,name
 242                   ,(mapcar #'classoid-name (direct-supers class))
 243                   ,(mapcar #'classoid-name (direct-subs class))
 244                   ,(map 'list
 245                         (lambda (x)
 246                           (classoid-name
 247                            (layout-classoid x)))
 248                         (reverse
 249                          (layout-inherits
 250                           (classoid-layout class))))
 251                   ,(if prototype-form
 252                        (eval prototype-form)
 253                        ;; This is the default prototype value which
 254                        ;; was used, without explanation, by the CMU CL
 255                        ;; code we're derived from. Evidently it's safe
 256                        ;; in all relevant cases.
 257                        42))))
 258             (remove-if (lambda (kernel-bic-entry)
 259                          (member (first kernel-bic-entry)
 260                                  ;; I'm not sure why these are removed from
 261                                  ;; the list, but that's what the original
 262                                  ;; CMU CL code did. -- WHN 20000715
 263                                  '(t function stream
 264                                      file-stream string-stream)))
 265                        sb-kernel::*built-in-classes*))))
 266 (/noshow "done setting up SB-PCL::*BUILT-IN-CLASSES*")
 267 \f
 268 ;;;; the classes that define the kernel of the metabraid
 269
 270 (defclass t () ()
 271   (:metaclass built-in-class))
 272
 273 (defclass function (t) ()
 274   (:metaclass built-in-class))
 275
 276 (defclass stream (t) ()
 277   (:metaclass built-in-class))
 278
 279 (defclass file-stream (stream) ()
 280   (:metaclass built-in-class))
 281
 282 (defclass string-stream (stream) ()
 283   (:metaclass built-in-class))
 284
 285 (defclass slot-object (t) ()
 286   (:metaclass slot-class))
 287
 288 (defclass condition (slot-object) ()
 289   (:metaclass condition-class))
 290
 291 (defclass structure-object (slot-object) ()
 292   (:metaclass structure-class))
 293
 294 (defstruct (dead-beef-structure-object
 295             (:constructor |STRUCTURE-OBJECT class constructor|)
 296             (:copier nil)))
 297
 298 (defclass standard-object (slot-object) ())
 299
 300 (defclass funcallable-standard-object (function standard-object)
 301   ()
 302   (:metaclass funcallable-standard-class))
 303
 304 (defclass metaobject (standard-object) ())
 305
 306 (defclass generic-function (dependent-update-mixin
 307                             definition-source-mixin
 308                             metaobject
 309                             funcallable-standard-object)
 310   ((%documentation :initform nil :initarg :documentation)
 311    ;; We need to make a distinction between the methods initially set
 312    ;; up by :METHOD options to DEFGENERIC and the ones set up later by
 313    ;; DEFMETHOD, because ANSI specifies that executing DEFGENERIC on
 314    ;; an already-DEFGENERICed function clears the methods set by the
 315    ;; previous DEFGENERIC, but not methods set by DEFMETHOD. (Making
 316    ;; this distinction seems a little kludgy, but it has the positive
 317    ;; effect of making it so that loading a file a.lisp containing
 318    ;; DEFGENERIC, then loading a second file b.lisp containing
 319    ;; DEFMETHOD, then modifying and reloading a.lisp and/or b.lisp
 320    ;; tends to leave the generic function in a state consistent with
 321    ;; the most-recently-loaded state of a.lisp and b.lisp.)
 322    (initial-methods :initform () :accessor generic-function-initial-methods)
 323    (encapsulations :initform () :accessor generic-function-encapsulations))
 324   (:metaclass funcallable-standard-class))
 325
 326 (defclass standard-generic-function (generic-function)
 327   ((name
 328     :initform nil
 329     :initarg :name
 330     :reader generic-function-name)
 331    (methods
 332     :initform ()
 333     :accessor generic-function-methods
 334     :type list)
 335    (method-class
 336     :initarg :method-class
 337     :accessor generic-function-method-class)
 338    (%method-combination
 339     :initarg :method-combination
 340     :accessor generic-function-method-combination)
 341    (declarations
 342     ;; KLUDGE: AMOP specifies :DECLARATIONS, while ANSI specifies
 343     ;; :DECLARE.  Allow either (but FIXME: maybe a note or a warning
 344     ;; might be appropriate).
 345     :initarg :declarations
 346     :initarg :declare
 347     :initform ()
 348     :accessor generic-function-declarations)
 349    (arg-info
 350     :initform (make-arg-info)
 351     :reader gf-arg-info)
 352    (dfun-state
 353     :initform ()
 354     :accessor gf-dfun-state)
 355    ;; Used to make DFUN-STATE & FIN-FUNCTION updates atomic.
 356    (%lock
 357     :initform (sb-thread:make-mutex :name "GF lock")
 358     :reader gf-lock)
 359    ;; Set to true by ADD-METHOD, REMOVE-METHOD; to false by
 360    ;; MAYBE-UPDATE-INFO-FOR-GF.
 361    (info-needs-update
 362     :initform nil
 363     :accessor gf-info-needs-update))
 364   (:metaclass funcallable-standard-class)
 365   (:default-initargs :method-class *the-class-standard-method*
 366                      :method-combination *standard-method-combination*))
 367
 368 (defclass method (metaobject) ())
 369
 370 (defclass standard-method (plist-mixin definition-source-mixin method)
 371   ((%generic-function :initform nil :accessor method-generic-function)
 372    (qualifiers :initform () :initarg :qualifiers :reader method-qualifiers)
 373    (specializers :initform () :initarg :specializers
 374                  :reader method-specializers)
 375    (lambda-list :initform () :initarg :lambda-list :reader method-lambda-list)
 376    (%function :initform nil :initarg :function :reader method-function)
 377    (%documentation :initform nil :initarg :documentation)
 378    ;; True IFF method is known to have no CALL-NEXT-METHOD in it, or
 379    ;; just a plain (CALL-NEXT-METHOD).
 380    (simple-next-method-call
 381     :initform nil
 382     :initarg simple-next-method-call
 383     :reader simple-next-method-call-p)))
 384
 385 (defclass accessor-method (standard-method)
 386   ((slot-name :initform nil :initarg :slot-name
 387               :reader accessor-method-slot-name)))
 388
 389 (defclass standard-accessor-method (accessor-method)
 390   ((%slot-definition :initform nil :initarg :slot-definition
 391                      :reader accessor-method-slot-definition)))
 392
 393 (defclass standard-reader-method (standard-accessor-method) ())
 394 (defclass standard-writer-method (standard-accessor-method) ())
 395 ;;; an extension, apparently.
 396 (defclass standard-boundp-method (standard-accessor-method) ())
 397
 398 ;;; for (SLOT-VALUE X 'FOO) / ACCESSOR-SLOT-VALUE optimization, which
 399 ;;; can't be STANDARD-READER-METHOD because there is no associated
 400 ;;; slot definition.
 401 (defclass global-reader-method (accessor-method) ())
 402 (defclass global-writer-method (accessor-method) ())
 403 (defclass global-boundp-method (accessor-method) ())
 404
 405 (defclass method-combination (metaobject)
 406   ((%documentation :initform nil :initarg :documentation)))
 407
 408 (defclass standard-method-combination (definition-source-mixin
 409                                        method-combination)
 410   ((type-name
 411     :reader method-combination-type-name
 412     :initarg :type-name)
 413    (options
 414     :reader method-combination-options
 415     :initarg :options)))
 416
 417 (defclass long-method-combination (standard-method-combination)
 418   ((function
 419     :initarg :function
 420     :reader long-method-combination-function)
 421    (args-lambda-list
 422     :initarg :args-lambda-list
 423     :reader long-method-combination-args-lambda-list)))
 424
 425 (defclass short-method-combination (standard-method-combination)
 426   ((operator
 427     :reader short-combination-operator
 428     :initarg :operator)
 429    (identity-with-one-argument
 430     :reader short-combination-identity-with-one-argument
 431     :initarg :identity-with-one-argument)))
 432
 433 (defclass slot-definition (metaobject)
 434   ((name
 435     :initform nil
 436     :initarg :name
 437     :accessor slot-definition-name)
 438    (initform
 439     :initform nil
 440     :initarg :initform
 441     :accessor slot-definition-initform)
 442    (initfunction
 443     :initform nil
 444     :initarg :initfunction
 445     :accessor slot-definition-initfunction)
 446    (initargs
 447     :initform nil
 448     :initarg :initargs
 449     :accessor slot-definition-initargs)
 450    (%type :initform t :initarg :type :accessor slot-definition-type)
 451    (%documentation
 452     :initform nil :initarg :documentation
 453     ;; KLUDGE: we need a reader for bootstrapping purposes, in
 454     ;; COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS.
 455     :reader %slot-definition-documentation)
 456    (%class :initform nil :initarg :class :accessor slot-definition-class)))
 457
 458 (defclass standard-slot-definition (slot-definition)
 459   ((allocation
 460     :initform :instance
 461     :initarg :allocation
 462     :accessor slot-definition-allocation)
 463    (allocation-class
 464     :initform nil
 465     :initarg :allocation-class
 466     :accessor slot-definition-allocation-class)))
 467
 468 (defclass condition-slot-definition (slot-definition)
 469   ((allocation
 470     :initform :instance
 471     :initarg :allocation
 472     :accessor slot-definition-allocation)
 473    (allocation-class
 474     :initform nil
 475     :initarg :allocation-class
 476     :accessor slot-definition-allocation-class)))
 477
 478 (defclass structure-slot-definition (slot-definition)
 479   ((defstruct-accessor-symbol
 480      :initform nil
 481      :initarg :defstruct-accessor-symbol
 482      :accessor slot-definition-defstruct-accessor-symbol)
 483    (internal-reader-function
 484      :initform nil
 485      :initarg :internal-reader-function
 486      :accessor slot-definition-internal-reader-function)
 487    (internal-writer-function
 488      :initform nil
 489      :initarg :internal-writer-function
 490      :accessor slot-definition-internal-writer-function)))
 491
 492 (defclass direct-slot-definition (slot-definition)
 493   ((readers
 494     :initform nil
 495     :initarg :readers
 496     :accessor slot-definition-readers)
 497    (writers
 498     :initform nil
 499     :initarg :writers
 500     :accessor slot-definition-writers)))
 501
 502 (defclass effective-slot-definition (slot-definition)
 503   ((accessor-flags
 504     :initform 0)
 505    (info
 506     :accessor slot-definition-info)))
 507
 508 ;;; We use a structure here, because fast slot-accesses to this information
 509 ;;; are critical to making SLOT-VALUE-USING-CLASS &co fast: places that need
 510 ;;; these functions can access the SLOT-INFO directly, avoiding the overhead
 511 ;;; of accessing a standard-instance.
 512 (defstruct (slot-info (:constructor make-slot-info
 513                                     (&key slotd
 514                                           typecheck
 515                                           (type t)
 516                                           (reader
 517                                            (uninitialized-accessor-function :reader slotd))
 518                                           (writer
 519                                            (uninitialized-accessor-function :writer slotd))
 520                                           (boundp
 521                                            (uninitialized-accessor-function :boundp slotd)))))
 522   (typecheck nil :type (or null function))
 523   (reader (missing-arg) :type function)
 524   (writer (missing-arg) :type function)
 525   (boundp (missing-arg) :type function))
 526
 527 (defclass standard-direct-slot-definition (standard-slot-definition
 528                                            direct-slot-definition)
 529   ())
 530
 531 (defclass standard-effective-slot-definition (standard-slot-definition
 532                                               effective-slot-definition)
 533   ((location ; nil, a fixnum, a cons: (slot-name . value)
 534     :initform nil
 535     :accessor slot-definition-location)))
 536
 537 (defclass condition-direct-slot-definition (condition-slot-definition
 538                                             direct-slot-definition)
 539   ())
 540
 541 (defclass condition-effective-slot-definition (condition-slot-definition
 542                                                effective-slot-definition)
 543   ())
 544
 545 (defclass structure-direct-slot-definition (structure-slot-definition
 546                                             direct-slot-definition)
 547   ())
 548
 549 (defclass structure-effective-slot-definition (structure-slot-definition
 550                                                effective-slot-definition)
 551   ())
 552
 553 (defclass specializer (metaobject)
 554   ;; KLUDGE: in sbcl-0.9.10.2 this was renamed from TYPE, which was an
 555   ;; external symbol of the CL package and hence potentially collides
 556   ;; with user code.  Renaming this to %TYPE, however, is the coward's
 557   ;; way out, because the objects that PCL puts in this slot aren't
 558   ;; (quite) types: they are closer to kinds of specializer.  However,
 559   ;; the wholesale renaming and disentangling of specializers didn't
 560   ;; appeal.  (See also message <sqd5hrclb2.fsf@cam.ac.uk> and
 561   ;; responses in comp.lang.lisp).  -- CSR, 2006-02-27
 562   ((%type :initform nil :reader specializer-type)))
 563
 564 ;;; STANDARD in this name doesn't mean "blessed by a standard" but
 565 ;;; "comes as standard with PCL"; that is, it includes CLASS-EQ
 566 ;;; and vestiges of PROTOTYPE specializers
 567 (defclass standard-specializer (specializer) ())
 568
 569 (defclass specializer-with-object (specializer) ())
 570
 571 (defclass exact-class-specializer (specializer) ())
 572
 573 (defclass class-eq-specializer (standard-specializer
 574                                 exact-class-specializer
 575                                 specializer-with-object)
 576   ((object :initarg :class
 577            :reader specializer-class
 578            :reader specializer-object)))
 579
 580 (defclass class-prototype-specializer (standard-specializer specializer-with-object)
 581   ((object :initarg :class
 582            :reader specializer-class
 583            :reader specializer-object)))
 584
 585 (defclass eql-specializer (standard-specializer exact-class-specializer specializer-with-object)
 586   ((object :initarg :object :reader specializer-object
 587            :reader eql-specializer-object)))
 588
 589 (defvar *eql-specializer-table* (make-hash-table :test 'eql))
 590
 591 (defun intern-eql-specializer (object)
 592   ;; Need to lock, so that two threads don't get non-EQ specializers
 593   ;; for an EQL object.
 594   (with-locked-system-table (*eql-specializer-table*)
 595     (or (gethash object *eql-specializer-table*)
 596         (setf (gethash object *eql-specializer-table*)
 597               (make-instance 'eql-specializer :object object)))))
 598
 599 (defclass class (dependent-update-mixin
 600                  definition-source-mixin
 601                  standard-specializer)
 602   ((name
 603     :initform nil
 604     :initarg :name
 605     :reader class-name)
 606    (class-eq-specializer
 607     :initform nil
 608     :reader class-eq-specializer)
 609    (direct-superclasses
 610     :initform ()
 611     :reader class-direct-superclasses)
 612    ;; Note: The (CLASS-)DIRECT-SUBCLASSES for STRUCTURE-CLASSes and
 613    ;; CONDITION-CLASSes are lazily computed whenever the subclass info
 614    ;; becomes available, i.e. when the PCL class is created.
 615    (direct-subclasses
 616     :initform ()
 617     :reader class-direct-subclasses)
 618    (direct-methods
 619     :initform (cons nil nil))
 620    (%documentation
 621     :initform nil
 622     :initarg :documentation)
 623    ;; True if the class definition was compiled with a (SAFETY 3)
 624    ;; optimization policy.
 625    (safe-p
 626     :initform nil
 627     :initarg safe-p
 628     :accessor safe-p)
 629    (finalized-p
 630     :initform nil
 631     :reader class-finalized-p)))
 632
 633 (def!method make-load-form ((class class) &optional env)
 634   ;; FIXME: should we not instead pass ENV to FIND-CLASS?  Probably
 635   ;; doesn't matter while all our environments are the same...
 636   (declare (ignore env))
 637   (let ((name (class-name class)))
 638     (unless (and name (eq (find-class name nil) class))
 639       (error "~@<Can't use anonymous or undefined class as constant: ~S~:@>"
 640              class))
 641     `(find-class ',name)))
 642
 643 ;;; The class PCL-CLASS is an implementation-specific common
 644 ;;; superclass of all specified subclasses of the class CLASS.
 645 (defclass pcl-class (class)
 646   ((%class-precedence-list
 647     :reader class-precedence-list)
 648    ;; KLUDGE: see note in CPL-OR-NIL
 649    (cpl-available-p
 650     :reader cpl-available-p
 651     :initform nil)
 652    (can-precede-list
 653     :initform ()
 654     :reader class-can-precede-list)
 655    (incompatible-superclass-list
 656     :initform ()
 657     :accessor class-incompatible-superclass-list)
 658    (wrapper
 659     :initform nil
 660     :reader class-wrapper)
 661    (prototype
 662     :initform nil
 663     :reader class-prototype)))
 664
 665 (defclass slot-class (pcl-class)
 666   ((direct-slots
 667     :initform ()
 668     :reader class-direct-slots)
 669    (slots
 670     :initform ()
 671     :reader class-slots)))
 672
 673 ;;; The class STD-CLASS is an implementation-specific common
 674 ;;; superclass of the classes STANDARD-CLASS and
 675 ;;; FUNCALLABLE-STANDARD-CLASS.
 676 (defclass std-class (slot-class)
 677   ())
 678
 679 (defclass standard-class (std-class)
 680   ()
 681   (:default-initargs
 682    :direct-superclasses (list *the-class-standard-object*)))
 683
 684 (defclass funcallable-standard-class (std-class)
 685   ()
 686   (:default-initargs
 687    :direct-superclasses (list *the-class-funcallable-standard-object*)))
 688
 689 (defclass forward-referenced-class (pcl-class) ())
 690
 691 (defclass built-in-class (pcl-class) ())
 692
 693 (defclass condition-class (slot-class) ())
 694
 695 (defclass structure-class (slot-class)
 696   ((defstruct-form :initform () :accessor class-defstruct-form)
 697    (defstruct-constructor :initform nil :accessor class-defstruct-constructor)
 698    (from-defclass-p :initform nil :initarg :from-defclass-p)))
 699
 700 (defclass definition-source-mixin (standard-object)
 701   ((source
 702     :initform nil
 703     :reader definition-source
 704     :initarg :definition-source)))
 705
 706 (defclass plist-mixin (standard-object)
 707   ((plist :initform () :accessor object-plist :initarg plist)))
 708
 709 (defclass dependent-update-mixin (plist-mixin) ())
 710
 711 (defparameter *early-class-predicates*
 712   '((specializer specializerp)
 713     (standard-specializer standard-specializer-p)
 714     (exact-class-specializer exact-class-specializer-p)
 715     (class-eq-specializer class-eq-specializer-p)
 716     (eql-specializer eql-specializer-p)
 717     (class classp)
 718     (slot-class slot-class-p)
 719     (std-class std-class-p)
 720     (standard-class standard-class-p)
 721     (funcallable-standard-class funcallable-standard-class-p)
 722     (condition-class condition-class-p)
 723     (structure-class structure-class-p)
 724     (forward-referenced-class forward-referenced-class-p)
 725     (method method-p)
 726     (standard-method standard-method-p)
 727     (accessor-method accessor-method-p)
 728     (standard-accessor-method standard-accessor-method-p)
 729     (standard-reader-method standard-reader-method-p)
 730     (standard-writer-method standard-writer-method-p)
 731     (standard-boundp-method standard-boundp-method-p)
 732     (global-reader-method global-reader-method-p)
 733     (global-writer-method global-writer-method-p)
 734     (global-boundp-method global-boundp-method-p)
 735     (generic-function generic-function-p)
 736     (standard-generic-function standard-generic-function-p)
 737     (method-combination method-combination-p)
 738     (long-method-combination long-method-combination-p)
 739     (short-method-combination short-method-combination-p)))