\begin{describe}{fun}{merge-keyword-lists @<lists> @> @<list>}
Merge a number of keyword-argument lists together and return the result.
- The @<lists> parameter is a list consisting of a number of @|(@<args>
- . @<origin>)| pairs: in each pair, @<args> is a list of
- \descref{argument}{cls} objects, and @<origin> is either nil or an object
- whose printed representation describes the origin of the corresponding
- @<args> list, suitable for inclusion in an error message.
+ The @<lists> parameter is a list consisting of a number of @|(@<origin>
+ . @<args>)| pairs: in each pair, @<origin> is either nil or an object whose
+ printed representation describes the origin of the corresponding @<args>
+ list suitable for inclusion in an error message, and @<args> is a list of
+ \descref{argument}{cls} objects.
The resulting list contains exactly one argument for each distinct argument
name appearing in the input @<lists>; this argument will contain the
(mapcan (lambda (class)
(let ((initargs (sod-class-initargs class)))
(and initargs
- (list (cons (mapcar #'sod-initarg-argument
- initargs)
- (format nil "initargs for ~A"
- class))))))
+ (list (cons (format nil "initargs for ~A"
+ class)
+ (mapcar #'sod-initarg-argument
+ initargs))))))
(sod-class-precedence-list
(effective-method-class method)))))
(defun merge-keyword-lists (lists)
"Return the union of keyword argument lists.
- The LISTS parameter consists of pairs (ARGS . WHAT), where ARGS is a list
- of `argument' objects, and WHAT is either nil or a printable object
- describing the origin of the corresponding argument list suitable for
- quoting in an error message.
+ The LISTS parameter consists of pairs (WHAT . ARGS), where WHAT is either
+ nil or a printable object describing the origin of this argument list
+ suitable for inclusion in an error message, and ARGS is a list of
+ `argument' objects.
The resulting list contains exactly one argument for each distinct
argument name appearing in the input lists; this argument will contain the
conflicting pair of arguments."
;; The easy way through all of this is with a hash table mapping argument
- ;; names to (ARGUMENT . WHAT) pairs.
+ ;; names to (WHAT . ARG) pairs.
(let ((argmap (make-hash-table :test #'equal)))
;; Set up the table. When we find a duplicate, check that the types
;; match.
(dolist (item lists)
- (let ((args (car item))
- (what (cdr item)))
+ (let ((what (car item))
+ (args (cdr item)))
(dolist (arg args)
(let* ((name (argument-name arg))
(other-item (gethash name argmap)))
(if (null other-item)
- (setf (gethash name argmap) (cons arg what))
+ (setf (gethash name argmap) (cons what arg))
(let* ((type (argument-type arg))
- (other (car other-item))
- (other-type (argument-type other))
- (other-what (cdr other-item)))
+ (other-what (car other-item))
+ (other (cdr other-item))
+ (other-type (argument-type other)))
(unless (c-type-equal-p type other-type)
(error "Type mismatch for keyword argument `~A': ~
~A~@[ (~A)~] doesn't match ~A~@[ (~A)~]"
(let ((result nil))
(maphash (lambda (name item)
(declare (ignore name))
- (push (car item) result))
+ (push (cdr item) result))
argmap)
(fix-and-check-keyword-argument-list result))))
((method effective-method) direct-methods)
(with-slots (message) method
(and (keyword-message-p message)
- (cons (cons (c-function-keywords (sod-message-type message))
- (format nil "message ~A (at ~A)"
- message (file-location message)))
+ (cons (cons (format nil "message ~A (at ~A)"
+ message (file-location message))
+ (c-function-keywords (sod-message-type message)))
(mapcar (lambda (m)
- (cons (c-function-keywords (sod-method-type m))
- (format nil "method for ~A on ~A (at ~A)"
+ (cons (format nil "method for ~A on ~A (at ~A)"
message
(sod-method-class m)
- (file-location m))))
+ (file-location m))
+ (c-function-keywords (sod-method-type m))))
direct-methods)))))
(defmethod shared-initialize :after
"Returns a list of keyword argument lists to be merged.
This should return a list suitable for passing to `merge-keyword-lists',
- i.e., each element should be a pair consisting of a list of `argument'
- objects and a string describing the source of the argument list."))
+ i.e., each element should be a pair consisting of a string describing the
+ source of the argument list, and a list of `argument' objects."))
(export 'compute-sod-effective-method)
(defgeneric compute-sod-effective-method (message class)