Name:
Anonymous
2007-10-27 17:11
Maintain this:
(defmacro loop (&rest args)
"(loop CLAUSE...): The Common Lisp `loop' macro.
Valid clauses are:
for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
always COND, never COND, thereis COND, collect EXPR into VAR,
append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
finally return EXPR, named NAME."
(if (not (memq t (mapcar 'symbolp (delq nil (delq t (copy-list args))))))
(list 'block nil (list* 'while t args))
(let ((loop-name nil) (loop-bindings nil)
(loop-body nil) (loop-steps nil)
(loop-result nil) (loop-result-explicit nil)
(loop-result-var nil) (loop-finish-flag nil)
(loop-accum-var nil) (loop-accum-vars nil)
(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))
(if loop-finish-flag
(cl-push (list (list loop-finish-flag t)) loop-bindings))
(if loop-first-flag
(progn (cl-push (list (list loop-first-flag t)) loop-bindings)
(cl-push (list 'setq loop-first-flag nil) loop-steps)))
(let* ((epilogue (nconc (nreverse loop-finally)
(list (or loop-result-explicit loop-result))))
(ands (cl-loop-build-ands (nreverse loop-body)))
(while-body (nconc (cadr ands) (nreverse loop-steps)))
(body (append
(nreverse loop-initially)
(list (if loop-map-form
(list 'block '--cl-finish--
(subst
(if (eq (car ands) t) while-body
(cons (list 'or (car ands)
'(return-from --cl-finish--
nil))
while-body))
'--cl-map loop-map-form))
(list* 'while (car ands) while-body)))
(if loop-finish-flag
(if (equal epilogue '(nil)) (list loop-result-var)
(list (list 'if loop-finish-flag
(cons 'progn epilogue) loop-result-var)))
epilogue))))
(if loop-result-var (cl-push (list loop-result-var) loop-bindings))
(while loop-bindings
(if (cdar loop-bindings)
(setq body (list (cl-loop-let (cl-pop loop-bindings) body t)))
(let ((lets nil))
(while (and loop-bindings
(not (cdar loop-bindings)))
(cl-push (car (cl-pop loop-bindings)) lets))
(setq body (list (cl-loop-let lets body nil))))))
(if loop-symbol-macs
(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 (cl-pop 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)
(error "Malformed `loop' macro"))
((eq word 'named)
(setq loop-name (cl-pop args)))
((eq word 'initially)
(if (memq (car args) '(do doing)) (cl-pop args))
(or (consp (car args)) (error "Syntax error on `initially' clause"))
(while (consp (car args))
(cl-push (cl-pop 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)) (cl-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 (cl-pop args)) '(quote nil)))
(while (consp (car args))
(cl-push (cl-pop args) loop-finally)))))
((memq word '(for as))
(let ((loop-for-bindings nil) (loop-for-sets nil) (loop-for-steps nil)
(ands nil))
(while
(let ((var (or (cl-pop args) (gensym))))
(setq word (cl-pop args))
(if (eq word 'being) (setq word (cl-pop args)))
(if (memq word '(the each)) (setq word (cl-pop args)))
(if (memq word '(buffer buffers))
(setq word 'in args (cons '(buffer-list) args)))
(cond
((memq word '(from downfrom upfrom to downto upto
above below by))
(cl-push word args)
(if (memq (car 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)
'(to upto downto above below))
(cl-pop2 args)))
(step (and (eq (car args) 'by) (cl-pop2 args)))
(end-var (and (not (cl-const-expr-p end)) (gensym)))
(step-var (and (not (cl-const-expr-p step))
(gensym))))
(and step (numberp step) (<= step 0)
(error "Loop `by' value is not positive: %s" step))
(cl-push (list var (or start 0)) loop-for-bindings)
(if end-var (cl-push (list end-var end) loop-for-bindings))
(if step-var (cl-push (list step-var step)
loop-for-bindings))
(if end
(cl-push (list
(if down (if excl '> '>=) (if excl '< '<=))
var (or end-var end)) loop-body))
(cl-push (list var (list (if down '- '+) var
(or step-var step 1)))
loop-for-steps)))
Name:
Anonymous
2007-10-27 17:12
((memq word '(in in-ref on))
(let* ((on (eq word 'on))
(temp (if (and on (symbolp var)) var (gensym))))
(cl-push (list temp (cl-pop args)) loop-for-bindings)
(cl-push (list 'consp temp) loop-body)
(if (eq word 'in-ref)
(cl-push (list var (list 'car temp)) loop-symbol-macs)
(or (eq temp var)
(progn
(cl-push (list var nil) loop-for-bindings)
(cl-push (list var (if on temp (list 'car temp)))
loop-for-sets))))
(cl-push (list temp
(if (eq (car args) 'by)
(let ((step (cl-pop2 args)))
(if (and (memq (car-safe step)
'(quote function
function*))
(symbolp (nth 1 step)))
(list (nth 1 step) temp)
(list 'funcall step temp)))
(list 'cdr temp)))
loop-for-steps)))
((eq word '=)
(let* ((start (cl-pop args))
(then (if (eq (car args) 'then) (cl-pop2 args) start)))
(cl-push (list var nil) loop-for-bindings)
(if (or ands (eq (car args) 'and))
(progn
(cl-push (list var
(list 'if
(or loop-first-flag
(setq loop-first-flag
(gensym)))
start var))
loop-for-sets)
(cl-push (list var then) loop-for-steps))
(cl-push (list var
(if (eq start then) start
(list 'if
(or loop-first-flag
(setq loop-first-flag (gensym)))
start then)))
loop-for-sets))))
((memq word '(across across-ref))
(let ((temp-vec (gensym)) (temp-idx (gensym)))
(cl-push (list temp-vec (cl-pop args)) loop-for-bindings)
(cl-push (list temp-idx -1) loop-for-bindings)
(cl-push (list '< (list 'setq temp-idx (list '1+ temp-idx))
(list 'length temp-vec)) loop-body)
(if (eq word 'across-ref)
(cl-push (list var (list 'aref temp-vec temp-idx))
loop-symbol-macs)
(cl-push (list var nil) loop-for-bindings)
(cl-push (list var (list 'aref temp-vec temp-idx))
loop-for-sets))))
((memq word '(element elements))
(let ((ref (or (memq (car args) '(in-ref of-ref))
(and (not (memq (car args) '(in of)))
(error "Expected `of'"))))
(seq (cl-pop2 args))
(temp-seq (gensym))
(temp-idx (if (eq (car args) 'using)
(if (and (= (length (cadr args)) 2)
(eq (caadr args) 'index))
(cadr (cl-pop2 args))
(error "Bad `using' clause"))
(gensym))))
(cl-push (list temp-seq seq) loop-for-bindings)
(cl-push (list temp-idx 0) loop-for-bindings)
(if ref
(let ((temp-len (gensym)))
(cl-push (list temp-len (list 'length temp-seq))
loop-for-bindings)
(cl-push (list var (list 'elt temp-seq temp-idx))
loop-symbol-macs)
(cl-push (list '< temp-idx temp-len) loop-body))
(cl-push (list var nil) loop-for-bindings)
(cl-push (list 'and temp-seq
(list 'or (list 'consp temp-seq)
(list '< temp-idx
(list 'length temp-seq))))
loop-body)
(cl-push (list var (list 'if (list 'consp temp-seq)
(list 'pop temp-seq)
(list 'aref temp-seq temp-idx)))
loop-for-sets))
(cl-push (list temp-idx (list '1+ temp-idx))
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))
(error "Bad `using' clause"))
(gensym))))
(if (memq word '(hash-value hash-values))
(setq var (prog1 other (setq other var))))
(setq loop-map-form
(list 'maphash (list 'function
(list* 'lambda (list var other)
'--cl-map)) table))))
((memq word '(symbol present-symbol external-symbol
symbols present-symbols external-symbols))
(let ((ob (and (memq (car args) '(in of)) (cl-pop2 args))))
(setq loop-map-form
(list 'mapatoms (list 'function
(list* 'lambda (list 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)))))
(setq loop-map-form
(list 'cl-map-extents
(list 'function (list 'lambda (list var (gensym))
'(progn . --cl-map) nil))
buf from to))))
((memq word '(interval intervals))
(let ((buf nil) (prop nil) (from nil) (to nil)
(var1 (gensym)) (var2 (gensym)))
(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)))))
(if (and (consp var) (symbolp (car var)) (symbolp (cdr var)))
(setq var1 (car var) var2 (cdr var))
(cl-push (list var (list 'cons var1 var2)) loop-for-sets))
(setq loop-map-form
(list 'cl-map-intervals
(list 'function (list 'lambda (list var1 var2)
'(progn . --cl-map)))
buf prop from to))))
Name:
Anonymous
2007-10-27 17:12
((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))
(error "Bad `using' clause"))
(gensym))))
(if (memq word '(key-binding key-bindings))
(setq var (prog1 other (setq other var))))
(setq loop-map-form
(list (if (memq word '(key-seq key-seqs))
'cl-map-keymap-recursively 'cl-map-keymap)
(list 'function (list* 'lambda (list var other)
'--cl-map)) map))))
((memq word '(frame frames screen screens))
(let ((temp (gensym)))
(cl-push (list var (if (eq cl-emacs-type 'lucid)
'(selected-screen) '(selected-frame)))
loop-for-bindings)
(cl-push (list temp nil) loop-for-bindings)
(cl-push (list 'prog1 (list 'not (list 'eq var temp))
(list 'or temp (list 'setq temp var)))
loop-body)
(cl-push (list var (list (if (eq cl-emacs-type 'lucid)
'next-screen 'next-frame) var))
loop-for-steps)))
((memq word '(window windows))
(let ((scr (and (memq (car args) '(in of)) (cl-pop2 args)))
(temp (gensym)))
(cl-push (list var (if scr
(list (if (eq cl-emacs-type 'lucid)
'screen-selected-window
'frame-selected-window) scr)
'(selected-window)))
loop-for-bindings)
(cl-push (list temp nil) loop-for-bindings)
(cl-push (list 'prog1 (list 'not (list 'eq var temp))
(list 'or temp (list 'setq temp var)))
loop-body)
(cl-push (list var (list 'next-window var)) loop-for-steps)))
(t
(let ((handler (and (symbolp word)
(get word 'cl-loop-for-handler))))
(if handler
(funcall handler var)
(error "Expected a `for' preposition, found %s" word)))))
(eq (car args) 'and))
(setq ands t)
(cl-pop args))
(if (and ands loop-for-bindings)
(cl-push (nreverse loop-for-bindings) loop-bindings)
(setq loop-bindings (nconc (mapcar 'list loop-for-bindings)
loop-bindings)))
(if loop-for-sets
(cl-push (list 'progn
(cl-loop-let (nreverse loop-for-sets) 'setq ands)
t) loop-body))
(if loop-for-steps
(cl-push (cons (if ands 'psetq 'setq)
(apply 'append (nreverse loop-for-steps)))
loop-steps))))
((eq word 'repeat)
(let ((temp (gensym)))
(cl-push (list (list temp (cl-pop args))) loop-bindings)
(cl-push (list '>= (list 'setq temp (list '1- temp)) 0) loop-body)))
((eq word 'collect)
(let ((what (cl-pop args))
(var (cl-loop-handle-accum nil 'nreverse)))
(if (eq var loop-accum-var)
(cl-push (list 'progn (list 'push what var) t) loop-body)
(cl-push (list 'progn
(list 'setq var (list 'nconc var (list 'list what)))
t) loop-body))))
((memq word '(nconc nconcing append appending))
(let ((what (cl-pop args))
(var (cl-loop-handle-accum nil 'nreverse)))
(cl-push (list 'progn
(list 'setq var
(if (eq var loop-accum-var)
(list 'nconc
(list (if (memq word '(nconc nconcing))
'nreverse 'reverse)
what)
var)
(list (if (memq word '(nconc nconcing))
'nconc 'append)
var what))) t) loop-body)))
Name:
Anonymous
2007-10-27 17:13
((memq word '(concat concating))
(let ((what (cl-pop args))
(var (cl-loop-handle-accum "")))
(cl-push (list 'progn (list 'callf 'concat var what) t) loop-body)))
((memq word '(vconcat vconcating))
(let ((what (cl-pop args))
(var (cl-loop-handle-accum [])))
(cl-push (list 'progn (list 'callf 'vconcat var what) t) loop-body)))
((memq word '(sum summing))
(let ((what (cl-pop args))
(var (cl-loop-handle-accum 0)))
(cl-push (list 'progn (list 'incf var what) t) loop-body)))
((memq word '(count counting))
(let ((what (cl-pop args))
(var (cl-loop-handle-accum 0)))
(cl-push (list 'progn (list 'if what (list 'incf var)) t) loop-body)))
((memq word '(minimize minimizing maximize maximizing))
(let* ((what (cl-pop args))
(temp (if (cl-simple-expr-p what) what (gensym)))
(var (cl-loop-handle-accum nil))
(func (intern (substring (symbol-name word) 0 3)))
(set (list 'setq var (list 'if var (list func var temp) temp))))
(cl-push (list 'progn (if (eq temp what) set
(list 'let (list (list temp what)) set))
t) loop-body)))
((eq word 'with)
(let ((bindings nil))
(while (progn (cl-push (list (cl-pop args)
(and (eq (car args) '=) (cl-pop2 args)))
bindings)
(eq (car args) 'and))
(cl-pop args))
(cl-push (nreverse bindings) loop-bindings)))
((eq word 'while)
(cl-push (cl-pop args) loop-body))
((eq word 'until)
(cl-push (list 'not (cl-pop args)) loop-body))
((eq word 'always)
(or loop-finish-flag (setq loop-finish-flag (gensym)))
(cl-push (list 'setq loop-finish-flag (cl-pop args)) loop-body)
(setq loop-result t))
((eq word 'never)
(or loop-finish-flag (setq loop-finish-flag (gensym)))
(cl-push (list 'setq loop-finish-flag (list 'not (cl-pop args)))
loop-body)
(setq loop-result t))
((eq word 'thereis)
(or loop-finish-flag (setq loop-finish-flag (gensym)))
(or loop-result-var (setq loop-result-var (gensym)))
(cl-push (list 'setq loop-finish-flag
(list 'not (list 'setq loop-result-var (cl-pop args))))
loop-body))
((memq word '(if when unless))
(let* ((cond (cl-pop 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 (cl-pop 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) (cl-pop 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))))))
(if (cl-expr-contains form 'it)
(let ((temp (gensym)))
(cl-push (list temp) loop-bindings)
(setq form (list* 'if (list 'setq temp cond)
(subst temp 'it form))))
(setq form (list* 'if cond form)))
(cl-push (if simple (list 'progn form t) form) loop-body))))
((memq word '(do doing))
(let ((body nil))
(or (consp (car args)) (error "Syntax error on `do' clause"))
(while (consp (car args)) (cl-push (cl-pop args) body))
(cl-push (cons 'progn (nreverse (cons t body))) loop-body)))
((eq word 'return)
(or loop-finish-flag (setq loop-finish-flag (gensym)))
(or loop-result-var (setq loop-result-var (gensym)))
(cl-push (list 'setq loop-result-var (cl-pop 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 (cl-pop args) (cl-parse-loop-clause)))))
(defun cl-loop-let (specs body par) ; uses loop-*
(let ((p specs) (temps nil) (new nil))
(while (and p (or (symbolp (car-safe (car p))) (null (cadar p))))
(setq p (cdr p)))
(and par p
(progn
(setq par nil p specs)
(while p
(or (cl-const-expr-p (cadar p))
(let ((temp (gensym)))
(cl-push (list temp (cadar p)) temps)
(setcar (cdar p) temp)))
(setq p (cdr p)))))
(while specs
(if (and (consp (car specs)) (listp (caar specs)))
(let* ((spec (caar specs)) (nspecs nil)
(expr (cadr (cl-pop specs)))
(temp (cdr (or (assq spec loop-destr-temps)
(car (cl-push (cons spec (or (last spec 0)
(gensym)))
loop-destr-temps))))))
(cl-push (list temp expr) new)
(while (consp spec)
(cl-push (list (cl-pop spec)
(and expr (list (if spec 'pop 'car) temp)))
nspecs))
(setq specs (nconc (nreverse nspecs) specs)))
(cl-push (cl-pop specs) new)))
(if (eq body 'setq)
(let ((set (cons (if par 'psetq 'setq) (apply 'nconc (nreverse new)))))
(if temps (list 'let* (nreverse temps) set) set))
(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)))
(or (memq var loop-accum-vars)
(progn (cl-push (list (list var def)) loop-bindings)
(cl-push var loop-accum-vars)))
var)
(or loop-accum-var
(progn
(cl-push (list (list (setq loop-accum-var (gensym)) def))
loop-bindings)
(setq loop-result (if func (list func loop-accum-var)
loop-accum-var))
loop-accum-var))))
(defun cl-loop-build-ands (clauses)
(let ((ands nil)
(body nil))
(while clauses
(if (and (eq (car-safe (car clauses)) 'progn)
(eq (car (last (car clauses))) t))
(if (cdr clauses)
(setq clauses (cons (nconc (butlast (car clauses))
(if (eq (car-safe (cadr clauses))
'progn)
(cdadr clauses)
(list (cadr clauses))))
(cddr clauses)))
(setq body (cdr (butlast (cl-pop clauses)))))
(cl-push (cl-pop clauses) ands)))
(setq ands (or (nreverse ands) (list t)))
(list (if (cdr ands) (cons 'and ands) (car ands))
body
(let ((full (if body
(append ands (list (cons 'progn (append body '(t)))))
ands)))
(if (cdr full) (cons 'and full) (car full))))))