An actual running implementation, which makes code that compiles.

[sod] / src / method-impl.lisp

diff --git a/src/method-impl.lisp b/src/method-impl.lisp
index b657b8b..09dbb2b 100644 (file)
--- a/src/method-impl.lisp
+++ b/src/method-impl.lisp
@@ -193,7 +193,8 @@
     (setf (slot-value method 'next-method-type)
          (c-type (fun (lisp (c-type-subtype type))
                       ("me" (* (class (sod-method-class method))))
-                      . (c-function-arguments type))))))
+                      .
+                      (c-function-arguments type))))))
 
 (defmethod slot-unbound (class
                         (method delegating-direct-method)
@@ -421,9 +422,6 @@
         (emf-type (c-type (fun (lisp return-type)
                                ("sod__obj" (lisp ilayout-type))
                                . (sod-message-no-varargs-tail message))))
-        (result (if (eq return-type (c-type void)) nil
-                    (temporary-var codegen return-type)))
-        (emf-target (or result :void))
 
         ;; Method entry details.
         (chain-tails (remove-if-not (lambda (super)
@@ -461,48 +459,53 @@
 
       ;; Generate the method body.  We'll work out what to do with it later.
       (codegen-push codegen)
-      (compute-effective-method-body method codegen emf-target)
-      (multiple-value-bind (vars insts) (codegen-pop codegen)
-       (cond ((or (= n-entries 1)
-                  (<= (* n-entries (reduce #'+ insts :key #'inst-metric))
-                      *method-entry-inline-threshold*))
-
-              ;; The effective method body is simple -- or there's only one
-              ;; of them.  We'll inline the method body into the entry
-              ;; functions.
-              (dolist (tail chain-tails)
-                (setup-entry tail)
-                (dolist (var vars)
-                  (ensure-var codegen (inst-name var)
-                              (inst-type var) (inst-init var)))
-                (when parm-n (varargs-prologue))
-                (emit-insts codegen insts)
-                (when parm-n (varargs-epilogue))
-                (deliver-expr codegen entry-target result)
-                (finish-entry tail)))
-
-             (t
-
-              ;; The effective method body is complicated and we'd need more
-              ;; than one copy.  We'll generate an effective method function
-              ;; and call it a lot.
-              (codegen-build-function codegen emf-name emf-type vars
-               (nconc insts (and result (list (make-return-inst result)))))
-
-              (let ((call (make-call-inst emf-name
-                           (cons "sod__obj" (mapcar #'argument-name
-                                                    emf-arg-tail)))))
+      (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)
+       (multiple-value-bind (vars insts) (codegen-pop codegen)
+         (cond ((or (= n-entries 1)
+                    (<= (* n-entries (reduce #'+ insts :key #'inst-metric))
+                        *method-entry-inline-threshold*))
+
+                ;; The effective method body is simple -- or there's only
+                ;; one of them.  We'll inline the method body into the entry
+                ;; functions.
                 (dolist (tail chain-tails)
                   (setup-entry tail)
-                  (cond (parm-n
-                         (varargs-prologue)
-                         (convert-stmts codegen entry-target return-type
-                                        (lambda (target)
-                                          (deliver-expr codegen target call)
-                                          (varargs-epilogue))))
-                        (t
-                         (deliver-expr codegen entry-target call)))
-                  (finish-entry tail))))))
+                  (dolist (var vars)
+                    (ensure-var codegen (inst-name var)
+                                (inst-type var) (inst-init var)))
+                  (when parm-n (varargs-prologue))
+                  (emit-insts codegen insts)
+                  (when parm-n (varargs-epilogue))
+                  (deliver-expr codegen entry-target result)
+                  (finish-entry tail)))
+
+               (t
+
+                ;; The effective method body is complicated and we'd need
+                ;; more than one copy.  We'll generate an effective method
+                ;; function and call it a lot.
+                (codegen-build-function codegen emf-name emf-type vars
+                 (nconc insts (and result
+                                   (list (make-return-inst result)))))
+
+                (let ((call (make-call-inst emf-name
+                             (cons "sod__obj" (mapcar #'argument-name
+                                                      emf-arg-tail)))))
+                  (dolist (tail chain-tails)
+                    (setup-entry tail)
+                    (cond (parm-n
+                           (varargs-prologue)
+                           (convert-stmts codegen entry-target return-type
+                                          (lambda (target)
+                                            (deliver-expr codegen
+                                                          target call)
+                                            (varargs-epilogue))))
+                          (t
+                           (deliver-expr codegen entry-target call)))
+                    (finish-entry tail)))))))
 
       (codegen-functions codegen))))