# HG changeset patch
# User Glenn Morris <rgm@gnu.org>
# Date 1288942485 25200
# Node ID 942097a71997ded32772a78e48b87fc52d91dfe8
# Parent  b8abad9fb36c5aa4dcfc663af3a4dcd65d714237
Silence cl-macs.el compilation.
* lisp/emacs-lisp/cl-macs.el (loop): Give local variable args a prefix.
(cl-parse-loop-clause, cl-loop-handle-accum): Update for above change.

diff -r b8abad9fb36c -r 942097a71997 lisp/ChangeLog
--- a/lisp/ChangeLog	Fri Nov 05 00:32:16 2010 -0700
+++ b/lisp/ChangeLog	Fri Nov 05 00:34:45 2010 -0700
@@ -1,5 +1,8 @@
 2010-11-05  Glenn Morris  <rgm@gnu.org>
 
+	* emacs-lisp/cl-macs.el (loop): Give local variable args a prefix.
+	(cl-parse-loop-clause, cl-loop-handle-accum): Update for above change.
+
 	* emacs-lisp/byte-opt.el (byte-decompile-bytecode-1): Give local
 	variables bytes, ptr, op a prefix.
 	(disassemble-offset): Update for above change.
diff -r b8abad9fb36c -r 942097a71997 lisp/emacs-lisp/cl-macs.el
--- a/lisp/emacs-lisp/cl-macs.el	Fri Nov 05 00:32:16 2010 -0700
+++ b/lisp/emacs-lisp/cl-macs.el	Fri Nov 05 00:34:45 2010 -0700
@@ -639,7 +639,7 @@
 
 ;;; The "loop" macro.
 
-(defvar args) (defvar loop-accum-var) (defvar loop-accum-vars)
+(defvar loop-args) (defvar loop-accum-var) (defvar loop-accum-vars)
 (defvar loop-bindings) (defvar loop-body) (defvar loop-destr-temps)
 (defvar loop-finally) (defvar loop-finish-flag) (defvar loop-first-flag)
 (defvar loop-initially) (defvar loop-map-form) (defvar loop-name)
@@ -647,7 +647,7 @@
 (defvar loop-result-var) (defvar loop-steps) (defvar loop-symbol-macs)
 
 ;;;###autoload
-(defmacro loop (&rest args)
+(defmacro loop (&rest loop-args)
   "The Common Lisp `loop' macro.
 Valid clauses are:
   for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
@@ -662,8 +662,8 @@
   finally return EXPR, named NAME.
 
 \(fn CLAUSE...)"
-  (if (not (memq t (mapcar 'symbolp (delq nil (delq t (copy-list args))))))
-      (list 'block nil (list* 'while t args))
+  (if (not (memq t (mapcar 'symbolp (delq nil (delq t (copy-list loop-args))))))
+      (list 'block nil (list* 'while t loop-args))
     (let ((loop-name nil)	(loop-bindings nil)
 	  (loop-body nil)	(loop-steps nil)
 	  (loop-result nil)	(loop-result-explicit nil)
@@ -672,8 +672,8 @@
 	  (loop-initially nil)	(loop-finally nil)
 	  (loop-map-form nil)   (loop-first-flag nil)
 	  (loop-destr-temps nil) (loop-symbol-macs nil))
-      (setq args (append args '(cl-end-loop)))
-      (while (not (eq (car args) 'cl-end-loop)) (cl-parse-loop-clause))
+      (setq loop-args (append loop-args '(cl-end-loop)))
+      (while (not (eq (car loop-args) 'cl-end-loop)) (cl-parse-loop-clause))
       (if loop-finish-flag
 	  (push `((,loop-finish-flag t)) loop-bindings))
       (if loop-first-flag
@@ -713,34 +713,34 @@
 	    (setq body (list (list* 'symbol-macrolet loop-symbol-macs body))))
 	(list* 'block loop-name body)))))
 
-(defun cl-parse-loop-clause ()		; uses args, loop-*
-  (let ((word (pop args))
+(defun cl-parse-loop-clause ()		; uses loop-*
+  (let ((word (pop loop-args))
 	(hash-types '(hash-key hash-keys hash-value hash-values))
 	(key-types '(key-code key-codes key-seq key-seqs
 		     key-binding key-bindings)))
     (cond
 
-     ((null args)
+     ((null loop-args)
       (error "Malformed `loop' macro"))
 
      ((eq word 'named)
-      (setq loop-name (pop args)))
+      (setq loop-name (pop loop-args)))
 
      ((eq word 'initially)
-      (if (memq (car args) '(do doing)) (pop args))
-      (or (consp (car args)) (error "Syntax error on `initially' clause"))
-      (while (consp (car args))
-	(push (pop args) loop-initially)))
+      (if (memq (car loop-args) '(do doing)) (pop loop-args))
+      (or (consp (car loop-args)) (error "Syntax error on `initially' clause"))
+      (while (consp (car loop-args))
+	(push (pop loop-args) loop-initially)))
 
      ((eq word 'finally)
-      (if (eq (car args) 'return)
-	  (setq loop-result-explicit (or (cl-pop2 args) '(quote nil)))
-	(if (memq (car args) '(do doing)) (pop args))
-	(or (consp (car args)) (error "Syntax error on `finally' clause"))
-	(if (and (eq (caar args) 'return) (null loop-name))
-	    (setq loop-result-explicit (or (nth 1 (pop args)) '(quote nil)))
-	  (while (consp (car args))
-	    (push (pop args) loop-finally)))))
+      (if (eq (car loop-args) 'return)
+	  (setq loop-result-explicit (or (cl-pop2 loop-args) '(quote nil)))
+	(if (memq (car loop-args) '(do doing)) (pop loop-args))
+	(or (consp (car loop-args)) (error "Syntax error on `finally' clause"))
+	(if (and (eq (caar loop-args) 'return) (null loop-name))
+	    (setq loop-result-explicit (or (nth 1 (pop loop-args)) '(quote nil)))
+	  (while (consp (car loop-args))
+	    (push (pop loop-args) loop-finally)))))
 
      ((memq word '(for as))
       (let ((loop-for-bindings nil) (loop-for-sets nil) (loop-for-steps nil)
@@ -749,29 +749,29 @@
 	    ;; Use `gensym' rather than `make-symbol'.  It's important that
 	    ;; (not (eq (symbol-name var1) (symbol-name var2))) because
 	    ;; these vars get added to the cl-macro-environment.
-	    (let ((var (or (pop args) (gensym "--cl-var--"))))
-	      (setq word (pop args))
-	      (if (eq word 'being) (setq word (pop args)))
-	      (if (memq word '(the each)) (setq word (pop args)))
+	    (let ((var (or (pop loop-args) (gensym "--cl-var--"))))
+	      (setq word (pop loop-args))
+	      (if (eq word 'being) (setq word (pop loop-args)))
+	      (if (memq word '(the each)) (setq word (pop loop-args)))
 	      (if (memq word '(buffer buffers))
-		  (setq word 'in args (cons '(buffer-list) args)))
+		  (setq word 'in loop-args (cons '(buffer-list) loop-args)))
 	      (cond
 
 	       ((memq word '(from downfrom upfrom to downto upto
 			     above below by))
-		(push word args)
-		(if (memq (car args) '(downto above))
+		(push word loop-args)
+		(if (memq (car loop-args) '(downto above))
 		    (error "Must specify `from' value for downward loop"))
-		(let* ((down (or (eq (car args) 'downfrom)
-				 (memq (caddr args) '(downto above))))
-		       (excl (or (memq (car args) '(above below))
-				 (memq (caddr args) '(above below))))
-		       (start (and (memq (car args) '(from upfrom downfrom))
-				   (cl-pop2 args)))
-		       (end (and (memq (car args)
+		(let* ((down (or (eq (car loop-args) 'downfrom)
+				 (memq (caddr loop-args) '(downto above))))
+		       (excl (or (memq (car loop-args) '(above below))
+				 (memq (caddr loop-args) '(above below))))
+		       (start (and (memq (car loop-args) '(from upfrom downfrom))
+				   (cl-pop2 loop-args)))
+		       (end (and (memq (car loop-args)
 				       '(to upto downto above below))
-				 (cl-pop2 args)))
-		       (step (and (eq (car args) 'by) (cl-pop2 args)))
+				 (cl-pop2 loop-args)))
+		       (step (and (eq (car loop-args) 'by) (cl-pop2 loop-args)))
 		       (end-var (and (not (cl-const-expr-p end))
 				     (make-symbol "--cl-var--")))
 		       (step-var (and (not (cl-const-expr-p step))
@@ -794,7 +794,7 @@
 		(let* ((on (eq word 'on))
 		       (temp (if (and on (symbolp var))
 				 var (make-symbol "--cl-var--"))))
-		  (push (list temp (pop args)) loop-for-bindings)
+		  (push (list temp (pop loop-args)) loop-for-bindings)
 		  (push (list 'consp temp) loop-body)
 		  (if (eq word 'in-ref)
 		      (push (list var (list 'car temp)) loop-symbol-macs)
@@ -804,8 +804,8 @@
 			  (push (list var (if on temp (list 'car temp)))
 				loop-for-sets))))
 		  (push (list temp
-			      (if (eq (car args) 'by)
-				  (let ((step (cl-pop2 args)))
+			      (if (eq (car loop-args) 'by)
+				  (let ((step (cl-pop2 loop-args)))
 				    (if (and (memq (car-safe step)
 						   '(quote function
 							   function*))
@@ -816,10 +816,10 @@
 			loop-for-steps)))
 
 	       ((eq word '=)
-		(let* ((start (pop args))
-		       (then (if (eq (car args) 'then) (cl-pop2 args) start)))
+		(let* ((start (pop loop-args))
+		       (then (if (eq (car loop-args) 'then) (cl-pop2 loop-args) start)))
 		  (push (list var nil) loop-for-bindings)
-		  (if (or ands (eq (car args) 'and))
+		  (if (or ands (eq (car loop-args) 'and))
 		      (progn
 			(push `(,var
 				(if ,(or loop-first-flag
@@ -839,7 +839,7 @@
 	       ((memq word '(across across-ref))
 		(let ((temp-vec (make-symbol "--cl-vec--"))
 		      (temp-idx (make-symbol "--cl-idx--")))
-		  (push (list temp-vec (pop args)) loop-for-bindings)
+		  (push (list temp-vec (pop loop-args)) loop-for-bindings)
 		  (push (list temp-idx -1) loop-for-bindings)
 		  (push (list '< (list 'setq temp-idx (list '1+ temp-idx))
 			      (list 'length temp-vec)) loop-body)
@@ -851,15 +851,15 @@
 			  loop-for-sets))))
 
 	       ((memq word '(element elements))
-		(let ((ref (or (memq (car args) '(in-ref of-ref))
-			       (and (not (memq (car args) '(in of)))
+		(let ((ref (or (memq (car loop-args) '(in-ref of-ref))
+			       (and (not (memq (car loop-args) '(in of)))
 				    (error "Expected `of'"))))
-		      (seq (cl-pop2 args))
+		      (seq (cl-pop2 loop-args))
 		      (temp-seq (make-symbol "--cl-seq--"))
-		      (temp-idx (if (eq (car args) 'using)
-				    (if (and (= (length (cadr args)) 2)
-					     (eq (caadr args) 'index))
-					(cadr (cl-pop2 args))
+		      (temp-idx (if (eq (car loop-args) 'using)
+				    (if (and (= (length (cadr loop-args)) 2)
+					     (eq (caadr loop-args) 'index))
+					(cadr (cl-pop2 loop-args))
 				      (error "Bad `using' clause"))
 				  (make-symbol "--cl-idx--"))))
 		  (push (list temp-seq seq) loop-for-bindings)
@@ -885,13 +885,13 @@
 			loop-for-steps)))
 
 	       ((memq word hash-types)
-		(or (memq (car args) '(in of)) (error "Expected `of'"))
-		(let* ((table (cl-pop2 args))
-		       (other (if (eq (car args) 'using)
-				  (if (and (= (length (cadr args)) 2)
-					   (memq (caadr args) hash-types)
-					   (not (eq (caadr args) word)))
-				      (cadr (cl-pop2 args))
+		(or (memq (car loop-args) '(in of)) (error "Expected `of'"))
+		(let* ((table (cl-pop2 loop-args))
+		       (other (if (eq (car loop-args) 'using)
+				  (if (and (= (length (cadr loop-args)) 2)
+					   (memq (caadr loop-args) hash-types)
+					   (not (eq (caadr loop-args) word)))
+				      (cadr (cl-pop2 loop-args))
 				    (error "Bad `using' clause"))
 				(make-symbol "--cl-var--"))))
 		  (if (memq word '(hash-value hash-values))
@@ -901,16 +901,16 @@
 
 	       ((memq word '(symbol present-symbol external-symbol
 			     symbols present-symbols external-symbols))
-		(let ((ob (and (memq (car args) '(in of)) (cl-pop2 args))))
+		(let ((ob (and (memq (car loop-args) '(in of)) (cl-pop2 loop-args))))
 		  (setq loop-map-form
 			`(mapatoms (lambda (,var) . --cl-map) ,ob))))
 
 	       ((memq word '(overlay overlays extent extents))
 		(let ((buf nil) (from nil) (to nil))
-		  (while (memq (car args) '(in of from to))
-		    (cond ((eq (car args) 'from) (setq from (cl-pop2 args)))
-			  ((eq (car args) 'to) (setq to (cl-pop2 args)))
-			  (t (setq buf (cl-pop2 args)))))
+		  (while (memq (car loop-args) '(in of from to))
+		    (cond ((eq (car loop-args) 'from) (setq from (cl-pop2 loop-args)))
+			  ((eq (car loop-args) 'to) (setq to (cl-pop2 loop-args)))
+			  (t (setq buf (cl-pop2 loop-args)))))
 		  (setq loop-map-form
 			`(cl-map-extents
 			  (lambda (,var ,(make-symbol "--cl-var--"))
@@ -921,12 +921,12 @@
 		(let ((buf nil) (prop nil) (from nil) (to nil)
 		      (var1 (make-symbol "--cl-var1--"))
 		      (var2 (make-symbol "--cl-var2--")))
-		  (while (memq (car args) '(in of property from to))
-		    (cond ((eq (car args) 'from) (setq from (cl-pop2 args)))
-			  ((eq (car args) 'to) (setq to (cl-pop2 args)))
-			  ((eq (car args) 'property)
-			   (setq prop (cl-pop2 args)))
-			  (t (setq buf (cl-pop2 args)))))
+		  (while (memq (car loop-args) '(in of property from to))
+		    (cond ((eq (car loop-args) 'from) (setq from (cl-pop2 loop-args)))
+			  ((eq (car loop-args) 'to) (setq to (cl-pop2 loop-args)))
+			  ((eq (car loop-args) 'property)
+			   (setq prop (cl-pop2 loop-args)))
+			  (t (setq buf (cl-pop2 loop-args)))))
 		  (if (and (consp var) (symbolp (car var)) (symbolp (cdr var)))
 		      (setq var1 (car var) var2 (cdr var))
 		    (push (list var (list 'cons var1 var2)) loop-for-sets))
@@ -936,13 +936,13 @@
 			  ,buf ,prop ,from ,to))))
 
 	       ((memq word key-types)
-		(or (memq (car args) '(in of)) (error "Expected `of'"))
-		(let ((map (cl-pop2 args))
-		      (other (if (eq (car args) 'using)
-				 (if (and (= (length (cadr args)) 2)
-					  (memq (caadr args) key-types)
-					  (not (eq (caadr args) word)))
-				     (cadr (cl-pop2 args))
+		(or (memq (car loop-args) '(in of)) (error "Expected `of'"))
+		(let ((map (cl-pop2 loop-args))
+		      (other (if (eq (car loop-args) 'using)
+				 (if (and (= (length (cadr loop-args)) 2)
+					  (memq (caadr loop-args) key-types)
+					  (not (eq (caadr loop-args) word)))
+				     (cadr (cl-pop2 loop-args))
 				   (error "Bad `using' clause"))
 			       (make-symbol "--cl-var--"))))
 		  (if (memq word '(key-binding key-bindings))
@@ -964,7 +964,7 @@
 			loop-for-steps)))
 
 	       ((memq word '(window windows))
-		(let ((scr (and (memq (car args) '(in of)) (cl-pop2 args)))
+		(let ((scr (and (memq (car loop-args) '(in of)) (cl-pop2 loop-args)))
 		      (temp (make-symbol "--cl-var--")))
 		  (push (list var (if scr
 				      (list 'frame-selected-window scr)
@@ -982,9 +982,9 @@
 		  (if handler
 		      (funcall handler var)
 		    (error "Expected a `for' preposition, found %s" word)))))
-	      (eq (car args) 'and))
+	      (eq (car loop-args) 'and))
 	  (setq ands t)
-	  (pop args))
+	  (pop loop-args))
 	(if (and ands loop-for-bindings)
 	    (push (nreverse loop-for-bindings) loop-bindings)
 	  (setq loop-bindings (nconc (mapcar 'list loop-for-bindings)
@@ -1000,11 +1000,11 @@
 
      ((eq word 'repeat)
       (let ((temp (make-symbol "--cl-var--")))
-	(push (list (list temp (pop args))) loop-bindings)
+	(push (list (list temp (pop loop-args))) loop-bindings)
 	(push (list '>= (list 'setq temp (list '1- temp)) 0) loop-body)))
 
      ((memq word '(collect collecting))
-      (let ((what (pop args))
+      (let ((what (pop loop-args))
 	    (var (cl-loop-handle-accum nil 'nreverse)))
 	(if (eq var loop-accum-var)
 	    (push (list 'progn (list 'push what var) t) loop-body)
@@ -1013,7 +1013,7 @@
 		      t) loop-body))))
 
      ((memq word '(nconc nconcing append appending))
-      (let ((what (pop args))
+      (let ((what (pop loop-args))
 	    (var (cl-loop-handle-accum nil 'nreverse)))
 	(push (list 'progn
 		    (list 'setq var
@@ -1028,27 +1028,27 @@
 				  var what))) t) loop-body)))
 
      ((memq word '(concat concating))
-      (let ((what (pop args))
+      (let ((what (pop loop-args))
 	    (var (cl-loop-handle-accum "")))
 	(push (list 'progn (list 'callf 'concat var what) t) loop-body)))
 
      ((memq word '(vconcat vconcating))
-      (let ((what (pop args))
+      (let ((what (pop loop-args))
 	    (var (cl-loop-handle-accum [])))
 	(push (list 'progn (list 'callf 'vconcat var what) t) loop-body)))
 
      ((memq word '(sum summing))
-      (let ((what (pop args))
+      (let ((what (pop loop-args))
 	    (var (cl-loop-handle-accum 0)))
 	(push (list 'progn (list 'incf var what) t) loop-body)))
 
      ((memq word '(count counting))
-      (let ((what (pop args))
+      (let ((what (pop loop-args))
 	    (var (cl-loop-handle-accum 0)))
 	(push (list 'progn (list 'if what (list 'incf var)) t) loop-body)))
 
      ((memq word '(minimize minimizing maximize maximizing))
-      (let* ((what (pop args))
+      (let* ((what (pop loop-args))
 	     (temp (if (cl-simple-expr-p what) what (make-symbol "--cl-var--")))
 	     (var (cl-loop-handle-accum nil))
 	     (func (intern (substring (symbol-name word) 0 3)))
@@ -1059,27 +1059,27 @@
 
      ((eq word 'with)
       (let ((bindings nil))
-	(while (progn (push (list (pop args)
-				  (and (eq (car args) '=) (cl-pop2 args)))
+	(while (progn (push (list (pop loop-args)
+				  (and (eq (car loop-args) '=) (cl-pop2 loop-args)))
 			    bindings)
-		      (eq (car args) 'and))
-	  (pop args))
+		      (eq (car loop-args) 'and))
+	  (pop loop-args))
 	(push (nreverse bindings) loop-bindings)))
 
      ((eq word 'while)
-      (push (pop args) loop-body))
+      (push (pop loop-args) loop-body))
 
      ((eq word 'until)
-      (push (list 'not (pop args)) loop-body))
+      (push (list 'not (pop loop-args)) loop-body))
 
      ((eq word 'always)
       (or loop-finish-flag (setq loop-finish-flag (make-symbol "--cl-flag--")))
-      (push (list 'setq loop-finish-flag (pop args)) loop-body)
+      (push (list 'setq loop-finish-flag (pop loop-args)) loop-body)
       (setq loop-result t))
 
      ((eq word 'never)
       (or loop-finish-flag (setq loop-finish-flag (make-symbol "--cl-flag--")))
-      (push (list 'setq loop-finish-flag (list 'not (pop args)))
+      (push (list 'setq loop-finish-flag (list 'not (pop loop-args)))
 	    loop-body)
       (setq loop-result t))
 
@@ -1087,20 +1087,20 @@
       (or loop-finish-flag (setq loop-finish-flag (make-symbol "--cl-flag--")))
       (or loop-result-var (setq loop-result-var (make-symbol "--cl-var--")))
       (push (list 'setq loop-finish-flag
-		  (list 'not (list 'setq loop-result-var (pop args))))
+		  (list 'not (list 'setq loop-result-var (pop loop-args))))
 	    loop-body))
 
      ((memq word '(if when unless))
-      (let* ((cond (pop args))
+      (let* ((cond (pop loop-args))
 	     (then (let ((loop-body nil))
 		     (cl-parse-loop-clause)
 		     (cl-loop-build-ands (nreverse loop-body))))
 	     (else (let ((loop-body nil))
-		     (if (eq (car args) 'else)
-			 (progn (pop args) (cl-parse-loop-clause)))
+		     (if (eq (car loop-args) 'else)
+			 (progn (pop loop-args) (cl-parse-loop-clause)))
 		     (cl-loop-build-ands (nreverse loop-body))))
 	     (simple (and (eq (car then) t) (eq (car else) t))))
-	(if (eq (car args) 'end) (pop args))
+	(if (eq (car loop-args) 'end) (pop loop-args))
 	(if (eq word 'unless) (setq then (prog1 else (setq else then))))
 	(let ((form (cons (if simple (cons 'progn (nth 1 then)) (nth 2 then))
 			  (if simple (nth 1 else) (list (nth 2 else))))))
@@ -1114,22 +1114,22 @@
 
      ((memq word '(do doing))
       (let ((body nil))
-	(or (consp (car args)) (error "Syntax error on `do' clause"))
-	(while (consp (car args)) (push (pop args) body))
+	(or (consp (car loop-args)) (error "Syntax error on `do' clause"))
+	(while (consp (car loop-args)) (push (pop loop-args) body))
 	(push (cons 'progn (nreverse (cons t body))) loop-body)))
 
      ((eq word 'return)
       (or loop-finish-flag (setq loop-finish-flag (make-symbol "--cl-var--")))
       (or loop-result-var (setq loop-result-var (make-symbol "--cl-var--")))
-      (push (list 'setq loop-result-var (pop args)
+      (push (list 'setq loop-result-var (pop loop-args)
 		  loop-finish-flag nil) loop-body))
 
      (t
       (let ((handler (and (symbolp word) (get word 'cl-loop-handler))))
 	(or handler (error "Expected a loop keyword, found %s" word))
 	(funcall handler))))
-    (if (eq (car args) 'and)
-	(progn (pop args) (cl-parse-loop-clause)))))
+    (if (eq (car loop-args) 'and)
+	(progn (pop loop-args) (cl-parse-loop-clause)))))
 
 (defun cl-loop-let (specs body par)   ; uses loop-*
   (let ((p specs) (temps nil) (new nil))
@@ -1165,9 +1165,9 @@
       (list* (if par 'let 'let*)
 	     (nconc (nreverse temps) (nreverse new)) body))))
 
-(defun cl-loop-handle-accum (def &optional func)   ; uses args, loop-*
-  (if (eq (car args) 'into)
-      (let ((var (cl-pop2 args)))
+(defun cl-loop-handle-accum (def &optional func)   ; uses loop-*
+  (if (eq (car loop-args) 'into)
+      (let ((var (cl-pop2 loop-args)))
 	(or (memq var loop-accum-vars)
 	    (progn (push (list (list var def)) loop-bindings)
 		   (push var loop-accum-vars)))
@@ -2791,5 +2791,4 @@
 ;; generated-autoload-file: "cl-loaddefs.el"
 ;; End:
 
-;; arch-tag: afd947a6-b553-4df1-bba5-000be6388f46
 ;;; cl-macs.el ends here