0.6.11.16:
[sbcl.git] / src / pcl / dlisp2.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 (defun emit-reader/writer-function (reader/writer 1-or-2-class class-slot-p)
27   (values
28    (ecase reader/writer
29      (:reader (ecase 1-or-2-class
30                 (1 (if class-slot-p
31                        (emit-reader/writer-macro :reader 1 t)
32                        (emit-reader/writer-macro :reader 1 nil)))
33                 (2 (if class-slot-p
34                        (emit-reader/writer-macro :reader 2 t)
35                        (emit-reader/writer-macro :reader 2 nil)))))
36      (:writer (ecase 1-or-2-class
37                 (1 (if class-slot-p
38                        (emit-reader/writer-macro :writer 1 t)
39                        (emit-reader/writer-macro :writer 1 nil)))
40                 (2 (if class-slot-p
41                        (emit-reader/writer-macro :writer 2 t)
42                        (emit-reader/writer-macro :writer 2 nil))))))
43    nil))
44
45 (defun emit-one-or-n-index-reader/writer-function
46     (reader/writer cached-index-p class-slot-p)
47   (values
48    (ecase reader/writer
49      (:reader (if cached-index-p
50                   (if class-slot-p
51                       (emit-one-or-n-index-reader/writer-macro :reader t t)
52                       (emit-one-or-n-index-reader/writer-macro :reader t nil))
53                   (if class-slot-p
54                       (emit-one-or-n-index-reader/writer-macro :reader nil t)
55                       (emit-one-or-n-index-reader/writer-macro :reader nil nil))))
56      (:writer (if cached-index-p
57                   (if class-slot-p
58                       (emit-one-or-n-index-reader/writer-macro :writer t t)
59                       (emit-one-or-n-index-reader/writer-macro :writer t nil))
60                   (if class-slot-p
61                       (emit-one-or-n-index-reader/writer-macro :writer nil t)
62                       (emit-one-or-n-index-reader/writer-macro :writer nil nil)))))
63    nil))
64
65 ;;; Note this list is setup in dlisp3.lisp when all the necessary
66 ;;; macros have been loaded.
67 (defvar *checking-or-caching-function-list* nil)
68
69 (defmacro emit-checking-or-caching-function-precompiled ()
70   `(cdr (assoc (list cached-emf-p return-value-p metatypes applyp)
71                *checking-or-caching-function-list*
72                :test #'equal)))
73
74 (defun emit-checking-or-caching-function (cached-emf-p return-value-p metatypes applyp)
75   (let ((fn (emit-checking-or-caching-function-precompiled)))
76     (if fn
77         (values fn nil)
78         (values (emit-checking-or-caching-function-preliminary
79                  cached-emf-p return-value-p metatypes applyp)
80                 t))))
81
82 (defvar *not-in-cache* (make-symbol "not in cache"))
83
84 (defun emit-checking-or-caching-function-preliminary
85     (cached-emf-p return-value-p metatypes applyp)
86   (declare (ignore applyp))
87   (if cached-emf-p
88       #'(lambda (cache miss-fn)
89           (declare (type function miss-fn))
90           #'(sb-kernel:instance-lambda (&rest args)
91               (declare #.*optimize-speed*)
92               (with-dfun-wrappers (args metatypes)
93                 (dfun-wrappers invalid-wrapper-p)
94                 (apply miss-fn args)
95                 (if invalid-wrapper-p
96                     (apply miss-fn args)
97                     (let ((emf (probe-cache cache dfun-wrappers *not-in-cache*)))
98                       (if (eq emf *not-in-cache*)
99                           (apply miss-fn args)
100                           (if return-value-p
101                               emf
102                               (invoke-emf emf args))))))))
103       #'(lambda (cache emf miss-fn)
104           (declare (type function miss-fn))
105           #'(sb-kernel:instance-lambda (&rest args)
106               (declare #.*optimize-speed*)
107               (with-dfun-wrappers (args metatypes)
108                 (dfun-wrappers invalid-wrapper-p)
109                 (apply miss-fn args)
110                 (if invalid-wrapper-p
111                     (apply miss-fn args)
112                     (let ((found-p (not (eq *not-in-cache*
113                                             (probe-cache cache dfun-wrappers
114                                                          *not-in-cache*)))))
115                       (if found-p
116                           (invoke-emf emf args)
117                           (if return-value-p
118                               t
119                               (apply miss-fn args))))))))))
120
121 (defun emit-default-only-function (metatypes applyp)
122   (declare (ignore metatypes applyp))
123   (values #'(lambda (emf)
124               #'(lambda (&rest args)
125                   (invoke-emf emf args)))
126           t))