X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fmeta-vmdef.lisp;h=db70bbe13158dc3a989bc081ef0a432291e0b98d;hb=ed7ba4dad8a79726fdfeba5aa12e276ea852c540;hp=4979d4ba7464901991096d54454c9efb61d0298b;hpb=1bfc464c657a8f4ad24ef612f76a38d8f6f1bbad;p=sbcl.git

diff --git a/src/compiler/meta-vmdef.lisp b/src/compiler/meta-vmdef.lisp
index 4979d4b..db70bbe 100644
--- a/src/compiler/meta-vmdef.lisp
+++ b/src/compiler/meta-vmdef.lisp
@@ -153,8 +153,8 @@
 	 (if (or (eq sb-name 'non-descriptor-stack)
 		 (find 'non-descriptor-stack
 		       (mapcar #'meta-sc-or-lose alternate-scs)
-		       :key #'(lambda (x)
-				(sb-name (sc-sb x)))))
+		       :key (lambda (x)
+			      (sb-name (sc-sb x)))))
 	     t nil)))
     `(progn
        (eval-when (:compile-toplevel :load-toplevel :execute)
@@ -331,15 +331,15 @@
 	(n-type (gensym)))
     `(let ((,n-vop (template-or-lose ',vop)))
        ,@(mapcar
-	  #'(lambda (type)
-	      `(let ((,n-type (primitive-type-or-lose ',type)))
-		 ,@(mapcar
-		    #'(lambda (kind)
-			(let ((slot (or (cdr (assoc kind
-						    *primitive-type-slot-alist*))
-					(error "unknown kind: ~S" kind))))
-			  `(setf (,slot ,n-type) ,n-vop)))
-		    kinds)))
+	  (lambda (type)
+	    `(let ((,n-type (primitive-type-or-lose ',type)))
+	       ,@(mapcar
+		  (lambda (kind)
+		    (let ((slot (or (cdr (assoc kind
+						*primitive-type-slot-alist*))
+				    (error "unknown kind: ~S" kind))))
+		      `(setf (,slot ,n-type) ,n-vop)))
+		  kinds)))
 	  types)
        nil)))
 
@@ -665,14 +665,14 @@
 	     (refs (cons (cons born t) index))))
 	  (incf index)))
       (let* ((sorted (sort (refs)
-			   #'(lambda (x y)
-			       (let ((x-time (car x))
-				     (y-time (car y)))
-				 (if (time-spec-order x-time y-time)
-				     (if (time-spec-order y-time x-time)
-					 (and (not (cdr x)) (cdr y))
-					 nil)
-				     t)))
+			   (lambda (x y)
+			     (let ((x-time (car x))
+				   (y-time (car y)))
+			       (if (time-spec-order x-time y-time)
+				   (if (time-spec-order y-time x-time)
+				       (and (not (cdr x)) (cdr y))
+				       nil)
+				   t)))
 			   :key #'car))
 	     (oe-type '(mod #.max-vop-tn-refs)) ; :REF-ORDERING element type
 	     (te-type '(mod #.(* max-vop-tn-refs 2))) ; :TARGETS element type
@@ -774,13 +774,13 @@
 			  (setf (vop-parse-vop-var parse) (gensym))))
 	       (form (if (rest funs)
 			 `(sc-case ,tn
-			    ,@(mapcar #'(lambda (x)
-					  `(,(mapcar #'sc-name (car x))
-					    ,(if load-p
-						 `(,(cdr x) ,n-vop ,tn
-						   ,load-tn)
-						 `(,(cdr x) ,n-vop ,load-tn
-						   ,tn))))
+			    ,@(mapcar (lambda (x)
+					`(,(mapcar #'sc-name (car x))
+					  ,(if load-p
+					       `(,(cdr x) ,n-vop ,tn
+						 ,load-tn)
+					       `(,(cdr x) ,n-vop ,load-tn
+						 ,tn))))
 				      funs))
 			 (if load-p
 			     `(,(cdr (first funs)) ,n-vop ,tn ,load-tn)
@@ -845,10 +845,10 @@
 		    (tn-ref-tn ,(operand-parse-temp op)))))
 	  ((:more-argument :more-result))))
 
-      `#'(lambda (,n-vop)
-	   (let* (,@(access-operands (vop-parse-args parse)
-				     (vop-parse-more-args parse)
-				     `(vop-args ,n-vop))
+      `(lambda (,n-vop)
+	 (let* (,@(access-operands (vop-parse-args parse)
+				   (vop-parse-more-args parse)
+				   `(vop-args ,n-vop))
 		  ,@(access-operands (vop-parse-results parse)
 				     (vop-parse-more-results parse)
 				     `(vop-results ,n-vop))
@@ -856,20 +856,20 @@
 				     `(vop-temps ,n-vop))
 		  ,@(when (vop-parse-info-args parse)
 		      `((,n-info (vop-codegen-info ,n-vop))
-			,@(mapcar #'(lambda (x) `(,x (pop ,n-info)))
+			,@(mapcar (lambda (x) `(,x (pop ,n-info)))
 				  (vop-parse-info-args parse))))
 		  ,@(when (vop-parse-variant-vars parse)
 		      `((,n-variant (vop-info-variant (vop-info ,n-vop)))
-			,@(mapcar #'(lambda (x) `(,x (pop ,n-variant)))
+			,@(mapcar (lambda (x) `(,x (pop ,n-variant)))
 				  (vop-parse-variant-vars parse))))
 		  ,@(when (vop-parse-node-var parse)
 		      `((,(vop-parse-node-var parse) (vop-node ,n-vop))))
 		  ,@(binds))
-	     (declare (ignore ,@(vop-parse-ignores parse)))
-	     ,@(loads)
-	     (sb!assem:assemble (*code-segment* ,n-vop)
-	       ,@(vop-parse-body parse))
-	     ,@(saves))))))
+	   (declare (ignore ,@(vop-parse-ignores parse)))
+	   ,@(loads)
+	   (sb!assem:assemble (*code-segment* ,n-vop)
+			      ,@(vop-parse-body parse))
+	   ,@(saves))))))
 
 ;;; Given a list of operand specifications as given to DEFINE-VOP,
 ;;; return a list of OPERAND-PARSE structures describing the fixed
@@ -1304,9 +1304,9 @@
 	   (type (or operand-parse null) more-op))
   (unless (eq types :unspecified)
     (let ((num (+ (length ops) (if more-op 1 0))))
-      (unless (= (count-if-not #'(lambda (x)
-				   (and (consp x)
-					(eq (car x) :constant)))
+      (unless (= (count-if-not (lambda (x)
+				 (and (consp x)
+				      (eq (car x) :constant)))
 			       types)
 		 num)
 	(error "expected ~W ~:[result~;argument~] type~P: ~S"
@@ -1319,12 +1319,12 @@
 
   (when (vop-parse-translate parse)
     (let ((types (specify-operand-types types ops more-op)))
-      (mapc #'(lambda (x y)
-		(check-operand-type-scs parse x y load-p))
+      (mapc (lambda (x y)
+	      (check-operand-type-scs parse x y load-p))
 	    (if more-op (butlast ops) ops)
-	    (remove-if #'(lambda (x)
-			   (and (consp x)
-				(eq (car x) ':constant)))
+	    (remove-if (lambda (x)
+			 (and (consp x)
+			      (eq (car x) ':constant)))
 		       (if more-op (butlast types) types)))))
 
   (values))
@@ -1366,16 +1366,16 @@
 ;;; to the translated is always used in a predicate position.
 (defun set-up-function-translation (parse n-template)
   (declare (type vop-parse parse))
-  (mapcar #'(lambda (name)
-	      `(let ((info (function-info-or-lose ',name)))
-		 (setf (function-info-templates info)
-		       (adjoin-template ,n-template
-					(function-info-templates info)))
-		 ,@(when (vop-parse-conditional-p parse)
-		     '((setf (function-info-attributes info)
-			     (attributes-union
-			      (ir1-attributes predicate)
-			      (function-info-attributes info)))))))
+  (mapcar (lambda (name)
+	    `(let ((info (function-info-or-lose ',name)))
+	       (setf (function-info-templates info)
+		     (adjoin-template ,n-template
+				      (function-info-templates info)))
+	       ,@(when (vop-parse-conditional-p parse)
+		   '((setf (function-info-attributes info)
+			   (attributes-union
+			    (ir1-attributes predicate)
+			    (function-info-attributes info)))))))
 	  (vop-parse-translate parse)))
 
 ;;; Return a form that can be evaluated to get the TEMPLATE operand type
@@ -1387,9 +1387,9 @@
 	(t
 	 (ecase (first type)
 	   (:or
-	    ``(:or ,,@(mapcar #'(lambda (type)
-				   `(primitive-type-or-lose ',type))
-			       (rest type))))
+	    ``(:or ,,@(mapcar (lambda (type)
+				`(primitive-type-or-lose ',type))
+			      (rest type))))
 	   (:constant
 	    ``(:constant ,#'(lambda (x)
 			      (typep x ',(second type)))
@@ -1468,7 +1468,7 @@
       :name ',(vop-parse-name parse)
       ,@(make-vop-info-types parse)
       :guard ,(when (vop-parse-guard parse)
-		`#'(lambda () ,(vop-parse-guard parse)))
+		`(lambda () ,(vop-parse-guard parse)))
       :note ',(vop-parse-note parse)
       :info-arg-count ,(length (vop-parse-info-args parse))
       :ltn-policy ',(vop-parse-ltn-policy parse)
@@ -1856,9 +1856,9 @@
 		(error "T case is not last in SC-Case."))
 	      (clauses `(t nil ,@(rest case)))
 	      (return))
-	    (clauses `((or ,@(mapcar #'(lambda (x)
-					 `(eql ,(meta-sc-number-or-lose x)
-					       ,n-sc))
+	    (clauses `((or ,@(mapcar (lambda (x)
+				       `(eql ,(meta-sc-number-or-lose x)
+					     ,n-sc))
 				     (if (atom head) (list head) head)))
 		       nil ,@(rest case))))))
 
@@ -1869,8 +1869,8 @@
 ;;; Return true if TNs SC is any of the named SCs, false otherwise.
 (defmacro sc-is (tn &rest scs)
   (once-only ((n-sc `(sc-number (tn-sc ,tn))))
-    `(or ,@(mapcar #'(lambda (x)
-		       `(eql ,n-sc ,(meta-sc-number-or-lose x)))
+    `(or ,@(mapcar (lambda (x)
+		     `(eql ,n-sc ,(meta-sc-number-or-lose x)))
 		   scs))))
 
 ;;; Iterate over the IR2 blocks in component, in emission order.