0.7.1.2:

[sbcl.git] / src / compiler / locall.lisp

diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp
index 8867f28..eb49946 100644 (file)
--- a/src/compiler/locall.lisp
+++ b/src/compiler/locall.lisp
@@ -135,7 +135,7 @@
          (declare (type index ,n-supplied))
          ,(if (policy *lexenv* (zerop safety))
               `(declare (ignore ,n-supplied))
-              `(%verify-argument-count ,n-supplied ,nargs))
+              `(%verify-arg-count ,n-supplied ,nargs))
          (%funcall ,fun ,@temps))))
     (optional-dispatch
      (let* ((min (optional-dispatch-min-args fun))
@@ -164,7 +164,7 @@
                            (%more-arg-context ,n-supplied ,max)
                          (%funcall ,more ,@temps ,n-context ,n-count))))))
             (t
-             (%argument-count-error ,n-supplied)))))))))
+             (%arg-count-error ,n-supplied)))))))))
 
 ;;; Make an external entry point (XEP) for FUN and return it. We
 ;;; convert the result of MAKE-XEP-LAMBDA in the correct environment,
@@ -190,7 +190,8 @@
            (component-reanalyze *current-component*) t
            (component-reoptimize *current-component*) t)
       (etypecase fun
-       (clambda (locall-analyze-fun-1 fun))
+       (clambda
+        (locall-analyze-fun-1 fun))
        (optional-dispatch
         (dolist (ep (optional-dispatch-entry-points fun))
           (locall-analyze-fun-1 ep))
@@ -284,6 +285,12 @@
                      ;; FUN becomes part of COMPONENT-LAMBDAS now.
                      (aver (not (member fun (component-lambdas component))))
                      (push fun (component-lambdas component)))
+                    ;; FIXME: Maybe we don't need this clause?
+                    ;; The only time I really thought I needed it
+                    ;; was bug 138, and adding this clause didn't
+                    ;; fix bug 138 but instead caused all sorts
+                    ;; of other things to fail downstream...
+                    #|
                     ((eql (lambda-inlinep fun) :inline)
                      ;; FUNs marked :INLINE are sometimes in
                      ;; COMPONENT-LAMBDAS and sometimes not. I (WHN
@@ -297,6 +304,7 @@
                      ;; expansions of local functions might in
                      ;; COMPONENT-LAMBDAS?)
                      (values))
+                     |#
                     (t ; FUN is old.
                      ;; FUN should be in COMPONENT-LAMBDAS already.
                      (aver (member fun (component-lambdas component)))))
@@ -469,7 +477,7 @@
           ;; wrong. And we're in locall.lisp here, so it's probably
           ;; (haven't checked this..) a call to something in the same
           ;; file. So maybe it deserves a full warning anyway.
-          (compiler-warning
+          (compiler-warn
            "function called with ~R argument~:P, but wants exactly ~R"
            call-args nargs)
           (setf (basic-combination-kind call) :error)))))
@@ -490,7 +498,7 @@
     (cond ((< call-args min-args)
           ;; FIXME: See FIXME note at the previous
           ;; wrong-number-of-arguments warnings in this file.
-          (compiler-warning
+          (compiler-warn
            "function called with ~R argument~:P, but wants at least ~R"
            call-args min-args)
           (setf (basic-combination-kind call) :error))
@@ -503,7 +511,7 @@
          (t
           ;; FIXME: See FIXME note at the previous
           ;; wrong-number-of-arguments warnings in this file.
-          (compiler-warning
+          (compiler-warn
            "function called with ~R argument~:P, but wants at most ~R"
            call-args max-args)
           (setf (basic-combination-kind call) :error))))
@@ -574,14 +582,14 @@
               (key-vars var))
              ((:rest :optional))
              ((:more-context :more-count)
-              (compiler-warning "can't local-call functions with &MORE args")
+              (compiler-warn "can't local-call functions with &MORE args")
               (setf (basic-combination-kind call) :error)
               (return-from convert-more-call))))))
 
       (when (optional-dispatch-keyp fun)
        (when (oddp (length more))
-         (compiler-warning "function called with odd number of ~
-                            arguments in keyword portion")
+         (compiler-warn "function called with odd number of ~
+                         arguments in keyword portion")
 
          (setf (basic-combination-kind call) :error)
          (return-from convert-more-call))
@@ -610,8 +618,8 @@
                    (return)))))))
 
        (when (and loser (not (optional-dispatch-allowp fun)))
-         (compiler-warning "function called with unknown argument keyword ~S"
-                           loser)
+         (compiler-warn "function called with unknown argument keyword ~S"
+                        loser)
          (setf (basic-combination-kind call) :error)
          (return-from convert-more-call)))
 
@@ -689,9 +697,9 @@
        (join-components component clambda-component)))
     (let ((*current-component* component))
       (node-ends-block call))
-    ;; FIXME: Use PROPER-LIST-OF-LENGTH-P here, and look for other
+    ;; FIXME: Use DESTRUCTURING-BIND here, and grep for other 
     ;; uses of '=.*length' which could also be converted to use
-    ;; PROPER-LIST-OF-LENGTH-P.
+    ;; DESTRUCTURING-BIND or PROPER-LIST-OF-LENGTH-P.
     (aver (= (length (block-succ call-block)) 1))
     (let ((next-block (first (block-succ call-block))))
       (unlink-blocks call-block next-block)
@@ -760,7 +768,7 @@
 
   (declare (type clambda clambda) (type basic-combination call))
 
-  (let ((component (block-component (node-block call))))
+  (let ((component (node-component call)))
     (unlink-blocks (component-head component) (lambda-block clambda))
     (setf (component-lambdas component)
          (delete clambda (component-lambdas component)))
@@ -933,7 +941,7 @@
 ;;; work. We change the CALL's CONT to be the continuation heading the
 ;;; BIND block, and also do REOPTIMIZE-CONTINUATION on the args and
 ;;; CONT so that LET-specific IR1 optimizations get a chance. We blow
-;;; away any entry for the function in *FREE-FUNCTIONS* so that nobody
+;;; away any entry for the function in *FREE-FUNS* so that nobody
 ;;; will create new references to it.
 (defun let-convert (fun call)
   (declare (type clambda fun) (type basic-combination call))