X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fir1tran.lisp;h=6936072c7b8bd6c4e5176a0d14371e90ce277fa9;hb=c713eb2b521b048ff2c927ec52b861787d289f85;hp=c6d14e7485ef7952a592ecb1b04d5a01191243e9;hpb=08307967c71c580058a503d46aa087cfefcf8c69;p=sbcl.git

diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp
index c6d14e7..6936072 100644
--- a/src/compiler/ir1tran.lisp
+++ b/src/compiler/ir1tran.lisp
@@ -610,7 +610,7 @@
 
 (defun muffle-warning-or-die ()
   (muffle-warning)
-  (error "internal error -- no MUFFLE-WARNING restart"))
+  (bug "no MUFFLE-WARNING restart"))
 
 ;;; Expand FORM using the macro whose MACRO-FUNCTION is FUN, trapping
 ;;; errors which occur during the macroexpansion.
@@ -712,9 +712,9 @@
 
 ;;;; converting combinations
 
-;;; Convert a function call where the function (i.e. the FUN argument)
-;;; is a LEAF. We return the COMBINATION node so that the caller can
-;;; poke at it if it wants to.
+;;; Convert a function call where the function FUN is a LEAF. FORM is
+;;; the source for the call. We return the COMBINATION node so that
+;;; the caller can poke at it if it wants to.
 (declaim (ftype (function (continuation continuation list leaf) combination)
 		ir1-convert-combination))
 (defun ir1-convert-combination (start cont form fun)
@@ -722,11 +722,10 @@
     (reference-leaf start fun-cont fun)
     (ir1-convert-combination-args fun-cont cont (cdr form))))
 
-;;; Convert the arguments to a call and make the COMBINATION node.
-;;; FUN-CONT is the continuation which yields the function to call.
-;;; FORM is the source for the call. ARGS is the list of arguments for
-;;; the call, which defaults to the cdr of source. We return the
-;;; COMBINATION node.
+;;; Convert the arguments to a call and make the COMBINATION
+;;; node. FUN-CONT is the continuation which yields the function to
+;;; call. ARGS is the list of arguments for the call, which defaults
+;;; to the cdr of source. We return the COMBINATION node.
 (defun ir1-convert-combination-args (fun-cont cont args)
   (declare (type continuation fun-cont cont) (list args))
   (let ((node (make-combination fun-cont)))
@@ -987,7 +986,7 @@
 	(make-lexenv :default res :funs new-fenv)
 	res)))
 
-;;; Like FIND-IN-BINDINGS, but looks for #'foo in the fvars.
+;;; like FIND-IN-BINDINGS, but looks for #'FOO in the FVARS
 (defun find-in-bindings-or-fbindings (name vars fvars)
   (declare (list vars fvars))
   (if (consp name)
@@ -1045,7 +1044,7 @@
       (special (process-special-decl spec res vars))
       (ftype
        (unless (cdr spec)
-	 (compiler-error "No type specified in FTYPE declaration: ~S" spec))
+	 (compiler-error "no type specified in FTYPE declaration: ~S" spec))
        (process-ftype-decl (second spec) res (cddr spec) fvars))
       ((inline notinline maybe-inline)
        (process-inline-decl spec res fvars))
@@ -1093,9 +1092,7 @@
   (dolist (decl decls)
     (dolist (spec (rest decl))
       (unless (consp spec)
-	(compiler-error "malformed declaration specifier ~S in ~S"
-			spec
-			decl))
+	(compiler-error "malformed declaration specifier ~S in ~S" spec decl))
       (setq env (process-1-decl spec env vars fvars cont))))
   env)
 
@@ -1126,22 +1123,22 @@
 ;;;; function representation" before you seriously mess with this
 ;;;; stuff.
 
-;;; Verify that a thing is a legal name for a variable and return a
-;;; Var structure for it, filling in info if it is globally special.
-;;; If it is losing, we punt with a Compiler-Error. Names-So-Far is an
-;;; alist of names which have previously been bound. If the name is in
+;;; Verify that the NAME is a legal name for a variable and return a
+;;; VAR structure for it, filling in info if it is globally special.
+;;; If it is losing, we punt with a COMPILER-ERROR. NAMES-SO-FAR is a
+;;; list of names which have previously been bound. If the NAME is in
 ;;; this list, then we error out.
 (declaim (ftype (function (t list) lambda-var) varify-lambda-arg))
 (defun varify-lambda-arg (name names-so-far)
   (declare (inline member))
   (unless (symbolp name)
-    (compiler-error "The lambda-variable ~S is not a symbol." name))
+    (compiler-error "The lambda variable ~S is not a symbol." name))
   (when (member name names-so-far :test #'eq)
     (compiler-error "The variable ~S occurs more than once in the lambda-list."
 		    name))
   (let ((kind (info :variable :kind name)))
     (when (or (keywordp name) (eq kind :constant))
-      (compiler-error "The name of the lambda-variable ~S is a constant."
+      (compiler-error "The name of the lambda variable ~S is already in use to name a constant."
 		      name))
     (cond ((eq kind :special)
 	   (let ((specvar (find-free-var name)))
@@ -1219,7 +1216,8 @@
 	(dolist (spec optional)
 	  (if (atom spec)
 	      (let ((var (varify-lambda-arg spec (names-so-far))))
-		(setf (lambda-var-arg-info var) (make-arg-info :kind :optional))
+		(setf (lambda-var-arg-info var)
+		      (make-arg-info :kind :optional))
 		(vars var)
 		(names-so-far spec))
 	      (let* ((name (first spec))
@@ -1620,7 +1618,7 @@
 
 	    (body
 	     `(when (oddp ,n-count)
-		(%odd-key-arguments-error)))
+		(%odd-key-args-error)))
 
 	    (body
 	     `(locally
@@ -1635,7 +1633,7 @@
 
 	    (unless allowp
 	      (body `(when (and ,n-losep (not ,n-allowp))
-		       (%unknown-key-argument-error ,n-losep)))))))
+		       (%unknown-key-arg-error ,n-losep)))))))
 
       (let ((ep (ir1-convert-lambda-body
 		 `((let ,(temps)