| blob | b149a2aee8379eda3e7147136752b0f6cbec3511 |
1 ;;;; This software is part of the SBCL system. See the README file for
2 ;;;; more information.
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.
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.
25 \f
38 pv-table wrappers)))
46 t nil nil)))))))
49 method-alist wrappers)
53 method-alist wrappers))
56 method-alist-p wrappers-p)
61 ;; We have some sort of `real' effective method. Go off and get a
62 ;; compiled function for it. Most of the real hair here is done by
63 ;; the GET-FUN mechanism.
65 method-alist-p wrappers-p)))
68 form
69 method-alist-p
70 wrappers-p)
80 t
88 'fast-method-call
98 ;; The effective method is just a call to CALL-METHOD. This opens up
99 ;; the possibility of just using the method function of the method as
100 ;; the effective method function.
101 ;;
102 ;; But we have to be careful. If that method function will ask for
103 ;; the next methods we have to provide them. We do not look to see
104 ;; if there are next methods, we look at whether the method function
105 ;; asks about them. If it does, we must tell it whether there are
106 ;; or aren't to prevent the leaky next methods bug.
116 method
117 cm-args1
118 fmf-p
119 method-alist
120 wrappers))))
122 ;;; methods-tracing TODO:
123 ;;;
124 ;;; 2. tracing method calls for non-fast-method-function calls
125 ;;; - [DONE] the calls themselves
126 ;;; - calls to the METHOD-FUNCTION of methods with fast functions
127 ;;; (e.g. from something implementing CALL-NEXT-METHOD; handle this with
128 ;;; some more smarts in %METHOD-FUNCTION objects?)
129 ;;; - calls to the METHOD-FUNCTION of methods without fast functions
130 ;;; (TRACE :METHODS T /could/ modify the METHOD-FUNCTION slot)
131 ;;; 4. tracing particular methods
132 ;;; - need an interface.
133 ;;; * (trace (method foo :around (t)))? [ how to trace the method and not
134 ;;; the generic function as a whole?]
135 ;;; * (trace :methods '((:around (t))) foo)? [probably not, interacts
136 ;;; poorly with TRACE arg handling]
137 ;;; 5. supporting non-munged arguments as an option
140 ;; KLUDGE: we abuse NIL as second argument to mean that this is a
141 ;; combined method (i.e. something resulting from MAKE-METHOD in a
142 ;; method combination, rather than CALL-METHOD on a method object).
151 ;; KLUDGE: testing if *TRACE-FUNS* has anything anything to
152 ;; avoid calling METHOD-TRACE-NAME during PCL bootstrapping
153 ;; when the generic-function type is not yet defined.)
164 copy)))))))
168 fun))))
172 ;; Avoid style-warning about compiler-macro being unavailable.
181 fmf-p method-alist wrappers))
197 arg
214 :qualifiers nil
216 arg))))
220 ;; FIXME: this is wrong. Very wrong. It assumes
221 ;; that the only place that can have make-method
222 ;; calls is in the list structure of the second
223 ;; argument to CALL-METHOD, but AMOP says that
224 ;; CALL-METHOD can be more complicated if
225 ;; COMPUTE-EFFECTIVE-METHOD (and presumably
226 ;; MAKE-METHOD-LAMBDA) is adjusted to match.
227 ;;
228 ;; On the other hand, it's a start, because
229 ;; without this calls to MAKE-METHOD in method
230 ;; combination where one of the methods is of a
231 ;; user-defined class don't work at all. -- CSR,
232 ;; 2006-08-05
240 mf))))
252 method-alist wrappers)
253 method))))
264 new)))
277 ;; Otherwise the METHOD-COMBINATION slot is not bound.
288 .dfun-more-context.
290 .dfun-more-count.)))
310 ;; the PROGN is here to defend against premature macroexpansion by
311 ;; RESTART-CASE.
319 generic-function form method-alist-p wrappers-p)))
321 'fast-method-call
322 t))
328 generic-function form method-alist-p wrappers-p)
333 generic-function form method-alist-p wrappers-p)
338 ;;; CMUCL comment (2003-10-15):
339 ;;;
340 ;;; This function is called via the GET-FUNCTION mechanism on forms
341 ;;; of an emf lambda. First value returned replaces FORM in the emf
342 ;;; lambda. Second value is a list of variable names that become
343 ;;; closure variables.
352 generic-function form method-alist-p wrappers-p))
357 generic-function form method-alist-p wrappers-p)))
369 generic-function form))))
374 generic-function form))
391 generic-function effective-method)))
396 method-alist-p wrappers-p))
399 metatypes applyp
400 method-alist-p wrappers-p))
407 (.meth.
409 (.meth-list.
456 ;; APPLICABLE-METHODS is normally non-null in effective
457 ;; method computation, but COMPUTE-APPLICABLE-METHODS can
458 ;; in principle be called by MetaObject Protocol programmers.
460 "No applicable method found for ~S"
463 ;; PCL checks for no primary method before method
464 ;; combination, but a MetaObject Protocol programmer could
465 ;; call COMPUTE-EFFECTIVE-METHOD themselves and end up
466 ;; here.
468 "No primary method found for ~S among applicable methods: ~S"
471 ;; By returning a single call-method `form' here we enable
472 ;; an important implementation-specific optimization; that
473 ;; is, we can use the fast method function directly as the
474 ;; effective method function.
475 ;;
476 ;; However, the requirement by ANSI (CLHS 7.6.5) on generic
477 ;; function argument checking inhibits this, as we don't
478 ;; perform this checking in fast-method-functions given
479 ;; that they are not solely used for effective method
480 ;; functions, but also in combination, when they should not
481 ;; perform argument checks. We still return the bare
482 ;; CALL-METHOD, but the caller is responsible for ensuring
483 ;; that keyword applicability is checked if this is a fast
484 ;; method function used in an effective method. (See
485 ;; WRAP-WITH-APPLICABLE-KEYWORD-CHECK below).
501 main-effective-method))))))
532 (:most-specific-first
539 primary)))))
541 ;; APPLICABLE-METHODS is normally non-null in effective
542 ;; method computation, but COMPUTE-APPLICABLE-METHODS can
543 ;; in principle be called by MetaObject Protocol programmers.
545 "No applicable method found for ~S"
548 ;; PCL checks for no primary method before method
549 ;; combination, but a MetaObject Protocol programmer could
550 ;; call COMPUTE-EFFECTIVE-METHOD themselves and end up
551 ;; here.
553 "No primary method found for ~S among applicable methods: ~S"
559 \f
560 ;;; helper code for checking keywords in generic function calls.
599 ~{~S~^, ~} (valid keys are ~{~S~^, ~}).~@:>"
607 key))
611 ;; only the leftmost :ALLOW-OTHER-KEYS has any effect
623 .keyargs-start. .valid-keys. .dfun-more-context. .dfun-more-count.)
625 \f
626 ;;;; the STANDARD method combination type. This is coded by hand
627 ;;;; (rather than with DEFINE-METHOD-COMBINATION) for bootstrapping
628 ;;;; and efficiency reasons. Note that the definition of the
629 ;;;; FIND-METHOD-COMBINATION-METHOD appears in the file
630 ;;;; defcombin.lisp. This is because EQL methods can't appear in the
631 ;;;; bootstrap.
632 ;;;;
633 ;;;; The DEFCLASS for the METHOD-COMBINATION and
634 ;;;; STANDARD-METHOD-COMBINATION classes has to appear here for this
635 ;;;; reason. This code must conform to the code in the file
636 ;;;; defcombin.lisp, look there for more details.
640 combin
641 applicable-methods))
643 ;;; not INVALID-METHOD-ERROR as that would violate CLHS 11.1.2.1.1
645 ())
652 ;;; not METHOD-COMBINATION-ERROR as that would violate CLHS 11.1.2.1.1
654 ())