(apply
(lambda (gf type options)
(declare (ignore gf))
- (do-short-method-combination
+ (short-combine-methods
type options operator ioa new-method doc))
args))
:definition-source `((define-method-combination ,type) ,truename)))
(remove-method #'find-method-combination old-method))
(add-method #'find-method-combination new-method)))
-(defun do-short-method-combination (type options operator ioa method doc)
+(defun short-combine-methods (type options operator ioa method doc)
(cond ((null options) (setq options '(:most-specific-first)))
((equal options '(:most-specific-first)))
((equal options '(:most-specific-last)))
(let ((type (method-combination-type combin))
(operator (short-combination-operator combin))
(ioa (short-combination-identity-with-one-argument combin))
+ (order (car (method-combination-options combin)))
(around ())
(primary ()))
(dolist (m applicable-methods)
(push m primary))
(t
(lose m "has an illegal qualifier"))))))
- (setq around (nreverse around)
- primary (nreverse primary))
+ (setq around (nreverse around))
+ (ecase order
+ (:most-specific-last) ; nothing to be done, already in correct order
+ (:most-specific-first
+ (setq primary (nreverse primary))))
(let ((main-method
(if (and (null (cdr primary))
(not (null ioa)))
(lambda-list (caddr form))
(method-group-specifiers (cadddr form))
(body (cddddr form))
- (arguments-option ())
+ (args-option ())
(gf-var nil))
(when (and (consp (car body)) (eq (caar body) :arguments))
- (setq arguments-option (cdr (pop body))))
+ (setq args-option (cdr (pop body))))
(when (and (consp (car body)) (eq (caar body) :generic-function))
(setq gf-var (cadr (pop body))))
(multiple-value-bind (documentation function)
(make-long-method-combination-function
- type lambda-list method-group-specifiers arguments-option gf-var
+ type lambda-list method-group-specifiers args-option gf-var
body)
`(load-long-defcombin ',type ',documentation #',function))))
(declare (ignore nms cm-args))
(apply
(lambda (generic-function type options)
- (declare (ignore generic-function options))
+ (declare (ignore generic-function))
(make-instance 'long-method-combination
:type type
+ :options options
:documentation doc))
args))
:definition-source `((define-method-combination ,type)
applicable-methods))
(defun make-long-method-combination-function
- (type ll method-group-specifiers arguments-option gf-var body)
- ;;(declare (values documentation function))
+ (type ll method-group-specifiers args-option gf-var body)
(declare (ignore type))
- (multiple-value-bind (documentation declarations real-body)
- (extract-declarations body)
+ (multiple-value-bind (real-body declarations documentation)
+ ;; (Note that PARSE-BODY ignores its second arg ENVIRONMENT.)
+ (parse-body body nil)
(let ((wrapped-body
(wrap-method-group-specifier-bindings method-group-specifiers
(when gf-var
(push `(,gf-var .generic-function.) (cadr wrapped-body)))
- (when arguments-option
- (setq wrapped-body (deal-with-arguments-option wrapped-body
- arguments-option)))
+ (when args-option
+ (setq wrapped-body (deal-with-args-option wrapped-body args-option)))
(when ll
(setq wrapped-body
;;;
;;; At compute-effective-method time, the symbols in the :arguments
;;; option are bound to the symbols in the intercept lambda list.
-(defun deal-with-arguments-option (wrapped-body arguments-option)
+(defun deal-with-args-option (wrapped-body args-option)
(let* ((intercept-lambda-list
(let (collect)
- (dolist (arg arguments-option)
+ (dolist (arg args-option)
(if (memq arg lambda-list-keywords)
(push arg collect)
(push (gensym) collect)))
(nreverse collect)))
(intercept-rebindings
- (loop for arg in arguments-option
+ (loop for arg in args-option
for int in intercept-lambda-list
unless (memq arg lambda-list-keywords)
collect `(,arg ',int))))