src/method-aggregate.lisp: Give aggregating combinations their own file.

[sod] / src / method-impl.lisp

diff --git a/src/method-impl.lisp b/src/method-impl.lisp
index 09dbb2b..49c6676 100644 (file)
--- a/src/method-impl.lisp
+++ b/src/method-impl.lisp
@@ -98,6 +98,9 @@
       (call-next-method)
       (primary-method-class message)))
 
+(defmethod primary-method-class ((message simple-message))
+  'basic-direct-method)
+
 ;;;--------------------------------------------------------------------------
 ;;; Direct method classes.
 
@@ -320,19 +323,18 @@
       method
     (let* ((message-type (sod-message-type message))
           (return-type (c-type-subtype message-type))
-          (voidp (eq return-type (c-type void)))
           (basic-tail (effective-method-basic-argument-names method)))
       (flet ((method-kernel (target)
               (dolist (before before-methods)
                 (invoke-method codegen :void basic-tail before))
-              (if (or voidp (null after-methods))
+              (if (null after-methods)
                   (funcall body target)
                   (convert-stmts codegen target return-type
                                  (lambda (target)
                                    (funcall body target)
                                    (dolist (after (reverse after-methods))
                                      (invoke-method codegen :void
-                                                    after basic-tail)))))))
+                                                    basic-tail after)))))))
        (invoke-delegation-chain codegen target basic-tail
                                 around-methods #'method-kernel)))))
 
@@ -459,7 +461,7 @@
 
       ;; Generate the method body.  We'll work out what to do with it later.
       (codegen-push codegen)
-      (let* ((result (if (eq return-type (c-type void)) nil
+      (let* ((result (if (eq return-type c-type-void) nil
                         (temporary-var codegen return-type)))
             (emf-target (or result :void)))
        (compute-effective-method-body method codegen emf-target)
@@ -474,8 +476,10 @@
                 (dolist (tail chain-tails)
                   (setup-entry tail)
                   (dolist (var vars)
-                    (ensure-var codegen (inst-name var)
-                                (inst-type var) (inst-init var)))
+                    (if (typep var 'var-inst)
+                        (ensure-var codegen (inst-name var)
+                                    (inst-type var) (inst-init var))
+                        (emit-decl codegen var)))
                   (when parm-n (varargs-prologue))
                   (emit-insts codegen insts)
                   (when parm-n (varargs-epilogue))
@@ -517,12 +521,11 @@
 
 (defmethod compute-effective-method-body
     ((method simple-effective-method) codegen target)
-  (with-slots (message basic-argument-names primary-methods) method
-    (basic-effective-method-body codegen target method
-                                (lambda (target)
-                                  (simple-method-body method
-                                                      codegen
-                                                      target)))))
+  (basic-effective-method-body codegen target method
+                              (lambda (target)
+                                (simple-method-body method
+                                                    codegen
+                                                    target))))
 
 ;;;--------------------------------------------------------------------------
 ;;; Standard method combination.
@@ -531,7 +534,7 @@
 (defclass standard-message (simple-message)
   ()
   (:documentation
-   "Message class for standard method combination.
+   "Message class for standard method combinations.
 
    Standard method combination is a simple method combination where the
    primary methods are invoked as a delegation chain, from most- to