0.7.1.3:

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

diff --git a/src/compiler/ir1util.lisp b/src/compiler/ir1util.lisp
index 2f96290..fd32077 100644 (file)
--- a/src/compiler/ir1util.lisp
+++ b/src/compiler/ir1util.lisp
@@ -375,7 +375,7 @@
        ((continuation-block cont)
         (block-home-lambda-or-null (continuation-block cont)))
        (t
-        (error "internal error: confused about home lambda for ~S"))))
+        (bug "confused about home lambda for ~S"))))
 
 ;;; Return the LAMBDA that is CONT's home.
 (defun continuation-home-lambda (cont)
@@ -386,8 +386,7 @@
 ;;; slot values. Values for the alist slots are NCONCed to the
 ;;; beginning of the current value, rather than replacing it entirely.
 (defun make-lexenv (&key (default *lexenv*)
-                        functions variables blocks tags type-restrictions
-                        options
+                        funs vars blocks tags type-restrictions options
                         (lambda (lexenv-lambda default))
                         (cleanup (lexenv-cleanup default))
                         (policy (lexenv-policy default)))
@@ -397,8 +396,8 @@
                      (nconc ,var old)
                      old))))
     (internal-make-lexenv
-     (frob functions lexenv-functions)
-     (frob variables lexenv-variables)
+     (frob funs lexenv-funs)
+     (frob vars lexenv-vars)
      (frob blocks lexenv-blocks)
      (frob tags lexenv-tags)
      (frob type-restrictions lexenv-type-restrictions)
@@ -948,8 +947,8 @@
        (unless (policy *compiler-error-context* (= inhibit-warnings 3))
          ;; ANSI section "3.2.5 Exceptional Situations in the Compiler"
          ;; requires this to be no more than a STYLE-WARNING.
-         (compiler-style-warning "The variable ~S is defined but never used."
-                                 (leaf-debug-name var)))
+         (compiler-style-warn "The variable ~S is defined but never used."
+                              (leaf-debug-name var)))
        (setf (leaf-ever-used var) t)))) ; to avoid repeated warnings? -- WHN
   (values))
 
@@ -1012,8 +1011,8 @@
                                    (not (eq pkg (symbol-package :end))))))
                         (not (member first *deletion-ignored-objects*))
                         (not (typep first '(or fixnum character)))
-                        (every #'(lambda (x)
-                                   (present-in-form first x 0))
+                        (every (lambda (x)
+                                 (present-in-form first x 0))
                                (source-path-forms path))
                         (present-in-form first (find-original-source path)
                                          0)))
@@ -1138,7 +1137,7 @@
 ;;; of arguments changes, the transform must be prepared to return a
 ;;; lambda with a new lambda-list with the correct number of
 ;;; arguments.
-(defun extract-function-args (cont fun num-args)
+(defun extract-fun-args (cont fun num-args)
   #!+sb-doc
   "If CONT is a call to FUN with NUM-ARGS args, change those arguments
    to feed directly to the continuation-dest of CONT, which must be
@@ -1167,7 +1166,7 @@
          (setf (combination-args outside)
                (append before-args inside-args after-args))
          (change-ref-leaf (continuation-use inside-fun)
-                          (find-free-function 'list "???"))
+                          (find-free-fun 'list "???"))
          (setf (combination-kind inside) :full)
          (setf (node-derived-type inside) *wild-type*)
          (flush-dest cont)
@@ -1197,8 +1196,8 @@
     (change-ref-leaf ref new-leaf))
   (values))
 
-;;; Like SUBSITUTE-LEAF, only there is a predicate on the REF to tell
-;;; whether to substitute.
+;;; like SUBSITUTE-LEAF, only there is a predicate on the REF to tell
+;;; whether to substitute
 (defun substitute-leaf-if (test new-leaf old-leaf)
   (declare (type leaf new-leaf old-leaf) (type function test))
   (dolist (ref (leaf-refs old-leaf))
@@ -1357,7 +1356,7 @@
     (handler-case (apply function args)
       (error (condition)
        (let ((*compiler-error-context* node))
-         (compiler-warning "Lisp error during ~A:~%~A" context condition)
+         (compiler-warn "Lisp error during ~A:~%~A" context condition)
          (return-from careful-call (values nil nil))))))
    t))
 \f