procyberian/emacs
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Silence cl-macs.el compilation.

Browse source 
* 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.
This commit is contained in:
Glenn Morris 2010-11-05 00:34:45 -07:00
parent 17fc58c923
commit 215461a8d3
2 changed files with 112 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

219
lisp/emacs-lisp/cl-macs.el
View file

@ -639,7 +639,7 @@ This is compatible with Common Lisp, but note that `defun' and
;;; 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 @@ This is compatible with Common Lisp, but note that `defun' and
(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 @@ Valid clauses are:
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 @@ Valid clauses are:
(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 @@ Valid clauses are:
(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 @@ Valid clauses are:
;; 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 @@ Valid clauses are:
(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 @@ Valid clauses are:
(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 @@ Valid clauses are:
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 @@ Valid clauses are:
((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 @@ Valid clauses are:
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 @@ Valid clauses are:
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 @@ Valid clauses are:
((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 @@ Valid clauses are:
(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 @@ Valid clauses are:
,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 @@ Valid clauses are:
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 @@ Valid clauses are:
(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 @@ Valid clauses are:
((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 @@ Valid clauses are:
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 @@ Valid clauses are:
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 @@ Valid clauses are:
((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 @@ Valid clauses are:
(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 @@ Valid clauses are:
((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 @@ Valid clauses are:
(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 @@ surrounded by (block NAME ...).
;; generated-autoload-file: "cl-loaddefs.el"
;; End:
;; arch-tag: afd947a6-b553-4df1-bba5-000be6388f46
;;; cl-macs.el ends here