2011-05-23 Stefan Monnier <monnier@iro.umontreal.ca>
+ * <lots-of-files>.el: Don't quote lambda expressions with `quote'.
+
* vc/smerge-mode.el (smerge-refine-subst): Don't deactivate the mark
(bug#8710).
enhancements, directly.")
;;;###autoload
(put 'allout-widgets-mode-inhibit 'safe-local-variable
- (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+ (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
(make-variable-buffer-local 'allout-widgets-mode-inhibit)
;;;_ = allout-inhibit-body-modification-hook
(defvar allout-inhibit-body-modification-hook nil
(make-variable-buffer-local 'allout-use-hanging-indents)
;;;###autoload
(put 'allout-use-hanging-indents 'safe-local-variable
- (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+ (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
;;;_ = allout-reindent-bodies
(defcustom allout-reindent-bodies (if allout-use-hanging-indents
'text)
(make-variable-buffer-local 'allout-reindent-bodies)
;;;###autoload
(put 'allout-reindent-bodies 'safe-local-variable
- '(lambda (x) (memq x '(nil t text force))))
+ (lambda (x) (memq x '(nil t text force))))
;;;_ = allout-show-bodies
(defcustom allout-show-bodies nil
(make-variable-buffer-local 'allout-show-bodies)
;;;###autoload
(put 'allout-show-bodies 'safe-local-variable
- (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+ (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
;;;_ = allout-beginning-of-line-cycles
(defcustom allout-beginning-of-line-cycles t
:group 'allout)
;;;###autoload
(put 'allout-use-mode-specific-leader 'safe-local-variable
- '(lambda (x) (or (memq x '(t nil allout-mode-leaders comment-start))
+ (lambda (x) (or (memq x '(t nil allout-mode-leaders comment-start))
(stringp x))))
;;;_ = allout-mode-leaders
(defvar allout-mode-leaders '()
(make-variable-buffer-local 'allout-old-style-prefixes)
;;;###autoload
(put 'allout-old-style-prefixes 'safe-local-variable
- (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+ (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
;;;_ = allout-stylish-prefixes -- alternating bullets
(defcustom allout-stylish-prefixes t
"Do fancy stuff with topic prefix bullets according to level, etc.
(make-variable-buffer-local 'allout-stylish-prefixes)
;;;###autoload
(put 'allout-stylish-prefixes 'safe-local-variable
- (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+ (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
;;;_ = allout-numbered-bullet
(defcustom allout-numbered-bullet "#"
(put 'allout-numbered-bullet 'safe-local-variable
(if (fboundp 'string-or-null-p)
'string-or-null-p
- '(lambda (x) (or (stringp x) (null x)))))
+ (lambda (x) (or (stringp x) (null x)))))
;;;_ = allout-file-xref-bullet
(defcustom allout-file-xref-bullet "@"
"Bullet signifying file cross-references, for `allout-resolve-xref'.
(put 'allout-file-xref-bullet 'safe-local-variable
(if (fboundp 'string-or-null-p)
'string-or-null-p
- '(lambda (x) (or (stringp x) (null x)))))
+ (lambda (x) (or (stringp x) (null x)))))
;;;_ = allout-presentation-padding
(defcustom allout-presentation-padding 2
"Presentation-format white-space padding factor, for greater indent."
(make-variable-buffer-local 'allout-layout)
;;;###autoload
(put 'allout-layout 'safe-local-variable
- '(lambda (x) (or (numberp x) (listp x) (memq x '(: * + -)))))
+ (lambda (x) (or (numberp x) (listp x) (memq x '(: * + -)))))
;;;_ : Topic header format
;;;_ = allout-regexp
(defmacro math-defsimplify (funcs &rest code)
- (append '(progn)
- (mapcar (function
- (lambda (func)
- (list 'put (list 'quote func) ''math-simplify
- (list 'nconc
- (list 'get (list 'quote func) ''math-simplify)
- (list 'list
- (list 'function
- (append '(lambda (math-simplify-expr))
- code)))))))
- (if (symbolp funcs) (list funcs) funcs))))
+ (cons 'progn
+ (mapcar #'(lambda (func)
+ `(put ',func 'math-simplify
+ (nconc
+ (get ',func 'math-simplify)
+ (list
+ #'(lambda (math-simplify-expr) ,@code)))))
+ (if (symbolp funcs) (list funcs) funcs))))
(put 'math-defsimplify 'lisp-indent-hook 1)
;; The function created by math-defsimplify uses the variable
(defmacro math-defintegral (funcs &rest code)
(setq math-integral-cache nil)
- (append '(progn)
- (mapcar (function
- (lambda (func)
- (list 'put (list 'quote func) ''math-integral
- (list 'nconc
- (list 'get (list 'quote func) ''math-integral)
- (list 'list
- (list 'function
- (append '(lambda (u))
- code)))))))
- (if (symbolp funcs) (list funcs) funcs))))
+ (cons 'progn
+ (mapcar #'(lambda (func)
+ `(put ',func 'math-integral
+ (nconc
+ (get ',func 'math-integral)
+ (list
+ #'(lambda (u) ,@code)))))
+ (if (symbolp funcs) (list funcs) funcs))))
(put 'math-defintegral 'lisp-indent-hook 1)
(defmacro math-defintegral-2 (funcs &rest code)
(setq math-integral-cache nil)
- (append '(progn)
- (mapcar (function
- (lambda (func)
- (list 'put (list 'quote func) ''math-integral-2
- (list 'nconc
- (list 'get (list 'quote func)
- ''math-integral-2)
- (list 'list
- (list 'function
- (append '(lambda (u v))
- code)))))))
- (if (symbolp funcs) (list funcs) funcs))))
+ (cons 'progn
+ (mapcar #'(lambda (func)
+ `(put ',func 'math-integral-2
+ `(nconc
+ (get ',func 'math-integral-2)
+ (list #'(lambda (u v) ,@code)))))
+ (if (symbolp funcs) (list funcs) funcs))))
(put 'math-defintegral-2 'lisp-indent-hook 1)
(defvar var-IntegAfterRules 'calc-IntegAfterRules)
(setq calculator-user-registers '((?g . 1.61803398875)))
before you load calculator."
:type '(repeat (cons character number))
- :set '(lambda (_ val)
- (and (boundp 'calculator-registers)
- (setq calculator-registers
- (append val calculator-registers)))
- (setq calculator-user-registers val))
+ :set (lambda (_ val)
+ (and (boundp 'calculator-registers)
+ (setq calculator-registers
+ (append val calculator-registers)))
+ (setq calculator-user-registers val))
:group 'calculator)
(defcustom calculator-user-operators nil
["Electric mode"
(progn (calculator-quit)
(setq calculator-restart-other-mode t)
- (run-with-timer 0.1 nil '(lambda () (message nil)))
+ (run-with-timer 0.1 nil (lambda () (message nil)))
;; the message from the menu will be visible,
;; couldn't make it go away...
(calculator))
(Electric-command-loop
'calculator-done
;; can't use 'noprompt, bug in electric.el
- '(lambda () 'noprompt)
+ (lambda () 'noprompt)
nil
(lambda (x y) (calculator-update-display))))
(and calculator-buffer
;; directory separators changed to directory-sep-char.
(let ((name nil))
(setq name (mapconcat
- '(lambda (char)
- (if (and (<= ?A char) (<= char ?Z))
- (char-to-string (+ (- char ?A) ?a))
- (char-to-string char)))
+ (lambda (char)
+ (if (and (<= ?A char) (<= char ?Z))
+ (char-to-string (+ (- char ?A) ?a))
+ (char-to-string char)))
filename nil))
;; Use expand-file-name to canonicalize directory separators, except
;; with bare drive letters (which would have the cwd appended).
;; "Cause the named functions to be open-coded when called from compiled code.
;; They will only be compiled open-coded when byte-compile-optimize is true."
;; (cons 'eval-and-compile
-;; (mapcar '(lambda (x)
+;; (mapcar (lambda (x)
;; (or (memq (get x 'byte-optimizer)
;; '(nil byte-compile-inline-expand))
;; (error
;; (defmacro proclaim-notinline (&rest fns)
;; "Cause the named functions to no longer be open-coded."
;; (cons 'eval-and-compile
-;; (mapcar '(lambda (x)
+;; (mapcar (lambda (x)
;; (if (eq (get x 'byte-optimizer) 'byte-compile-inline-expand)
;; (put x 'byte-optimizer nil))
;; (list 'if (list 'eq (list 'get (list 'quote x) ''byte-optimizer)
extlst "File Extensions"
cntlst "# of occurrences"
10
- '(lambda (a b) (> (cdr a) (cdr b))))
+ (lambda (a b) (> (cdr a) (cdr b))))
))
(defun chart-space-usage (d)
nmlst "File Name"
cntlst "File Size"
10
- '(lambda (a b) (> (cdr a) (cdr b))))
+ (lambda (a b) (> (cdr a) (cdr b))))
))
(defun chart-emacs-storage ()
nmlst "User Names"
cntlst "# of occurrences"
10
- '(lambda (a b) (> (cdr a) (cdr b))))
+ (lambda (a b) (> (cdr a) (cdr b))))
))
;; or [menu-bar emacs-lisp eval-buffer]. Additional key-bindings
;; are also provided under C-c ? KEY
;; (require 'checkdoc)
-;; (add-hook 'emacs-lisp-mode-hook
-;; '(lambda () (checkdoc-minor-mode 1)))
+;; (add-hook 'emacs-lisp-mode-hook 'checkdoc-minor-mode)
;;
;; Using `checkdoc':
;;
((eq (car-safe (car-safe arg)) 'byte-code)
(insert "(<byte code>...)\n")
(mapc ;recurse on list of byte-code objects
- '(lambda (obj)
- (disassemble-1
- obj
- (+ indent disassemble-recursive-indent)))
+ (lambda (obj)
+ (disassemble-1
+ obj
+ (+ indent disassemble-recursive-indent)))
arg))
(t
;; really just a constant
;;;These forms are all considered safe
(defconst testcover-unsafep-safe
'(((lambda (x) (* x 2)) 14)
- (apply 'cdr (mapcar '(lambda (x) (car x)) y))
+ (apply 'cdr (mapcar (lambda (x) (car x)) y))
(cond ((= x 4) 5) (t 27))
(condition-case x (car y) (error (car x)))
(dolist (x y) (message "here: %s" x))
(dotimes (x 14 (* x 2)) (message "here: %d" x))
(let (x) (dolist (y '(1 2 3) (1+ y)) (push y x)))
- (let (x) (apply '(lambda (x) (* x 2)) 14))
+ (let (x) (apply (lambda (x) (* x 2)) 14))
(let ((x '(2))) (push 1 x) (pop x) (add-to-list 'x 2))
(let ((x 1) (y 2)) (setq x (+ x y)))
(let ((x 1)) (let ((y (+ x 3))) (* x y)))
. (function kill-buffer))
( (mapcar x y)
. (unquoted x))
- ( (mapcar '(lambda (x) (rename-file x "x")) '("unsafep.el"))
+ ( (mapcar (lambda (x) (rename-file x "x")) '("unsafep.el"))
. (function rename-file))
( (mapconcat x1 x2 " ")
. (unquoted x1))
(let ((lines 0))
(if (not (cua--rectangle-virtual-edges))
(cua--rectangle-operation nil nil t 2 t
- '(lambda (s e l r v)
- (setq lines (1+ lines))
- (if (and (> e s) (<= e (point-max)))
- (delete-region s e))))
+ (lambda (s e l r v)
+ (setq lines (1+ lines))
+ (if (and (> e s) (<= e (point-max)))
+ (delete-region s e))))
(cua--rectangle-operation nil 1 t nil t
- '(lambda (s e l r v)
+ (lambda (s e l r v)
(setq lines (1+ lines))
(when (and (> e s) (<= e (point-max)))
(delete-region s e)))))
(let (rect)
(if (not (cua--rectangle-virtual-edges))
(cua--rectangle-operation nil nil nil nil nil ; do not tabify
- '(lambda (s e l r)
+ (lambda (s e l r)
(setq rect (cons (cua--filter-buffer-noprops s e) rect))))
(cua--rectangle-operation nil 1 nil nil nil ; do not tabify
- '(lambda (s e l r v)
+ (lambda (s e l r v)
(let ((copy t) (bs 0) (as 0) row)
(if (= s e) (setq e (1+ e)))
(goto-char s)
(when (/= left right)
(sit-for 0) ; make window top/bottom reliable
(cua--rectangle-operation nil t nil nil nil ; do not tabify
- '(lambda (s e l r v)
+ (lambda (s e l r v)
(let ((rface (if v 'cua-rectangle 'cua-rectangle-noselect))
overlay bs ms as)
(when (cua--rectangle-virtual-edges)
(pad (cua--rectangle-virtual-edges))
indent)
(cua--rectangle-operation (if clear 'clear 'corners) nil t pad nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(move-to-column col pad)
(if (and (eolp)
(< (current-column) col))
(if (cua--rectangle-right-side t)
(cua--rectangle-insert-col (current-column))
(setq indent (- (current-column) l))))
- '(lambda (l r)
+ (lambda (l r)
(when (and indent (> indent 0))
(aset cua--rectangle 2 (+ l indent))
(aset cua--rectangle 3 (+ r indent -1)))))))
but instead winds up to the right of the rectangle."
(interactive)
(cua--rectangle-operation 'corners nil t 1 nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(skip-chars-forward " \t")
(let ((ws (- (current-column) l))
(p (point)))
With prefix arg, also delete whitespace to the left of that column."
(interactive "P")
(cua--rectangle-operation 'clear nil t 1 nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(when arg
(skip-syntax-backward " " (line-beginning-position))
(setq s (point)))
The text previously in the rectangle is overwritten by the blanks."
(interactive)
(cua--rectangle-operation 'keep nil nil 1 nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(goto-char e)
(skip-syntax-forward " " (line-end-position))
(setq e (point))
(interactive)
(let (x)
(cua--rectangle-operation 'clear nil t t nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(let ((b (line-beginning-position)))
(skip-syntax-backward "^ " b)
(skip-syntax-backward " " b)
(skip-syntax-forward " " (line-end-position))
(delete-region s (point))
(indent-to l))
- '(lambda (l r)
+ (lambda (l r)
(move-to-column l)
;; (setq cua-save-point (point))
))))
The length of STRING need not be the same as the rectangle width."
(interactive "sString rectangle: ")
(cua--rectangle-operation 'keep nil t t nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(delete-region s e)
(skip-chars-forward " \t")
(let ((ws (- (current-column) l)))
(insert string)
(indent-to (+ (current-column) ws))))
(unless (cua--rectangle-restriction)
- '(lambda (l r)
+ (lambda (l r)
(cua--rectangle-right (max l (+ l (length string) -1)))))))
(defun cua-fill-char-rectangle (character)
"Replace CUA rectangle contents with CHARACTER."
(interactive "cFill rectangle with character: ")
(cua--rectangle-operation 'clear nil t 1 nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(delete-region s e)
(move-to-column l t)
(insert-char character (- r l)))))
(if buffer-read-only
(message "Cannot replace in read-only buffer")
(cua--rectangle-operation 'keep nil t 1 nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(if (re-search-forward regexp e t)
(replace-match newtext nil nil))))))
"Increment each line of CUA rectangle by prefix amount."
(interactive "p")
(cua--rectangle-operation 'keep nil t 1 nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(cond
((re-search-forward "0x\\([0-9a-fA-F]+\\)" e t)
(let* ((txt (cua--filter-buffer-noprops (match-beginning 1) (match-end 1)))
(setq format cua--rectangle-seq-format)
(setq cua--rectangle-seq-format format))
(cua--rectangle-operation 'clear nil t 1 nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(delete-region s e)
(insert (format format first))
(setq first (+ first incr)))))
(defmacro cua--convert-rectangle-as (command tabify)
`(cua--rectangle-operation 'clear nil nil nil ,tabify
- '(lambda (s e l r)
+ (lambda (s e l r)
(,command s e))))
(defun cua-upcase-rectangle ()
(if cua--debug
(print z auxbuf))
(cua--rectangle-operation nil nil t pad nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(let (cc)
(goto-char e)
(skip-chars-forward " \t")
nil nil nil nil)))
(cua--rectangle-aux-replace width t t t 1
'cua--left-fill-rectangle
- '(lambda () (insert text))))
+ (lambda () (insert text))))
(defun cua-refill-rectangle (width)
"Fill contents of current rectagle.
nil nil nil
'shell-command-history)))
(cua--rectangle-aux-replace -1 t t replace 1
- '(lambda (s e)
+ (lambda (s e)
(shell-command-on-region s e command
replace replace nil))))
"Remove the first line of the rectangle and scroll remaining lines up."
(interactive)
(cua--rectangle-aux-replace 0 t t t t
- '(lambda (s e)
+ (lambda (s e)
(if (= (forward-line 1) 0)
(delete-region s (point))))))
The remaining lines are scrolled down, losing the last line."
(interactive)
(cua--rectangle-aux-replace 0 t t t t
- '(lambda (s e)
+ (lambda (s e)
(goto-char s)
(insert "\n"))))
(pad (cua--rectangle-virtual-edges))
indent)
(cua--rectangle-operation 'corners nil t pad nil
- '(lambda (s e l r)
+ (lambda (s e l r)
(move-to-column
(if (cua--rectangle-right-side t)
(max (1+ r) col) l)
(if (cua--rectangle-right-side t)
(cua--rectangle-insert-col (current-column))
(setq indent (- l (current-column))))))
- '(lambda (l r)
+ (lambda (l r)
(when (and indent (> indent 0))
(aset cua--rectangle 2 (- l indent))
(aset cua--rectangle 3 (- r indent 1)))))))
(defun tpu-make-file-buffer-list (buffer-list)
"Return names from BUFFER-LIST excluding those beginning with a space or star."
- (delq nil (mapcar '(lambda (b)
- (if (or (= (aref (buffer-name b) 0) ? )
- (= (aref (buffer-name b) 0) ?*)) nil b))
+ (delq nil (mapcar (lambda (b)
+ (if (or (= (aref (buffer-name b) 0) ?\s)
+ (= (aref (buffer-name b) 0) ?*)) nil b))
buffer-list)))
(defun tpu-next-window nil
"Function that implements ESC key in Viper emulation of Vi."
(interactive)
(let ((cmd (or (key-binding (viper-envelop-ESC-key))
- '(lambda () (interactive) (error "Viper bell")))))
+ (lambda () (interactive) (error "Viper bell")))))
;; call the actual function to execute ESC (if no other symbols followed)
;; or the key bound to the ESC sequence (if the sequence was issued
char-p (= (length base-key-name) 1))
(setq mod-char-list
(mapcar
- '(lambda (elt) (upcase (substring (symbol-name elt) 0 1)))
+ (lambda (elt) (upcase (substring (symbol-name elt) 0 1)))
modifiers))
(if char-p
(setq key-name
;; XEmacs only
(defun viper-event-vector-p (vec)
(and (vectorp vec)
- (eval (cons 'and (mapcar '(lambda (elt) (if (eventp elt) t)) vec)))))
+ (eval (cons 'and (mapcar (lambda (elt) (if (eventp elt) t)) vec)))))
;; check if vec is a vector of character symbols
the `Local variables' section of a file."
(setq viper-related-files-and-buffers-ring
(make-ring (1+ (length other-files-or-buffers))))
- (mapc '(lambda (elt)
+ (mapc (lambda (elt)
(viper-ring-insert viper-related-files-and-buffers-ring elt))
other-files-or-buffers)
(viper-ring-insert viper-related-files-and-buffers-ring (buffer-name))
;; over misspelled words (due to the overlay keymaps)
(defvar flyspell-mode-hook)
(add-hook 'flyspell-mode-hook
- '(lambda ()
- (define-key flyspell-mouse-map viper-ESC-key nil)))
+ (lambda ()
+ (define-key flyspell-mouse-map viper-ESC-key nil)))
;; if viper is started from .emacs, it might be impossible to get certain
;; info about the display and windows until emacs initialization is complete
;; So do it via the window-setup-hook
(add-hook 'window-setup-hook
- '(lambda ()
- (modify-frame-parameters
- (selected-frame)
- (list (cons 'viper-vi-state-cursor-color
- (viper-get-cursor-color))))
- (setq viper-vi-state-cursor-color (viper-get-cursor-color))
- ))
+ (lambda ()
+ (modify-frame-parameters
+ (selected-frame)
+ (list (cons 'viper-vi-state-cursor-color
+ (viper-get-cursor-color))))
+ (setq viper-vi-state-cursor-color (viper-get-cursor-color))
+ ))
;; Tell vc-diff to put *vc* in Vi mode
(eval-after-load
;; if this is a glob pattern than needs to be expanded, then it
;; will need to expand each member of the resulting glob list
(add-to-list 'eshell-current-modifiers
- '(lambda (list)
- (if (listp list)
- (mapcar 'expand-file-name list)
- (expand-file-name list)))))
+ (lambda (list)
+ (if (listp list)
+ (mapcar 'expand-file-name list)
+ (expand-file-name list)))))
(add-to-list 'eshell-current-modifiers 'eshell-extended-glob))
(defun eshell-parse-glob-chars ()
(?s . (eshell-pred-file-mode 4000)) ; setuid
(?S . (eshell-pred-file-mode 2000)) ; setgid
(?t . (eshell-pred-file-mode 1000)) ; sticky bit
- (?U . '(lambda (file) ; owned by effective uid
- (if (file-exists-p file)
- (= (nth 2 (file-attributes file)) (user-uid)))))
-;;; (?G . '(lambda (file) ; owned by effective gid
-;;; (if (file-exists-p file)
-;;; (= (nth 2 (file-attributes file)) (user-uid)))))
- (?* . '(lambda (file)
- (and (file-regular-p file)
- (not (file-symlink-p file))
- (file-executable-p file))))
+ (?U . #'(lambda (file) ; owned by effective uid
+ (if (file-exists-p file)
+ (= (nth 2 (file-attributes file)) (user-uid)))))
+ ;; (?G . #'(lambda (file) ; owned by effective gid
+ ;; (if (file-exists-p file)
+ ;; (= (nth 2 (file-attributes file)) (user-uid)))))
+ (?* . #'(lambda (file)
+ (and (file-regular-p file)
+ (not (file-symlink-p file))
+ (file-executable-p file))))
(?l . (eshell-pred-file-links))
(?u . (eshell-pred-user-or-group ?u "user" 2 'eshell-user-id))
(?g . (eshell-pred-user-or-group ?g "group" 3 'eshell-group-id))
(put 'eshell-predicate-alist 'risky-local-variable t)
(defcustom eshell-modifier-alist
- '((?E . '(lambda (lst)
- (mapcar
- (function
- (lambda (str)
- (eshell-stringify
- (car (eshell-parse-argument str))))) lst)))
- (?L . '(lambda (lst)
- (mapcar 'downcase lst)))
- (?U . '(lambda (lst)
- (mapcar 'upcase lst)))
- (?C . '(lambda (lst)
- (mapcar 'capitalize lst)))
- (?h . '(lambda (lst)
- (mapcar 'file-name-directory lst)))
+ '((?E . #'(lambda (lst)
+ (mapcar
+ (function
+ (lambda (str)
+ (eshell-stringify
+ (car (eshell-parse-argument str))))) lst)))
+ (?L . #'(lambda (lst) (mapcar 'downcase lst)))
+ (?U . #'(lambda (lst) (mapcar 'upcase lst)))
+ (?C . #'(lambda (lst) (mapcar 'capitalize lst)))
+ (?h . #'(lambda (lst) (mapcar 'file-name-directory lst)))
(?i . (eshell-include-members))
(?x . (eshell-include-members t))
- (?r . '(lambda (lst)
- (mapcar 'file-name-sans-extension lst)))
- (?e . '(lambda (lst)
- (mapcar 'file-name-extension lst)))
- (?t . '(lambda (lst)
- (mapcar 'file-name-nondirectory lst)))
- (?q . '(lambda (lst)
- (mapcar 'eshell-escape-arg lst)))
- (?u . '(lambda (lst)
- (eshell-uniqify-list lst)))
- (?o . '(lambda (lst)
- (sort lst 'string-lessp)))
- (?O . '(lambda (lst)
- (nreverse (sort lst 'string-lessp))))
+ (?r . #'(lambda (lst) (mapcar 'file-name-sans-extension lst)))
+ (?e . #'(lambda (lst) (mapcar 'file-name-extension lst)))
+ (?t . #'(lambda (lst) (mapcar 'file-name-nondirectory lst)))
+ (?q . #'(lambda (lst) (mapcar 'eshell-escape-arg lst)))
+ (?u . #'(lambda (lst) (eshell-uniqify-list lst)))
+ (?o . #'(lambda (lst) (sort lst 'string-lessp)))
+ (?O . #'(lambda (lst) (nreverse (sort lst 'string-lessp))))
(?j . (eshell-join-members))
(?S . (eshell-split-members))
(?R . 'reverse)
:group 'backup
:group 'vc)
(put 'version-control 'safe-local-variable
- '(lambda (x) (or (booleanp x) (equal x 'never))))
+ (lambda (x) (or (booleanp x) (equal x 'never))))
(defcustom dired-kept-versions 2
"When cleaning directory, number of versions to keep."
(widget-create
'push-button
:notify
- '(lambda (&rest ignore)
- (let* ((info (assq gnus-agent-cat-name gnus-category-alist))
- (widgets category-fields))
- (while widgets
- (let* ((widget (pop widgets))
- (value (condition-case nil (widget-value widget) (error))))
- (eval `(setf (,(widget-get widget :accessor) ',info)
- ',value)))))
- (gnus-category-write)
- (gnus-kill-buffer (current-buffer))
- (when (get-buffer gnus-category-buffer)
- (switch-to-buffer (get-buffer gnus-category-buffer))
- (gnus-category-list)))
+ (lambda (&rest ignore)
+ (let* ((info (assq gnus-agent-cat-name gnus-category-alist))
+ (widgets category-fields))
+ (while widgets
+ (let* ((widget (pop widgets))
+ (value (condition-case nil (widget-value widget) (error))))
+ (eval `(setf (,(widget-get widget :accessor) ',info)
+ ',value)))))
+ (gnus-category-write)
+ (gnus-kill-buffer (current-buffer))
+ (when (get-buffer gnus-category-buffer)
+ (switch-to-buffer (get-buffer gnus-category-buffer))
+ (gnus-category-list)))
"Done")
(widget-insert
"\n Note: Empty fields default to the customizable global\
(when (gnus-group-entry group)
(gnus-activate-group group)
(add-hook 'message-send-hook
- '(lambda ()
- (message-remove-header gnus-delay-header)))
+ (lambda () (message-remove-header gnus-delay-header)))
(setq articles (nndraft-articles))
(while (setq article (pop articles))
(gnus-request-head article group)
(switch-to-buffer gnus-group-buffer)
(funcall gnus-other-frame-function arg)
(add-hook 'gnus-exit-gnus-hook
- '(lambda nil
- (when (and (frame-live-p gnus-other-frame-object)
- (cdr (frame-list)))
- (delete-frame gnus-other-frame-object))
- (setq gnus-other-frame-object nil)))))))
+ (lambda nil
+ (when (and (frame-live-p gnus-other-frame-object)
+ (cdr (frame-list)))
+ (delete-frame gnus-other-frame-object))
+ (setq gnus-other-frame-object nil)))))))
;;;###autoload
(defun gnus (&optional arg dont-connect slave)
;; (defun hilit-chg-debug-show (&optional beg end)
;; (interactive)
;; (message "--- hilit-chg-debug-show ---")
-;; (hilit-chg-map-changes '(lambda (prop start end)
-;; (message "%d-%d: %s" start end prop)
-;; )
+;; (hilit-chg-map-changes (lambda (prop start end)
+;; (message "%d-%d: %s" start end prop))
;; beg end
;; ))
;;
(funcall f completion-list
:help-string "ido "
:activate-callback
- '(lambda (x y z) (message "Doesn't work yet, sorry!"))))
+ (lambda (x y z) (message "Doesn't work yet, sorry!"))))
;; else running Emacs
;;(add-hook 'completion-setup-hook 'completion-setup-function)
(display-completion-list completion-list)))))))
wish to put something like the following in your `.emacs' file:
\(add-hook 'ielm-mode-hook
- '(lambda ()
+ (lambda ()
(define-key ielm-map \"\\C-w\" 'comint-kill-region)
(define-key ielm-map [C-S-backspace]
'comint-kill-whole-line)))
;; `(,(nth 4 fattribs) ,(nth 7 fattribs) ,f)))
;; (directory-files (image-dired-dir) t ".+\.thumb\..+$"))
;; ;; Sort function. Compare time between two files.
-;; '(lambda (l1 l2)
+;; (lambda (l1 l2)
;; (time-less-p (car l1) (car l2)))))
;; (dirsize (apply '+ (mapcar (lambda (x) (cadr x)) files))))
;; (while (> dirsize image-dired-dir-max-size)
(define-button-type 'quail-keyboard-layout-button
:supertype 'help-xref
- 'help-function '(lambda (layout)
- (help-setup-xref `(quail-keyboard-layout-button ,layout)
- nil)
- (quail-show-keyboard-layout layout))
+ 'help-function (lambda (layout)
+ (help-setup-xref `(quail-keyboard-layout-button ,layout)
+ nil)
+ (quail-show-keyboard-layout layout))
'help-echo (purecopy "mouse-2, RET: show keyboard layout"))
(define-button-type 'quail-keyboard-customize-button
;; (delete-minibuffer-contents))
;;
;; (add-hook 'iswitchb-define-mode-map-hook
-;; '(lambda () (define-key
+;; (lambda () (define-key
;; iswitchb-mode-map "\C-o"
;; 'iswitchb-exclude-nonmatching)))
;; Do it after subr, since both after-load-functions and add-hook are
;; implemented in subr.el.
-(add-hook 'after-load-functions '(lambda (f) (garbage-collect)))
+(add-hook 'after-load-functions (lambda (f) (garbage-collect)))
;; We specify .el in case someone compiled version.el by mistake.
(load "version.el")
(equal (nth 4 command-line-args) "bootstrap"))
(setcdr load-path nil))
-(remove-hook 'after-load-functions '(lambda (f) (garbage-collect)))
+(remove-hook 'after-load-functions (lambda (f) (garbage-collect)))
(setq inhibit-load-charset-map nil)
(clear-charset-maps)
system-configuration-options "'\n\n"))
(insert "Important settings:\n")
(mapc
- '(lambda (var)
- (insert (format " value of $%s: %s\n" var (getenv var))))
+ (lambda (var)
+ (insert (format " value of $%s: %s\n" var (getenv var))))
'("LC_ALL" "LC_COLLATE" "LC_CTYPE" "LC_MESSAGES"
"LC_MONETARY" "LC_NUMERIC" "LC_TIME" "LANG" "XMODIFIERS"))
(insert (format " locale-coding-system: %s\n" locale-coding-system))
)
(defcustom feedmail-queue-runner-mode-setter
- '(lambda (&optional arg) (mail-mode))
+ (lambda (&optional arg) (mail-mode))
"A function to set the proper mode of a message file.
Called when the message is read back out of the queue directory with a single
argument, the optional argument used in the call to
(defcustom feedmail-queue-runner-message-sender
- '(lambda (&optional arg) (mail-send))
+ (lambda (&optional arg) (mail-send))
"Function to initiate sending a message file.
Called for each message read back out of the queue directory with a
single argument, the optional argument used in the call to
(defcustom feedmail-queue-runner-cleaner-upper
- '(lambda (fqm-file &optional arg)
+ (lambda (fqm-file &optional arg)
(delete-file fqm-file)
(if arg (feedmail-say-chatter "Nuked %s" fqm-file)))
"Function that will be called after a message has been sent.
;; don't be overconfident about the name of the trace buffer
(tracer (concat "trace.*smtp.*" (regexp-quote smtpmail-smtp-server))))
(mapcar
- '(lambda (buffy)
+ (lambda (buffy)
(if (string-match tracer (buffer-name buffy))
(progn
(insert "SMTP Trace from " (buffer-name buffy) "\n---------------")
;; don't be overconfident about the name of the trace buffer
(tracer (concat "trace.*smtp.*" (regexp-quote smtp-server))))
(mapcar
- '(lambda (buffy)
+ (lambda (buffy)
(if (string-match tracer (buffer-name buffy))
(progn
(insert "SMTP Trace from " (buffer-name buffy) "\n---------------")
(if feedmail-queue-run-orderer
(setq list-of-possible-fqms (funcall feedmail-queue-run-orderer list-of-possible-fqms)))
(mapc
- '(lambda (blobby)
+ (lambda (blobby)
(setq maybe-file (expand-file-name blobby feedmail-queue-directory))
(cond
((file-directory-p maybe-file) nil) ; don't care about subdirs
;; iterate, counting things we find along the way in the directory
(if (file-directory-p queue-directory)
(mapc
- '(lambda (blobby)
+ (lambda (blobby)
(cond
((file-directory-p blobby) nil) ; don't care about subdirs
((feedmail-fqm-p blobby)
(save-excursion
(if feedmail-enable-spray
(mapcar
- '(lambda (feedmail-spray-this-address)
+ (lambda (feedmail-spray-this-address)
(let ((spray-buffer (get-buffer-create " *FQM Outgoing Email Spray*")))
(with-current-buffer spray-buffer
(erase-buffer)
;; Mailing list inboxes
;; must have VM already loaded to get vm-folder-directory.
- (mapcar '(lambda (s)
- "make the appropriate entry for vm-spool-files"
- (list
- (concat mspools-folder-directory s)
- (concat mspools-folder-directory s "." mspools-suffix)
- (concat mspools-folder-directory s ".crash")))
+ (mapcar (lambda (s)
+ "make the appropriate entry for vm-spool-files"
+ (list
+ (concat mspools-folder-directory s)
+ (concat mspools-folder-directory s "." mspools-suffix)
+ (concat mspools-folder-directory s ".crash")))
;; So I create a vm-spool-files entry for each of those mail drops
(mapcar 'file-name-sans-extension
(directory-files mspools-folder-directory nil
(let ((l))
(mapc
;; remove duplicates
- '(lambda (e)
- (unless (member e l)
- (push e l)))
+ (lambda (e)
+ (unless (member e l)
+ (push e l)))
(split-string new-header-values
",[[:space:]]+" t))
(mapconcat 'identity l ", "))
(message "Making passwd aliases...")
(setq passwd-matches
(mapconcat
- '(lambda (elem)
- (if (or (string-match regexp (car elem))
- (string-match regexp (cadr elem)))
- (format "%s: %s\n" (car elem) (cadr elem))))
+ (lambda (elem)
+ (if (or (string-match regexp (car elem))
+ (string-match regexp (cadr elem)))
+ (format "%s: %s\n" (car elem) (cadr elem))))
mh-alias-passwd-alist ""))
(message "Making passwd aliases...done")))
(if (and (string-equal "" matches)
(t
(message "Unknown variant %s; use %s"
variant
- (mapconcat '(lambda (x) (format "%s" (car x)))
+ (mapconcat (lambda (x) (format "%s" (car x)))
(mh-variants) " or "))))))
(defcustom-mh mh-variant 'autodetect
"Help text for `mh-inc-spool-map'.")
(define-key mh-inc-spool-map "?"
- '(lambda ()
- (interactive)
- (if mh-inc-spool-map-help
- (mh-help mh-inc-spool-map-help)
- (mh-ephem-message
- "There are no keys defined yet; customize `mh-inc-spool-list'"))))
+ (lambda ()
+ (interactive)
+ (if mh-inc-spool-map-help
+ (mh-help mh-inc-spool-map-help)
+ (mh-ephem-message
+ "There are no keys defined yet; customize `mh-inc-spool-list'"))))
;;;###mh-autoload
(defun mh-inc-spool-make ()
(delete-other-windows)
(pop-to-buffer (get-buffer-create "*MH-E Spammer Frequencies*"))
(erase-buffer)
- (maphash '(lambda (key value) ""
- (if (> value 2)
- (insert (format "%s %s\n" key value))))
+ (maphash (lambda (key value) ""
+ (if (> value 2)
+ (insert (format "%s %s\n" key value))))
domains)
(sort-numeric-fields 2 (point-min) (point-max))
(reverse-region (point-min) (point-max))
;; Do an alias lookup on recipients
(message-options-set 'message-recipients
(mapconcat
- '(lambda (ali)
- (mail-strip-quoted-names (mh-alias-expand ali)))
+ (lambda (ali)
+ (mail-strip-quoted-names (mh-alias-expand ali)))
(split-string (message-options-get 'message-recipients) "[, ]+")
", ")))
(let ((saved-text (buffer-string))
:set 'msb-custom-set
:group 'msb)
-(defvar msb-horizontal-shift-function '(lambda () 0)
+(defvar msb-horizontal-shift-function (lambda () 0)
"*Function that specifies how many pixels to shift the top menu leftwards.")
(defcustom msb-display-invisible-buffers-p nil
;; base-versions
;; (file-name-directory fn)))
;; (versions (mapcar
-;; '(lambda (arg)
+;; (lambda (arg)
;; (if (and (string-match
;; "[0-9]+$" arg bv-length)
;; (= (match-beginning 0) bv-length))
hash table."
(let (result)
(maphash
- '(lambda (key value) (add-to-list 'result (cons key value) 'append))
+ (lambda (key value) (add-to-list 'result (cons key value) 'append))
dbus-registered-objects-table)
result))
;; Check whether SERVICE is a known name.
(when (not (string-match "^:" service))
(maphash
- '(lambda (key value)
- (dolist (elt value)
- ;; key has the structure (BUS INTERFACE MEMBER).
- ;; elt has the structure (UNAME SERVICE PATH HANDLER).
- (when (string-equal old-owner (car elt))
- ;; Remove old key, and add new entry with changed name.
- (dbus-unregister-object (list key (cdr elt)))
- ;; Maybe we could arrange the lists a little bit better
- ;; that we don't need to extract every single element?
- (dbus-register-signal
- ;; BUS SERVICE PATH
- (nth 0 key) (nth 1 elt) (nth 2 elt)
- ;; INTERFACE MEMBER HANDLER
- (nth 1 key) (nth 2 key) (nth 3 elt)))))
+ (lambda (key value)
+ (dolist (elt value)
+ ;; key has the structure (BUS INTERFACE MEMBER).
+ ;; elt has the structure (UNAME SERVICE PATH HANDLER).
+ (when (string-equal old-owner (car elt))
+ ;; Remove old key, and add new entry with changed name.
+ (dbus-unregister-object (list key (cdr elt)))
+ ;; Maybe we could arrange the lists a little bit better
+ ;; that we don't need to extract every single element?
+ (dbus-register-signal
+ ;; BUS SERVICE PATH
+ (nth 0 key) (nth 1 elt) (nth 2 elt)
+ ;; INTERFACE MEMBER HANDLER
+ (nth 1 key) (nth 2 key) (nth 3 elt)))))
(copy-hash-table dbus-registered-objects-table))))
;; The error is reported only in debug mode.
(when dbus-debug
(setq direction nil))
;; Collect the signatures.
(mapconcat
- '(lambda (x)
- (let ((arg (dbus-introspect-get-argument
- bus service path interface name x)))
- (if (or (not (stringp direction))
- (string-equal
- direction
- (dbus-introspect-get-attribute arg "direction")))
- (dbus-introspect-get-attribute arg "type")
- "")))
+ (lambda (x)
+ (let ((arg (dbus-introspect-get-argument
+ bus service path interface name x)))
+ (if (or (not (stringp direction))
+ (string-equal
+ direction
+ (dbus-introspect-get-attribute arg "direction")))
+ (dbus-introspect-get-attribute arg "type")
+ "")))
(dbus-introspect-get-argument-names bus service path interface name)
"")))
;; This function runs in a special context where lisp symbols corresponding
;; to field names in record are bound to the corresponding values
(eval
- `(let* (,@(mapcar '(lambda (c)
+ `(let* (,@(mapcar (lambda (c)
(list (car c) (if (listp (cdr c))
(list 'quote (cdr c))
(cdr c))))
(void-variable nil)))
((and recurse
(listp spec))
- (mapcar '(lambda (spec-elem)
+ (mapcar (lambda (spec-elem)
(eudc-parse-spec spec-elem record nil))
spec))
(t
"------" gap "--------\n"
"\n")
(setq eudc-hotlist-list-beginning (point))
- (mapc '(lambda (entry)
+ (mapc (lambda (entry)
(insert (car entry))
(indent-to proto-col)
(insert (symbol-name (cdr entry)) "\n"))
(error "Not in a EUDC hotlist edit buffer"))
(let ((server (read-from-minibuffer "Server: "))
(protocol (completing-read "Protocol: "
- (mapcar '(lambda (elt)
+ (mapcar (lambda (elt)
(cons (symbol-name elt)
elt))
eudc-known-protocols)))
The translation is done according to
`eudc-protocol-attributes-translation-alist'."
(if eudc-protocol-attributes-translation-alist
- (mapcar '(lambda (attribute)
- (let ((trans (assq (car attribute)
- (symbol-value eudc-protocol-attributes-translation-alist))))
- (if trans
- (cons (cdr trans) (cdr attribute))
- attribute)))
+ (mapcar (lambda (attribute)
+ (let ((trans (assq (car attribute)
+ (symbol-value eudc-protocol-attributes-translation-alist))))
+ (if trans
+ (cons (cdr trans) (cdr attribute))
+ attribute)))
query)
query))
`eudc-protocol-attributes-translation-alist'."
(if eudc-protocol-attributes-translation-alist
(let (trans)
- (mapcar '(lambda (attribute)
+ (mapcar (lambda (attribute)
(setq trans (assq attribute
(symbol-value eudc-protocol-attributes-translation-alist)))
(if trans
(interactive (list
(read-from-minibuffer "Directory Server: ")
(intern (completing-read "Protocol: "
- (mapcar '(lambda (elt)
+ (mapcar (lambda (elt)
(cons (symbol-name elt)
elt))
eudc-known-protocols)))))
(> n 0))
(setq formats
(delq nil
- (mapcar '(lambda (format)
+ (mapcar (lambda (format)
(if (= n
(length format))
format
"Return RECORD if it matches `eudc-bbdb-current-query', nil otherwise."
(catch 'unmatch
(progn
- (mapc
- (function
- (lambda (condition)
- (let ((attr (car condition))
- (val (cdr condition))
- (case-fold-search t)
- bbdb-val)
- (or (and (memq attr '(firstname lastname aka company phones addresses net))
- (progn
- (setq bbdb-val
- (eval (list (intern (concat "bbdb-record-"
- (symbol-name attr)))
- 'record)))
- (if (listp bbdb-val)
- (if eudc-bbdb-enable-substring-matches
- (eval `(or ,@(mapcar '(lambda (subval)
- (string-match val
- subval))
- bbdb-val)))
- (member (downcase val)
- (mapcar 'downcase bbdb-val)))
- (if eudc-bbdb-enable-substring-matches
- (string-match val bbdb-val)
- (string-equal (downcase val) (downcase bbdb-val))))))
- (throw 'unmatch nil)))))
- eudc-bbdb-current-query)
+ (dolist (condition eudc-bbdb-current-query)
+ (let ((attr (car condition))
+ (val (cdr condition))
+ (case-fold-search t)
+ bbdb-val)
+ (or (and (memq attr '(firstname lastname aka company phones
+ addresses net))
+ (progn
+ (setq bbdb-val
+ (eval (list (intern (concat "bbdb-record-"
+ (symbol-name attr)))
+ 'record)))
+ (if (listp bbdb-val)
+ (if eudc-bbdb-enable-substring-matches
+ (eval `(or ,@(mapcar (lambda (subval)
+ (string-match val subval))
+ bbdb-val)))
+ (member (downcase val)
+ (mapcar 'downcase bbdb-val)))
+ (if eudc-bbdb-enable-substring-matches
+ (string-match val bbdb-val)
+ (string-equal (downcase val) (downcase bbdb-val))))))
+ (throw 'unmatch nil))))
record)))
;; External.
"Format the EUDC QUERY list as a RFC1558 LDAP search filter."
(format "(&%s)"
(apply 'concat
- (mapcar '(lambda (item)
- (format "(%s=%s)"
- (car item)
- (eudc-ldap-escape-query-special-chars (cdr item))))
+ (mapcar (lambda (item)
+ (format "(%s=%s)"
+ (car item)
+ (eudc-ldap-escape-query-special-chars (cdr item))))
query))))
'directory-file-name (list directory))))
(tramp-message vec 8 "%s" directory)
(maphash
- '(lambda (key value)
+ (lambda (key value)
(when (and (stringp (tramp-file-name-localname key))
(string-match directory (tramp-file-name-localname key)))
(remhash key tramp-cache-data)))
(add-hook 'eshell-pre-command-hook 'tramp-flush-file-function)
(add-hook 'kill-buffer-hook 'tramp-flush-file-function)
(add-hook 'tramp-cache-unload-hook
- '(lambda ()
+ (lambda ()
(remove-hook 'before-revert-hook
'tramp-flush-file-function)
(remove-hook 'eshell-pre-command-hook
(when (hash-table-p table)
(let (result)
(maphash
- '(lambda (key value)
+ (lambda (key value)
(let ((tmp (format
"(%s %s)"
(if (processp key)
"Return a list of all known connection vectors according to `tramp-cache'."
(let (result)
(maphash
- '(lambda (key value)
+ (lambda (key value)
(when (and (vectorp key) (null (aref key 3)))
(add-to-list 'result key)))
tramp-cache-data)
(let ((cache (copy-hash-table tramp-cache-data)))
;; Remove temporary data.
(maphash
- '(lambda (key value)
+ (lambda (key value)
(if (and (vectorp key) (not (tramp-file-name-localname key)))
(progn
(remhash "process-name" value)
(unless noninteractive
(add-hook 'kill-emacs-hook 'tramp-dump-connection-properties))
(add-hook 'tramp-cache-unload-hook
- '(lambda ()
+ (lambda ()
(remove-hook 'kill-emacs-hook
'tramp-dump-connection-properties)))
for all methods. Resulting data are derived from connection history."
(let (res)
(maphash
- '(lambda (key value)
+ (lambda (key value)
(if (and (vectorp key)
(string-equal method (tramp-file-name-method key))
(not (tramp-file-name-localname key)))
(dolist (buffer
(delq nil
(mapcar
- '(lambda (b)
- (when (string-match "\\*tramp/" (buffer-name b)) b))
+ (lambda (b)
+ (when (string-match "\\*tramp/" (buffer-name b)) b))
(buffer-list))))
(let ((reporter-eval-buffer buffer)
(buffer-name (buffer-name buffer))
;; handling.
(put 'substitute-in-file-name 'ange-ftp 'tramp-handle-substitute-in-file-name)
(add-hook 'tramp-ftp-unload-hook
- '(lambda ()
- (setplist 'substitute-in-file-name
- (delete 'ange-ftp
- (delete 'tramp-handle-substitute-in-file-name
- (symbol-plist
- 'substitute-in-file-name))))))
+ (lambda ()
+ (setplist 'substitute-in-file-name
+ (delete 'ange-ftp
+ (delete 'tramp-handle-substitute-in-file-name
+ (symbol-plist
+ 'substitute-in-file-name))))))
;;;###tramp-autoload
(defun tramp-ftp-file-name-handler (operation &rest args)
(or (null str) (string-match "^[ \t]*$" str)))
(defun webjump-url-encode (str)
- (mapconcat '(lambda (c)
- (let ((s (char-to-string c)))
- (cond ((string= s " ") "+")
- ((string-match "[a-zA-Z_.-/]" s) s)
- (t (upcase (format "%%%02x" c))))))
+ (mapconcat (lambda (c)
+ (let ((s (char-to-string c)))
+ (cond ((string= s " ") "+")
+ ((string-match "[a-zA-Z_.-/]" s) s)
+ (t (upcase (format "%%%02x" c))))))
(encode-coding-string str 'utf-8)
""))
(push (concat (nth 3 lang-words) "\n") thetoc)
(push (concat (make-string (string-width (nth 3 lang-words)) ?=)
"\n") thetoc)
- (mapc '(lambda (line)
- (if (string-match org-todo-line-regexp
- line)
- ;; This is a headline
- (progn
- (setq have-headings t)
- (setq level (- (match-end 1) (match-beginning 1)
- level-offset)
- level (org-tr-level level)
- txt (match-string 3 line)
- todo
- (or (and org-export-mark-todo-in-toc
- (match-beginning 2)
- (not (member (match-string 2 line)
- org-done-keywords)))
+ (mapc (lambda (line)
+ (if (string-match org-todo-line-regexp
+ line)
+ ;; This is a headline
+ (progn
+ (setq have-headings t)
+ (setq level (- (match-end 1) (match-beginning 1)
+ level-offset)
+ level (org-tr-level level)
+ txt (match-string 3 line)
+ todo
+ (or (and org-export-mark-todo-in-toc
+ (match-beginning 2)
+ (not (member (match-string 2 line)
+ org-done-keywords)))
; TODO, not DONE
- (and org-export-mark-todo-in-toc
- (= level umax-toc)
- (org-search-todo-below
- line lines level))))
- (setq txt (org-html-expand-for-ascii txt))
-
- (while (string-match org-bracket-link-regexp txt)
- (setq txt
- (replace-match
- (match-string (if (match-end 2) 3 1) txt)
- t t txt)))
-
- (if (and (memq org-export-with-tags '(not-in-toc nil))
- (string-match
- (org-re "[ \t]+:[[:alnum:]_@#%:]+:[ \t]*$")
- txt))
- (setq txt (replace-match "" t t txt)))
- (if (string-match quote-re0 txt)
- (setq txt (replace-match "" t t txt)))
-
- (if org-export-with-section-numbers
- (setq txt (concat (org-section-number level)
- " " txt)))
- (if (<= level umax-toc)
- (progn
- (push
- (concat
- (make-string
- (* (max 0 (- level org-min-level)) 4) ?\ )
- (format (if todo "%s (*)\n" "%s\n") txt))
- thetoc)
- (setq org-last-level level))
- ))))
+ (and org-export-mark-todo-in-toc
+ (= level umax-toc)
+ (org-search-todo-below
+ line lines level))))
+ (setq txt (org-html-expand-for-ascii txt))
+
+ (while (string-match org-bracket-link-regexp txt)
+ (setq txt
+ (replace-match
+ (match-string (if (match-end 2) 3 1) txt)
+ t t txt)))
+
+ (if (and (memq org-export-with-tags '(not-in-toc nil))
+ (string-match
+ (org-re "[ \t]+:[[:alnum:]_@#%:]+:[ \t]*$")
+ txt))
+ (setq txt (replace-match "" t t txt)))
+ (if (string-match quote-re0 txt)
+ (setq txt (replace-match "" t t txt)))
+
+ (if org-export-with-section-numbers
+ (setq txt (concat (org-section-number level)
+ " " txt)))
+ (if (<= level umax-toc)
+ (progn
+ (push
+ (concat
+ (make-string
+ (* (max 0 (- level org-min-level)) 4) ?\ )
+ (format (if todo "%s (*)\n" "%s\n") txt))
+ thetoc)
+ (setq org-last-level level))
+ ))))
lines)
(setq thetoc (if have-headings (nreverse thetoc) nil))))
(cd dir)
(shell-command "git add .")
(shell-command "git ls-files --deleted" t)
- (mapc '(lambda (file)
- (unless (string= file "")
- (shell-command
- (concat "git rm \"" file "\""))))
+ (mapc (lambda (file)
+ (unless (string= file "")
+ (shell-command
+ (concat "git rm \"" file "\""))))
(split-string (buffer-string) "\n"))
(shell-command "git commit -m 'Synchronized attachments'")))))
markup (org-symname-or-string (pop params))
lang (and (member markup '("src" "SRC"))
(org-symname-or-string (pop params)))
- switches (mapconcat '(lambda (x) (format "%s" x)) params " ")
+ switches (mapconcat (lambda (x) (format "%s" x)) params " ")
start nil end nil)
(delete-region (match-beginning 0) (match-end 0))
(if (or (not file)
(push "<div id=\"text-table-of-contents\">\n" thetoc)
(push "<ul>\n<li>" thetoc)
(setq lines
- (mapcar '(lambda (line)
- (if (and (string-match org-todo-line-regexp line)
- (not (get-text-property 0 'org-protected line)))
- ;; This is a headline
- (progn
- (setq have-headings t)
- (setq level (- (match-end 1) (match-beginning 1)
- level-offset)
- level (org-tr-level level)
- txt (save-match-data
- (org-html-expand
- (org-export-cleanup-toc-line
- (match-string 3 line))))
- todo
- (or (and org-export-mark-todo-in-toc
- (match-beginning 2)
- (not (member (match-string 2 line)
- org-done-keywords)))
+ (mapcar (lambda (line)
+ (if (and (string-match org-todo-line-regexp line)
+ (not (get-text-property 0 'org-protected line)))
+ ;; This is a headline
+ (progn
+ (setq have-headings t)
+ (setq level (- (match-end 1) (match-beginning 1)
+ level-offset)
+ level (org-tr-level level)
+ txt (save-match-data
+ (org-html-expand
+ (org-export-cleanup-toc-line
+ (match-string 3 line))))
+ todo
+ (or (and org-export-mark-todo-in-toc
+ (match-beginning 2)
+ (not (member (match-string 2 line)
+ org-done-keywords)))
; TODO, not DONE
- (and org-export-mark-todo-in-toc
- (= level umax-toc)
- (org-search-todo-below
- line lines level))))
- (if (string-match
- (org-re "[ \t]+:\\([[:alnum:]_@:]+\\):[ \t]*$") txt)
- (setq txt (replace-match " <span class=\"tag\"> \\1</span>" t nil txt)))
- (if (string-match quote-re0 txt)
- (setq txt (replace-match "" t t txt)))
- (setq snumber (org-section-number level))
- (if org-export-with-section-numbers
- (setq txt (concat snumber " " txt)))
- (if (<= level (max umax umax-toc))
- (setq head-count (+ head-count 1)))
- (if (<= level umax-toc)
- (progn
- (if (> level org-last-level)
- (progn
- (setq cnt (- level org-last-level))
- (while (>= (setq cnt (1- cnt)) 0)
- (push "\n<ul>\n<li>" thetoc))
- (push "\n" thetoc)))
- (if (< level org-last-level)
- (progn
- (setq cnt (- org-last-level level))
- (while (>= (setq cnt (1- cnt)) 0)
- (push "</li>\n</ul>" thetoc))
- (push "\n" thetoc)))
- ;; Check for targets
- (while (string-match org-any-target-regexp line)
- (setq line (replace-match
- (concat "@<span class=\"target\">" (match-string 1 line) "@</span> ")
- t t line)))
- (while (string-match "<\\(<\\)+\\|>\\(>\\)+" txt)
- (setq txt (replace-match "" t t txt)))
- (setq href
- (replace-regexp-in-string
- "\\." "_" (format "sec-%s" snumber)))
- (setq href (or (cdr (assoc href org-export-preferred-target-alist)) href))
- (push
- (format
- (if todo
- "</li>\n<li><a href=\"#%s\"><span class=\"todo\">%s</span></a>"
- "</li>\n<li><a href=\"#%s\">%s</a>")
- href txt) thetoc)
-
- (setq org-last-level level))
- )))
- line)
+ (and org-export-mark-todo-in-toc
+ (= level umax-toc)
+ (org-search-todo-below
+ line lines level))))
+ (if (string-match
+ (org-re "[ \t]+:\\([[:alnum:]_@:]+\\):[ \t]*$") txt)
+ (setq txt (replace-match " <span class=\"tag\"> \\1</span>" t nil txt)))
+ (if (string-match quote-re0 txt)
+ (setq txt (replace-match "" t t txt)))
+ (setq snumber (org-section-number level))
+ (if org-export-with-section-numbers
+ (setq txt (concat snumber " " txt)))
+ (if (<= level (max umax umax-toc))
+ (setq head-count (+ head-count 1)))
+ (if (<= level umax-toc)
+ (progn
+ (if (> level org-last-level)
+ (progn
+ (setq cnt (- level org-last-level))
+ (while (>= (setq cnt (1- cnt)) 0)
+ (push "\n<ul>\n<li>" thetoc))
+ (push "\n" thetoc)))
+ (if (< level org-last-level)
+ (progn
+ (setq cnt (- org-last-level level))
+ (while (>= (setq cnt (1- cnt)) 0)
+ (push "</li>\n</ul>" thetoc))
+ (push "\n" thetoc)))
+ ;; Check for targets
+ (while (string-match org-any-target-regexp line)
+ (setq line (replace-match
+ (concat "@<span class=\"target\">" (match-string 1 line) "@</span> ")
+ t t line)))
+ (while (string-match "<\\(<\\)+\\|>\\(>\\)+" txt)
+ (setq txt (replace-match "" t t txt)))
+ (setq href
+ (replace-regexp-in-string
+ "\\." "_" (format "sec-%s" snumber)))
+ (setq href (or (cdr (assoc href org-export-preferred-target-alist)) href))
+ (push
+ (format
+ (if todo
+ "</li>\n<li><a href=\"#%s\"><span class=\"todo\">%s</span></a>"
+ "</li>\n<li><a href=\"#%s\">%s</a>")
+ href txt) thetoc)
+
+ (setq org-last-level level))
+ )))
+ line)
lines))
(while (> org-last-level (1- org-min-level))
(setq org-last-level (1- org-last-level))
("Check Tags"
,@(org-mouse-keyword-menu
(sort (mapcar 'car (org-get-buffer-tags)) 'string-lessp)
- '(lambda (tag) (org-tags-sparse-tree nil tag)))
+ (lambda (tag) (org-tags-sparse-tree nil tag)))
"--"
["Custom Tag ..." org-tags-sparse-tree t])
["Check Phrase ..." org-occur]
("Display Tags"
,@(org-mouse-keyword-menu
(sort (mapcar 'car (org-get-buffer-tags)) 'string-lessp)
- '(lambda (tag) (org-tags-view nil tag)))
+ (lambda (tag) (org-tags-view nil tag)))
"--"
["Custom Tag ..." org-tags-view t])
["Display Calendar" org-goto-calendar t]
"--"
,@(org-mouse-keyword-menu
(mapcar 'car org-agenda-custom-commands)
- '(lambda (key)
+ (lambda (key)
(eval `(flet ((read-char-exclusive () (string-to-char ,key)))
(org-agenda nil))))
nil
- '(lambda (key)
+ (lambda (key)
(let ((entry (assoc key org-agenda-custom-commands)))
(org-mouse-clip-text
(cond
("Tags and Priorities"
,@(org-mouse-keyword-menu
(org-mouse-priority-list)
- '(lambda (keyword)
+ (lambda (keyword)
(org-mouse-set-priority (string-to-char keyword)))
priority "Priority %s")
"--"
(mouse-drag-region event)))
(add-hook 'org-mode-hook
- '(lambda ()
+ (lambda ()
(setq org-mouse-context-menu-function 'org-mouse-context-menu)
(when (memq 'context-menu org-mouse-features)
; (setq org-agenda-mode-hook nil)
(add-hook 'org-agenda-mode-hook
- '(lambda ()
+ (lambda ()
(setq org-mouse-context-menu-function 'org-mouse-agenda-context-menu)
(org-defkey org-agenda-mode-map [mouse-3] 'org-mouse-show-context-menu)
(org-defkey org-agenda-mode-map [down-mouse-3] 'org-mouse-move-tree-start)
(org-defkey org-agenda-mode-map [C-mouse-4] 'org-agenda-earlier)
(org-defkey org-agenda-mode-map [C-mouse-5] 'org-agenda-later)
(org-defkey org-agenda-mode-map [drag-mouse-3]
- '(lambda (event) (interactive "e")
+ (lambda (event) (interactive "e")
(case (org-mouse-get-gesture event)
(:left (org-agenda-earlier 1))
(:right (org-agenda-later 1)))))))
(defun org-src-mode-configure-edit-buffer ()
(when (org-bound-and-true-p org-edit-src-from-org-mode)
(org-add-hook 'kill-buffer-hook
- '(lambda () (delete-overlay org-edit-src-overlay)) nil 'local)
+ (lambda () (delete-overlay org-edit-src-overlay)) nil 'local)
(if (org-bound-and-true-p org-edit-src-allow-write-back-p)
(progn
(setq buffer-offer-save t)
(const :tag "no confirmation (dangerous)" nil)))
(put 'org-confirm-shell-link-function
'safe-local-variable
- '(lambda (x) (member x '(yes-or-no-p y-or-n-p))))
+ (lambda (x) (member x '(yes-or-no-p y-or-n-p))))
(defcustom org-confirm-elisp-link-function 'yes-or-no-p
"Non-nil means ask for confirmation before executing Emacs Lisp links.
(const :tag "no confirmation (dangerous)" nil)))
(put 'org-confirm-shell-link-function
'safe-local-variable
- '(lambda (x) (member x '(yes-or-no-p y-or-n-p))))
+ (lambda (x) (member x '(yes-or-no-p y-or-n-p))))
(defconst org-file-apps-defaults-gnu
'((remote . emacs)
and by using a prefix arg to `S-up/down' to specify the exact number
of minutes to shift."
:group 'org-time
- :get '(lambda (var) ; Make sure both elements are there
+ :get (lambda (var) ; Make sure both elements are there
(if (integerp (default-value var))
(list (default-value var) 5)
(default-value var)))
If the file does not specify a category, then file's base name
is used instead.")
(make-variable-buffer-local 'org-category)
-(put 'org-category 'safe-local-variable '(lambda (x) (or (symbolp x) (stringp x))))
+(put 'org-category 'safe-local-variable (lambda (x) (or (symbolp x) (stringp x))))
(defcustom org-agenda-files nil
"The files to be used for agenda display.
;; I have also this in my .gnus:
;;(add-hook 'gnus-article-mode-hook
-;; '(lambda ()
+;; (lambda ()
;; (define-key gnus-article-mode-map "i" 'fortune-from-region)))
;; which allows marking a region and then pressing "i" so that the marked
;; region will be automatically added to my favourite fortune-file.
(pargs (cdr (car flist))))
(setq command
(concat command " | " pcom " "
- (mapconcat '(lambda (phrase)
- (if (not (stringp phrase))
- (error "Malformed Man-filter-list"))
- phrase)
+ (mapconcat (lambda (phrase)
+ (if (not (stringp phrase))
+ (error "Malformed Man-filter-list"))
+ phrase)
pargs " ")))
(setq flist (cdr flist))))
command))
;; To customize f90-mode for your taste, use, for example:
;; (you don't have to specify values for all the parameters below)
;;
-;;(add-hook 'f90-mode-hook
-;; ;; These are the default values.
-;; '(lambda () (setq f90-do-indent 3
+;; (add-hook 'f90-mode-hook
+;; ;; These are the default values.
+;; (lambda () (setq f90-do-indent 3
;; f90-if-indent 3
;; f90-type-indent 3
;; f90-program-indent 2
;; Don't bind "q" to kill-this-buffer as we need it for breakpoint icons.
(define-key map "q" 'gdb-delete-frame-or-window)
(define-key map "\r" 'gdb-goto-breakpoint)
- (define-key map "\t" '(lambda ()
+ (define-key map "\t" (lambda ()
(interactive)
(gdb-set-window-buffer
(gdb-get-buffer-create 'gdb-threads-buffer) t)))
(define-key map "i" 'gdb-interrupt-thread)
(define-key map "c" 'gdb-continue-thread)
(define-key map "s" 'gdb-step-thread)
- (define-key map "\t" '(lambda ()
+ (define-key map "\t" (lambda ()
(interactive)
(gdb-set-window-buffer
(gdb-get-buffer-create 'gdb-breakpoints-buffer) t)))
(let ((map (make-sparse-keymap)))
(suppress-keymap map)
(define-key map "q" 'kill-this-buffer)
- (define-key map "\t" '(lambda ()
+ (define-key map "\t" (lambda ()
(interactive)
(gdb-set-window-buffer
(gdb-get-buffer-create
(define-key map "\r" 'gdb-edit-register-value)
(define-key map [mouse-2] 'gdb-edit-register-value)
(define-key map "q" 'kill-this-buffer)
- (define-key map "\t" '(lambda ()
+ (define-key map "\t" (lambda ()
(interactive)
(gdb-set-window-buffer
(gdb-get-buffer-create
(display-buffer-reuse-frames t))
(catch 'info-found
(walk-windows
- '(lambda (window)
- (if (eq (window-buffer window) (get-buffer "*info*"))
- (progn
- (setq same-window-regexps nil)
- (throw 'info-found nil))))
+ (lambda (window)
+ (if (eq (window-buffer window) (get-buffer "*info*"))
+ (progn
+ (setq same-window-regexps nil)
+ (throw 'info-found nil))))
nil 0)
(select-frame (make-frame)))
(if (eq gud-minor-mode 'gdbmi)
((or idlwave-help-browser-is-local
(string-match "w3" (symbol-name idlwave-help-browser-function)))
- (idlwave-help-display-help-window '(lambda () (browse-url full-link))))
+ (idlwave-help-display-help-window (lambda () (browse-url full-link))))
(t (browse-url full-link)))))
(define-key idlwave-shell-electric-debug-mode-map "_"
'idlwave-shell-stack-down)
(define-key idlwave-shell-electric-debug-mode-map "e"
- '(lambda () (interactive) (idlwave-shell-print '(16))))
+ (lambda () (interactive) (idlwave-shell-print '(16))))
(define-key idlwave-shell-electric-debug-mode-map "q" 'idlwave-shell-retall)
(define-key idlwave-shell-electric-debug-mode-map "t"
- '(lambda () (interactive) (idlwave-shell-send-command "help,/TRACE")))
+ (lambda () (interactive) (idlwave-shell-send-command "help,/TRACE")))
(define-key idlwave-shell-electric-debug-mode-map [(control ??)]
'idlwave-shell-electric-debug-help)
(define-key idlwave-shell-electric-debug-mode-map "x"
- '(lambda (arg) (interactive "P")
- (idlwave-shell-print arg nil nil t)))
+ (lambda (arg) (interactive "P")
+ (idlwave-shell-print arg nil nil t)))
; Enter the prefix map in two places.
(let* ((completion-ignore-case t)
;; we already have a list, but it is not in the right format
;; transform it to a valid table so completition can use it
- (table (mapcar '(lambda (elm)
- (cons (symbol-name (car elm)) nil))
+ (table (mapcar (lambda (elm) (cons (symbol-name (car elm)) nil))
mixal-operation-codes-alist))
;; prompt is different depending on we are close to a valid op-code
(have-default (assq (intern-soft (current-word))
(features (cons 'python-mode features))) ; and requires this
(brm-init) ; second line of normal recipe
(remove-hook 'python-mode-hook ; undo this from `brm-init'
- '(lambda () (easy-menu-add brm-menu)))
+ (lambda () (easy-menu-add brm-menu)))
(easy-menu-define
python-brm-menu python-mode-map
"Bicycle Repair Man"
(mapc
;; In Emacs 22+, provide SYSTEM-FLAG to define-abbrev.
- '(lambda (abbrev)
- (let ((name (car abbrev))
- (expansion (cdr abbrev)))
- (condition-case nil
- (define-abbrev sql-mode-abbrev-table name expansion nil 0 t)
- (error
- (define-abbrev sql-mode-abbrev-table name expansion)))))
+ (lambda (abbrev)
+ (let ((name (car abbrev))
+ (expansion (cdr abbrev)))
+ (condition-case nil
+ (define-abbrev sql-mode-abbrev-table name expansion nil 0 t)
+ (error
+ (define-abbrev sql-mode-abbrev-table name expansion)))))
'(("ins" . "insert")
("upd" . "update")
("del" . "delete")
(verilog-mode))))
(buffer-list))
;; Process the files
- (mapcar '(lambda (buf)
+ (mapcar (lambda (buf)
(when (buffer-file-name buf)
(save-excursion
(if (not (file-exists-p (buffer-file-name buf)))
(defun verilog-keyword-completion (keyword-list)
"Give list of all possible completions of keywords in KEYWORD-LIST."
- (mapcar '(lambda (s)
+ (mapcar (lambda (s)
(if (string-match (concat "\\<" verilog-str) s)
(if (or (null verilog-pred)
(funcall verilog-pred s))
(all-completions verilog-str 'verilog-completion)))
(match (if verilog-toggle-completions
"" (try-completion
- verilog-str (mapcar '(lambda (elm)
+ verilog-str (mapcar (lambda (elm)
(cons elm 0)) allcomp)))))
;; Delete old string
(delete-region b e)
(verilog-auto-re-search-do "/\\*AUTOINOUTCOMP([^)]*)\\*/" 'verilog-auto-inout-comp)
;; next in/outs which need previous sucked inputs first
(verilog-auto-re-search-do "/\\*AUTOOUTPUT\\((\"[^\"]*\")\\)\\*/"
- '(lambda () (verilog-auto-output t)))
+ (lambda () (verilog-auto-output t)))
(verilog-auto-re-search-do "/\\*AUTOOUTPUT\\*/" 'verilog-auto-output)
(verilog-auto-re-search-do "/\\*AUTOINPUT\\((\"[^\"]*\")\\)\\*/"
- '(lambda () (verilog-auto-input t)))
+ (lambda () (verilog-auto-input t)))
(verilog-auto-re-search-do "/\\*AUTOINPUT\\*/" 'verilog-auto-input)
(verilog-auto-re-search-do "/\\*AUTOINOUT\\((\"[^\"]*\")\\)\\*/"
- '(lambda () (verilog-auto-inout t)))
+ (lambda () (verilog-auto-inout t)))
(verilog-auto-re-search-do "/\\*AUTOINOUT\\*/" 'verilog-auto-inout)
;; Then tie off those in/outs
(verilog-auto-re-search-do "/\\*AUTOTIEOFF\\*/" 'verilog-auto-tieoff)
;; (setq ps-font-info-database '(<your stuff> <the standard stuff>))
;; or, use `ps-print-hook' (see section Hooks):
;; (add-hook 'ps-print-hook
-;; '(lambda ()
+;; (lambda ()
;; (or (assq 'Helvetica ps-font-info-database)
;; (setq ps-font-info-database (append ...)))))
;;
(setq x
(sort
(copy-sequence serial-speed-history)
- '(lambda (a b) (when (and (stringp a) (stringp b))
- (> (string-to-number a) (string-to-number b))))))
+ (lambda (a b) (when (and (stringp a) (stringp b))
+ (> (string-to-number a) (string-to-number b))))))
(dolist (i x) (when (not (equal i (car y))) (push i y)))
y))
(define-key map [t] 'te-pass-through)
(define-key map [switch-frame] 'handle-switch-frame)
(define-key map "\e" terminal-meta-map)
- ;(define-key map "\C-l"
- ; '(lambda () (interactive) (te-pass-through) (redraw-display)))
+ ;;(define-key map "\C-l"
+ ;; (lambda () (interactive) (te-pass-through) (redraw-display)))
(setq terminal-map map)))
(defvar terminal-escape-map nil)
;;* using flyspell with mail-mode add the following expression */
;;* in your .emacs file: */
;;* (add-hook 'mail-mode */
-;;* '(lambda () (setq flyspell-generic-check-word-predicate */
+;;* (lambda () (setq flyspell-generic-check-word-predicate */
;;* 'mail-mode-flyspell-verify))) */
;;*---------------------------------------------------------------------*/
(defvar flyspell-generic-check-word-predicate nil
(let ((fattribs-list (file-attributes f)))
`(,(nth 4 fattribs-list) ,(nth 7 fattribs-list) ,f)))
(directory-files (thumbs-thumbsdir) t (image-file-name-regexp)))
- '(lambda (l1 l2) (time-less-p (car l1) (car l2)))))
+ (lambda (l1 l2) (time-less-p (car l1) (car l2)))))
(dirsize (apply '+ (mapcar (lambda (x) (cadr x)) files-list))))
(while (> dirsize thumbs-thumbsdir-max-size)
(progn
If nil, use local time.
If t, use universal time.")
(put 'add-log-time-zone-rule 'safe-local-variable
- '(lambda (x) (or (booleanp x) (stringp x))))
+ (lambda (x) (or (booleanp x) (stringp x))))
(defun add-log-iso8601-time-zone (&optional time)
(let* ((utc-offset (or (car (current-time-zone time)) 0))
(set (make-local-variable 'fill-indent-according-to-mode) t)
;; Avoid that filling leaves behind a single "*" on a line.
(add-hook 'fill-nobreak-predicate
- '(lambda ()
- (looking-back "^\\s *\\*\\s *" (line-beginning-position)))
+ (lambda ()
+ (looking-back "^\\s *\\*\\s *" (line-beginning-position)))
nil t)
(set (make-local-variable 'indent-line-function) 'change-log-indent)
(set (make-local-variable 'tab-always-indent) nil)
;; The following functions must precede all defcustom-defined variables.
-(fset 'ediff-set-actual-diff-options '(lambda () nil))
+(fset 'ediff-set-actual-diff-options (lambda () nil))
(defcustom ediff-shell
(cond ((memq system-type '(ms-dos windows-nt))
'ediff-get-lines-to-region-start)
((eq op 'scroll-up)
'ediff-get-lines-to-region-end)
- (t '(lambda (a b c) 0))))
+ (t (lambda (a b c) 0))))
(max-lines (max (funcall func 'A n ctl-buf)
(funcall func 'B n ctl-buf)
(if (ediff-buffer-live-p ediff-buffer-C)