1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-06 06:20:55 -08:00

Remove redundant #' before lambda

* admin/unidata/unidata-gen.el (unidata-gen-table)
(unidata-gen-table-symbol, unidata-gen-table-integer)
(unidata-gen-table-numeric, unidata-gen-table-word-list)
(unidata-describe-decomposition):
* lisp/apropos.el (apropos-user-option):
* lisp/bookmark.el (bookmark-bmenu-search):
* lisp/composite.el (unicode-category-table):
* lisp/elec-pair.el (electric-pair--balance-info):
* lisp/electric.el (electric-quote-chars):
* lisp/emulation/cua-base.el (cua-rectangle-mark-key):
* lisp/epa-hook.el (epa-file-encrypt-to):
* lisp/faces.el (face-font-selection-order)
(face-font-family-alternatives, face-font-registry-alternatives)
(face-valid-attribute-values, tty-run-terminal-initialization):
* lisp/files.el (recover-file, file-expand-wildcards):
* lisp/frame.el (frames-on-display-list):
* lisp/help-at-pt.el (help-at-pt-display-when-idle):
* lisp/help-fns.el (help-fns--face-attributes):
* lisp/ido.el (ido-mode, ido-unc-hosts):
* lisp/isearch.el (isearch-highlight-regexp)
(isearch-highlight-lines-matching-regexp):
* lisp/language/indian.el (script-regexp-alist):
* lisp/language/lao.el:
* lisp/leim/quail/ipa.el (ipa-x-sampa-prepend-to-keymap-entry):
* lisp/mh-e/mh-folder.el (mh-process-commands):
* lisp/mh-e/mh-mime.el (mh-display-with-external-viewer):
* lisp/ps-mule.el (ps-mule-end-job):
* lisp/ps-print.el (ps-color-scale, ps-background-pages)
(ps-background-text, ps-background-image, ps-background)
(ps-begin-job, ps-print-translation-table):
* lisp/recentf.el (recentf-sort-ascending)
(recentf-sort-descending, recentf-sort-basenames-ascending)
(recentf-sort-basenames-descending)
(recentf-sort-directories-ascending)
(recentf-sort-directories-descending):
* lisp/replace.el (occur-engine-add-prefix):
* lisp/select.el (xselect--encode-string):
* lisp/server.el (server-use-tcp):
* lisp/ses.el (ses-sort-column):
* lisp/sort.el (sort-columns):
* lisp/term/ns-win.el (window-system-initialization):
* lisp/tree-widget.el (tree-widget-image-formats):
* lisp/whitespace.el (whitespace-report-region): Remove redundant #'
before lambda.
This commit is contained in:
Stefan Kangas 2021-10-21 23:35:07 +02:00
parent 6352e0a555
commit 357d273d2e
31 changed files with 385 additions and 388 deletions

View file

@ -583,17 +583,17 @@ Property value is a symbol `o' (Open), `c' (Close), or `n' (None)."
(aset vec (- range start) val-code)) (aset vec (- range start) val-code))
(setq tail (cdr tail))) (setq tail (cdr tail)))
(setq str "\002" val-code -1 count 0) (setq str "\002" val-code -1 count 0)
(mapc #'(lambda (x) (mapc (lambda (x)
(if (= val-code x) (if (= val-code x)
(setq count (1+ count)) (setq count (1+ count))
(if (> count 2) (if (> count 2)
(setq str (concat str (string val-code (setq str (concat str (string val-code
(+ count 128)))) (+ count 128))))
(if (= count 2) (if (= count 2)
(setq str (concat str (string val-code val-code))) (setq str (concat str (string val-code val-code)))
(if (= count 1) (if (= count 1)
(setq str (concat str (string val-code)))))) (setq str (concat str (string val-code))))))
(setq val-code x count 1))) (setq val-code x count 1)))
vec) vec)
(if (= count 128) (if (= count 128)
(if val (if val
@ -613,8 +613,8 @@ Property value is a symbol `o' (Open), `c' (Close), or `n' (None)."
(defun unidata-gen-table-symbol (prop index default-value val-list) (defun unidata-gen-table-symbol (prop index default-value val-list)
(let ((table (unidata-gen-table prop index (let ((table (unidata-gen-table prop index
#'(lambda (x) (and (> (length x) 0) (lambda (x) (and (> (length x) 0)
(intern x))) (intern x)))
default-value val-list))) default-value val-list)))
(set-char-table-extra-slot table 1 0) (set-char-table-extra-slot table 1 0)
(set-char-table-extra-slot table 2 1) (set-char-table-extra-slot table 2 1)
@ -622,8 +622,8 @@ Property value is a symbol `o' (Open), `c' (Close), or `n' (None)."
(defun unidata-gen-table-integer (prop index default-value val-list) (defun unidata-gen-table-integer (prop index default-value val-list)
(let ((table (unidata-gen-table prop index (let ((table (unidata-gen-table prop index
#'(lambda (x) (and (> (length x) 0) (lambda (x) (and (> (length x) 0)
(string-to-number x))) (string-to-number x)))
default-value val-list))) default-value val-list)))
(set-char-table-extra-slot table 1 0) (set-char-table-extra-slot table 1 0)
(set-char-table-extra-slot table 2 1) (set-char-table-extra-slot table 2 1)
@ -631,13 +631,13 @@ Property value is a symbol `o' (Open), `c' (Close), or `n' (None)."
(defun unidata-gen-table-numeric (prop index default-value val-list) (defun unidata-gen-table-numeric (prop index default-value val-list)
(let ((table (unidata-gen-table prop index (let ((table (unidata-gen-table prop index
#'(lambda (x) (lambda (x)
(if (string-match "/" x) (if (string-match "/" x)
(/ (float (string-to-number x)) (/ (float (string-to-number x))
(string-to-number (string-to-number
(substring x (match-end 0)))) (substring x (match-end 0))))
(if (> (length x) 0) (if (> (length x) 0)
(string-to-number x)))) (string-to-number x))))
default-value val-list))) default-value val-list)))
(set-char-table-extra-slot table 1 0) (set-char-table-extra-slot table 1 0)
(set-char-table-extra-slot table 2 2) (set-char-table-extra-slot table 2 2)
@ -1000,7 +1000,7 @@ Property value is a symbol `o' (Open), `c' (Close), or `n' (None)."
(cl-incf (alist-get elt (cdr word-list) 0))))) (cl-incf (alist-get elt (cdr word-list) 0)))))
(set-char-table-range table (cons start limit) vec)))))) (set-char-table-range table (cons start limit) vec))))))
(setq word-list (sort (cdr word-list) (setq word-list (sort (cdr word-list)
#'(lambda (x y) (> (cdr x) (cdr y))))) (lambda (x y) (> (cdr x) (cdr y)))))
(setq tail word-list idx 0) (setq tail word-list idx 0)
(while tail (while tail
(setcdr (car tail) (unidata-encode-word idx)) (setcdr (car tail) (unidata-encode-word idx))
@ -1266,11 +1266,11 @@ Property value is a symbol `o' (Open), `c' (Close), or `n' (None)."
(defun unidata-describe-decomposition (val) (defun unidata-describe-decomposition (val)
(mapconcat (mapconcat
#'(lambda (x) (lambda (x)
(if (symbolp x) (symbol-name x) (if (symbolp x) (symbol-name x)
(concat (string ?') (concat (string ?')
(compose-string (string x) 0 1 (string ?\t x ?\t)) (compose-string (string x) 0 1 (string ?\t x ?\t))
(string ?')))) (string ?'))))
val " ")) val " "))
(defun unidata-describe-bidi-bracket-type (val) (defun unidata-describe-bidi-bracket-type (val)

View file

@ -515,9 +515,9 @@ variables, not just user options."
current-prefix-arg)) current-prefix-arg))
(apropos-command pattern nil (apropos-command pattern nil
(if (or do-all apropos-do-all) (if (or do-all apropos-do-all)
#'(lambda (symbol) (lambda (symbol)
(and (boundp symbol) (and (boundp symbol)
(get symbol 'variable-documentation))) (get symbol 'variable-documentation)))
#'custom-variable-p))) #'custom-variable-p)))
;;;###autoload ;;;###autoload

View file

@ -2314,10 +2314,10 @@ Prompt with completion for the new path."
(lambda () (lambda ()
(setq timer (run-with-idle-timer (setq timer (run-with-idle-timer
bookmark-search-delay 'repeat bookmark-search-delay 'repeat
#'(lambda (buf) (lambda (buf)
(with-current-buffer buf (with-current-buffer buf
(bookmark-bmenu-filter-alist-by-regexp (bookmark-bmenu-filter-alist-by-regexp
(minibuffer-contents)))) (minibuffer-contents))))
(current-buffer)))) (current-buffer))))
(read-string "Pattern: ") (read-string "Pattern: ")
(when timer (cancel-timer timer) (setq timer nil))) (when timer (cancel-timer timer) (setq timer nil)))

View file

@ -739,9 +739,9 @@ All non-spacing characters have this function in
(let ((elt `([,(purecopy "\\c.\\c^+") 1 compose-gstring-for-graphic] (let ((elt `([,(purecopy "\\c.\\c^+") 1 compose-gstring-for-graphic]
[nil 0 compose-gstring-for-graphic]))) [nil 0 compose-gstring-for-graphic])))
(map-char-table (map-char-table
#'(lambda (key val) (lambda (key val)
(if (memq val '(Mn Mc Me)) (if (memq val '(Mn Mc Me))
(set-char-table-range composition-function-table key elt))) (set-char-table-range composition-function-table key elt)))
unicode-category-table)) unicode-category-table))
;; for dotted-circle ;; for dotted-circle
(aset composition-function-table #x25CC (aset composition-function-table #x25CC
@ -901,6 +901,4 @@ For more information on Auto Composition mode, see
(provide 'composite) (provide 'composite)
;;; composite.el ends here ;;; composite.el ends here

View file

@ -308,51 +308,51 @@ If point is not enclosed by any lists, return ((t) . (t))."
;; called when `scan-sexps' ran perfectly, when it found ;; called when `scan-sexps' ran perfectly, when it found
;; a parenthesis pointing in the direction of travel. ;; a parenthesis pointing in the direction of travel.
;; Also when travel started inside a comment and exited it. ;; Also when travel started inside a comment and exited it.
#'(lambda () (lambda ()
(setq outermost (list t)) (setq outermost (list t))
(unless innermost (unless innermost
(setq innermost (list t))))) (setq innermost (list t)))))
(ended-prematurely-fn (ended-prematurely-fn
;; called when `scan-sexps' crashed against a parenthesis ;; called when `scan-sexps' crashed against a parenthesis
;; pointing opposite the direction of travel. After ;; pointing opposite the direction of travel. After
;; traversing that character, the idea is to travel one sexp ;; traversing that character, the idea is to travel one sexp
;; in the opposite direction looking for a matching ;; in the opposite direction looking for a matching
;; delimiter. ;; delimiter.
#'(lambda () (lambda ()
(let* ((pos (point)) (let* ((pos (point))
(matched (matched
(save-excursion (save-excursion
(cond ((< direction 0) (cond ((< direction 0)
(condition-case nil (condition-case nil
(eq (char-after pos) (eq (char-after pos)
(electric-pair--with-uncached-syntax (electric-pair--with-uncached-syntax
(table) (table)
(matching-paren (matching-paren
(char-before (char-before
(scan-sexps (point) 1))))) (scan-sexps (point) 1)))))
(scan-error nil))) (scan-error nil)))
(t (t
;; In this case, no need to use ;; In this case, no need to use
;; `scan-sexps', we can use some ;; `scan-sexps', we can use some
;; `electric-pair--syntax-ppss' in this ;; `electric-pair--syntax-ppss' in this
;; case (which uses the quicker ;; case (which uses the quicker
;; `syntax-ppss' in some cases) ;; `syntax-ppss' in some cases)
(let* ((ppss (electric-pair--syntax-ppss (let* ((ppss (electric-pair--syntax-ppss
(1- (point)))) (1- (point))))
(start (car (last (nth 9 ppss)))) (start (car (last (nth 9 ppss))))
(opener (char-after start))) (opener (char-after start)))
(and start (and start
(eq (char-before pos) (eq (char-before pos)
(or (with-syntax-table table (or (with-syntax-table table
(matching-paren opener)) (matching-paren opener))
opener)))))))) opener))))))))
(actual-pair (if (> direction 0) (actual-pair (if (> direction 0)
(char-before (point)) (char-before (point))
(char-after (point))))) (char-after (point)))))
(unless innermost (unless innermost
(setq innermost (cons matched actual-pair))) (setq innermost (cons matched actual-pair)))
(unless matched (unless matched
(setq outermost (cons matched actual-pair))))))) (setq outermost (cons matched actual-pair)))))))
(save-excursion (save-excursion
(while (not outermost) (while (not outermost)
(condition-case err (condition-case err

View file

@ -506,11 +506,11 @@ This list's members correspond to left single quote, right single
quote, left double quote, and right double quote, respectively." quote, left double quote, and right double quote, respectively."
:version "26.1" :version "26.1"
:type '(list character character character character) :type '(list character character character character)
:safe #'(lambda (x) :safe (lambda (x)
(pcase x (pcase x
(`(,(pred characterp) ,(pred characterp) (`(,(pred characterp) ,(pred characterp)
,(pred characterp) ,(pred characterp)) ,(pred characterp) ,(pred characterp))
t))) t)))
:group 'electricity) :group 'electricity)
(defcustom electric-quote-paragraph t (defcustom electric-quote-paragraph t

View file

@ -396,17 +396,17 @@ and after the region marked by the rectangle to search."
(defcustom cua-rectangle-mark-key [(control return)] (defcustom cua-rectangle-mark-key [(control return)]
"Global key used to toggle the cua rectangle mark." "Global key used to toggle the cua rectangle mark."
:set #'(lambda (symbol value) :set (lambda (symbol value)
(set symbol value) (set symbol value)
(when (and (boundp 'cua--keymaps-initialized) (when (and (boundp 'cua--keymaps-initialized)
cua--keymaps-initialized) cua--keymaps-initialized)
(define-key cua-global-keymap value (define-key cua-global-keymap value
#'cua-set-rectangle-mark) #'cua-set-rectangle-mark)
(when (boundp 'cua--rectangle-keymap) (when (boundp 'cua--rectangle-keymap)
(define-key cua--rectangle-keymap value (define-key cua--rectangle-keymap value
#'cua-clear-rectangle-mark) #'cua-clear-rectangle-mark)
(define-key cua--region-keymap value (define-key cua--region-keymap value
#'cua-toggle-rectangle-mark)))) #'cua-toggle-rectangle-mark))))
:type 'key-sequence) :type 'key-sequence)
(defcustom cua-rectangle-modifier-key 'meta (defcustom cua-rectangle-modifier-key 'meta

View file

@ -56,15 +56,15 @@ through Custom does that automatically."
May either be a string or a list of strings.") May either be a string or a list of strings.")
(put 'epa-file-encrypt-to 'safe-local-variable (put 'epa-file-encrypt-to 'safe-local-variable
#'(lambda (val) (lambda (val)
(or (stringp val) (or (stringp val)
(and (listp val) (and (listp val)
(catch 'safe (catch 'safe
(mapc (lambda (elt) (mapc (lambda (elt)
(unless (stringp elt) (unless (stringp elt)
(throw 'safe nil))) (throw 'safe nil)))
val) val)
t))))) t)))))
(put 'epa-file-encrypt-to 'permanent-local t) (put 'epa-file-encrypt-to 'permanent-local t)

View file

@ -88,9 +88,9 @@ a font height that isn't optimal."
:tag "Font selection order" :tag "Font selection order"
:type '(list symbol symbol symbol symbol) :type '(list symbol symbol symbol symbol)
:group 'font-selection :group 'font-selection
:set #'(lambda (symbol value) :set (lambda (symbol value)
(set-default symbol value) (set-default symbol value)
(internal-set-font-selection-order value))) (internal-set-font-selection-order value)))
;; In the absence of Fontconfig support, Monospace and Sans Serif are ;; In the absence of Fontconfig support, Monospace and Sans Serif are
@ -140,9 +140,9 @@ ALTERNATIVE2 etc."
:tag "Alternative font families to try" :tag "Alternative font families to try"
:type '(repeat (repeat string)) :type '(repeat (repeat string))
:group 'font-selection :group 'font-selection
:set #'(lambda (symbol value) :set (lambda (symbol value)
(set-default symbol value) (set-default symbol value)
(internal-set-alternative-font-family-alist value))) (internal-set-alternative-font-family-alist value)))
;; This is defined originally in xfaces.c. ;; This is defined originally in xfaces.c.
@ -167,9 +167,9 @@ REGISTRY, ALTERNATIVE1, ALTERNATIVE2, and etc."
:type '(repeat (repeat string)) :type '(repeat (repeat string))
:version "21.1" :version "21.1"
:group 'font-selection :group 'font-selection
:set #'(lambda (symbol value) :set (lambda (symbol value)
(set-default symbol value) (set-default symbol value)
(internal-set-alternative-font-registry-alist value))) (internal-set-alternative-font-registry-alist value)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -1147,27 +1147,27 @@ an integer value."
(:foundry (:foundry
(list nil)) (list nil))
(:width (:width
(mapcar #'(lambda (x) (cons (symbol-name (aref x 1)) (aref x 1))) (mapcar (lambda (x) (cons (symbol-name (aref x 1)) (aref x 1)))
font-width-table)) font-width-table))
(:weight (:weight
(mapcar #'(lambda (x) (cons (symbol-name (aref x 1)) (aref x 1))) (mapcar (lambda (x) (cons (symbol-name (aref x 1)) (aref x 1)))
font-weight-table)) font-weight-table))
(:slant (:slant
(mapcar #'(lambda (x) (cons (symbol-name (aref x 1)) (aref x 1))) (mapcar (lambda (x) (cons (symbol-name (aref x 1)) (aref x 1)))
font-slant-table)) font-slant-table))
((or :inverse-video :extend) ((or :inverse-video :extend)
(mapcar #'(lambda (x) (cons (symbol-name x) x)) (mapcar (lambda (x) (cons (symbol-name x) x))
(internal-lisp-face-attribute-values attribute))) (internal-lisp-face-attribute-values attribute)))
((or :underline :overline :strike-through :box) ((or :underline :overline :strike-through :box)
(if (window-system frame) (if (window-system frame)
(nconc (mapcar #'(lambda (x) (cons (symbol-name x) x)) (nconc (mapcar (lambda (x) (cons (symbol-name x) x))
(internal-lisp-face-attribute-values attribute)) (internal-lisp-face-attribute-values attribute))
(mapcar #'(lambda (c) (cons c c)) (mapcar (lambda (c) (cons c c))
(defined-colors frame))) (defined-colors frame)))
(mapcar #'(lambda (x) (cons (symbol-name x) x)) (mapcar (lambda (x) (cons (symbol-name x) x))
(internal-lisp-face-attribute-values attribute)))) (internal-lisp-face-attribute-values attribute))))
((or :foreground :background) ((or :foreground :background)
(mapcar #'(lambda (c) (cons c c)) (mapcar (lambda (c) (cons c c))
(defined-colors frame))) (defined-colors frame)))
(:height (:height
'integerp) 'integerp)
@ -1182,7 +1182,7 @@ an integer value."
x-bitmap-file-path))))) x-bitmap-file-path)))))
(:inherit (:inherit
(cons '("none" . nil) (cons '("none" . nil)
(mapcar #'(lambda (c) (cons (symbol-name c) c)) (mapcar (lambda (c) (cons (symbol-name c) c))
(face-list)))) (face-list))))
(_ (_
(error "Internal error"))))) (error "Internal error")))))
@ -2286,19 +2286,19 @@ If you set `term-file-prefix' to nil, this function does nothing."
(let* (term-init-func) (let* (term-init-func)
;; First, load the terminal initialization file, if it is ;; First, load the terminal initialization file, if it is
;; available and it hasn't been loaded already. ;; available and it hasn't been loaded already.
(tty-find-type #'(lambda (type) (tty-find-type (lambda (type)
(let ((file (locate-library (concat term-file-prefix type)))) (let ((file (locate-library (concat term-file-prefix type))))
(and file (and file
(or (assoc file load-history) (or (assoc file load-history)
(load (replace-regexp-in-string (load (replace-regexp-in-string
"\\.el\\(\\.gz\\)?\\'" "" "\\.el\\(\\.gz\\)?\\'" ""
file) file)
t t))))) t t)))))
type) type)
;; Next, try to find a matching initialization function, and call it. ;; Next, try to find a matching initialization function, and call it.
(tty-find-type #'(lambda (type) (tty-find-type (lambda (type)
(fboundp (setq term-init-func (fboundp (setq term-init-func
(intern (concat "terminal-init-" type))))) (intern (concat "terminal-init-" type)))))
type) type)
(when (fboundp term-init-func) (when (fboundp term-init-func)
(funcall term-init-func)) (funcall term-init-func))

View file

@ -6682,12 +6682,12 @@ auto-save file, if that is more recent than the visited file."
(abbreviate-file-name file-name))) (abbreviate-file-name file-name)))
((with-temp-buffer-window ((with-temp-buffer-window
"*Directory*" nil "*Directory*" nil
#'(lambda (window _value) (lambda (window _value)
(with-selected-window window (with-selected-window window
(unwind-protect (unwind-protect
(yes-or-no-p (format "Recover auto save file %s? " file-name)) (yes-or-no-p (format "Recover auto save file %s? " file-name))
(when (window-live-p window) (when (window-live-p window)
(quit-restore-window window 'kill))))) (quit-restore-window window 'kill)))))
(with-current-buffer standard-output (with-current-buffer standard-output
(let ((switches dired-listing-switches)) (let ((switches dired-listing-switches))
(if (file-symlink-p file) (if (file-symlink-p file)
@ -7130,16 +7130,16 @@ default directory. However, if FULL is non-nil, they are absolute."
(let ((this-dir-contents (let ((this-dir-contents
;; Filter out "." and ".." ;; Filter out "." and ".."
(delq nil (delq nil
(mapcar #'(lambda (name) (mapcar (lambda (name)
(unless (string-match "\\`\\.\\.?\\'" (unless (string-match "\\`\\.\\.?\\'"
(file-name-nondirectory name)) (file-name-nondirectory name))
name)) name))
(directory-files (or dir ".") full (directory-files (or dir ".") full
(wildcard-to-regexp nondir)))))) (wildcard-to-regexp nondir))))))
(setq contents (setq contents
(nconc (nconc
(if (and dir (not full)) (if (and dir (not full))
(mapcar #'(lambda (name) (concat dir name)) (mapcar (lambda (name) (concat dir name))
this-dir-contents) this-dir-contents)
this-dir-contents) this-dir-contents)
contents))))) contents)))))

View file

@ -987,8 +987,8 @@ HOST:SERVER.SCREEN).
If DEVICE is omitted or nil, it defaults to the selected If DEVICE is omitted or nil, it defaults to the selected
frame's terminal device." frame's terminal device."
(let* ((terminal (get-device-terminal device)) (let* ((terminal (get-device-terminal device))
(func #'(lambda (frame) (func (lambda (frame)
(eq (frame-terminal frame) terminal)))) (eq (frame-terminal frame) terminal))))
(filtered-frame-list func))) (filtered-frame-list func)))
(defun framep-on-display (&optional terminal) (defun framep-on-display (&optional terminal)
@ -1165,9 +1165,9 @@ If you change this without using customize, you should use
`frame-set-background-mode' to update existing frames; `frame-set-background-mode' to update existing frames;
e.g. (mapc \\='frame-set-background-mode (frame-list))." e.g. (mapc \\='frame-set-background-mode (frame-list))."
:group 'faces :group 'faces
:set #'(lambda (var value) :set (lambda (var value)
(set-default var value) (set-default var value)
(mapc #'frame-set-background-mode (frame-list))) (mapc #'frame-set-background-mode (frame-list)))
:initialize #'custom-initialize-changed :initialize #'custom-initialize-changed
:type '(choice (const dark) :type '(choice (const dark)
(const light) (const light)

View file

@ -229,11 +229,11 @@ this option, or use \"In certain situations\" and specify no text
properties, to enable buffer local values." properties, to enable buffer local values."
never)) never))
:initialize 'custom-initialize-default :initialize 'custom-initialize-default
:set #'(lambda (variable value) :set (lambda (variable value)
(set-default variable value) (set-default variable value)
(if (eq value 'never) (if (eq value 'never)
(help-at-pt-cancel-timer) (help-at-pt-cancel-timer)
(help-at-pt-set-timer))) (help-at-pt-set-timer)))
:set-after '(help-at-pt-timer-delay) :set-after '(help-at-pt-timer-delay)
:require 'help-at-pt) :require 'help-at-pt)

View file

@ -1561,7 +1561,7 @@ If FRAME is omitted or nil, use the selected frame."
(:fontset . "Fontset") (:fontset . "Fontset")
(:extend . "Extend") (:extend . "Extend")
(:inherit . "Inherit"))) (:inherit . "Inherit")))
(max-width (apply #'max (mapcar #'(lambda (x) (length (cdr x))) (max-width (apply #'max (mapcar (lambda (x) (length (cdr x)))
attrs)))) attrs))))
(dolist (a attrs) (dolist (a attrs)
(let ((attr (face-attribute face (car a) frame))) (let ((attr (face-attribute face (car a) frame)))

View file

@ -354,8 +354,8 @@ The following values are possible:
Setting this variable directly does not take effect; Setting this variable directly does not take effect;
use either \\[customize] or the function `ido-mode'." use either \\[customize] or the function `ido-mode'."
:set #'(lambda (_symbol value) :set (lambda (_symbol value)
(ido-mode (or value 0))) (ido-mode (or value 0)))
:initialize #'custom-initialize-default :initialize #'custom-initialize-default
:require 'ido :require 'ido
:link '(emacs-commentary-link "ido.el") :link '(emacs-commentary-link "ido.el")
@ -620,9 +620,9 @@ hosts on first use of UNC path."
(function-item :tag "Use `NET VIEW'" (function-item :tag "Use `NET VIEW'"
:value ido-unc-hosts-net-view) :value ido-unc-hosts-net-view)
(function :tag "Your own function")) (function :tag "Your own function"))
:set #'(lambda (symbol value) :set (lambda (symbol value)
(set symbol value) (set symbol value)
(setq ido-unc-hosts-cache t))) (setq ido-unc-hosts-cache t)))
(defcustom ido-downcase-unc-hosts t (defcustom ido-downcase-unc-hosts t
"Non-nil if UNC host names should be downcased." "Non-nil if UNC host names should be downcased."

View file

@ -2478,8 +2478,8 @@ The arguments passed to `highlight-regexp' are the regexp from
the last search and the face from `hi-lock-read-face-name'." the last search and the face from `hi-lock-read-face-name'."
(interactive) (interactive)
(isearch--highlight-regexp-or-lines (isearch--highlight-regexp-or-lines
#'(lambda (regexp face lighter) (lambda (regexp face lighter)
(highlight-regexp regexp face nil lighter)))) (highlight-regexp regexp face nil lighter))))
(defun isearch-highlight-lines-matching-regexp () (defun isearch-highlight-lines-matching-regexp ()
"Exit Isearch mode and call `highlight-lines-matching-regexp'. "Exit Isearch mode and call `highlight-lines-matching-regexp'.
@ -2487,8 +2487,8 @@ The arguments passed to `highlight-lines-matching-regexp' are the
regexp from the last search and the face from `hi-lock-read-face-name'." regexp from the last search and the face from `hi-lock-read-face-name'."
(interactive) (interactive)
(isearch--highlight-regexp-or-lines (isearch--highlight-regexp-or-lines
#'(lambda (regexp face _lighter) (lambda (regexp face _lighter)
(highlight-lines-matching-regexp regexp face)))) (highlight-lines-matching-regexp regexp face))))
(defun isearch-delete-char () (defun isearch-delete-char ()

View file

@ -376,12 +376,12 @@ South Indian language Malayalam is supported in this language environment."))
(kannada . ,kannada-composable-pattern) (kannada . ,kannada-composable-pattern)
(malayalam . ,malayalam-composable-pattern)))) (malayalam . ,malayalam-composable-pattern))))
(map-char-table (map-char-table
#'(lambda (key val) (lambda (key val)
(let ((slot (assq val script-regexp-alist))) (let ((slot (assq val script-regexp-alist)))
(if slot (if slot
(set-char-table-range (set-char-table-range
composition-function-table key composition-function-table key
(list (vector (cdr slot) 0 #'font-shape-gstring)))))) (list (vector (cdr slot) 0 #'font-shape-gstring))))))
char-script-table)) char-script-table))
(provide 'indian) (provide 'indian)

View file

@ -59,11 +59,11 @@
(let* ((chars (car l)) (let* ((chars (car l))
(len (length chars)) (len (length chars))
;; Replace `c', `t', `v' to consonant, tone, and vowel. ;; Replace `c', `t', `v' to consonant, tone, and vowel.
(regexp (mapconcat #'(lambda (c) (regexp (mapconcat (lambda (c)
(cond ((= c ?c) consonant) (cond ((= c ?c) consonant)
((= c ?t) tone) ((= c ?t) tone)
((= c ?v) vowel-upper-lower) ((= c ?v) vowel-upper-lower)
(t (string c)))) (t (string c))))
(cdr l) "")) (cdr l) ""))
;; Element of composition-function-table. ;; Element of composition-function-table.
(elt (list (vector regexp 1 #'lao-composition-function) (elt (list (vector regexp 1 #'lao-composition-function)

View file

@ -278,10 +278,10 @@ string."
(list (list
(apply #'vector (apply #'vector
(mapcar (mapcar
#'(lambda (entry) (lambda (entry)
(cl-assert (char-or-string-p entry) t) (cl-assert (char-or-string-p entry) t)
(format "%s%s" to-prepend (format "%s%s" to-prepend
(if (integerp entry) (string entry) entry))) (if (integerp entry) (string entry) entry)))
quail-keymap)))) quail-keymap))))
(defun ipa-x-sampa-underscore-implosive (input-string length) (defun ipa-x-sampa-underscore-implosive (input-string length)

View file

@ -1543,34 +1543,34 @@ after the commands are processed."
(append folders-changed (mh-index-execute-commands)))) (append folders-changed (mh-index-execute-commands))))
;; Then refile messages ;; Then refile messages
(mapc #'(lambda (folder-msg-list) (mapc (lambda (folder-msg-list)
(let* ((dest-folder (symbol-name (car folder-msg-list))) (let* ((dest-folder (symbol-name (car folder-msg-list)))
(last (car (mh-translate-range dest-folder "last"))) (last (car (mh-translate-range dest-folder "last")))
(msgs (cdr folder-msg-list))) (msgs (cdr folder-msg-list)))
(push dest-folder folders-changed) (push dest-folder folders-changed)
(setq redraw-needed-flag t) (setq redraw-needed-flag t)
(apply #'mh-exec-cmd (apply #'mh-exec-cmd
"refile" "-src" folder dest-folder "refile" "-src" folder dest-folder
(mh-coalesce-msg-list msgs)) (mh-coalesce-msg-list msgs))
(mh-delete-scan-msgs msgs) (mh-delete-scan-msgs msgs)
;; Preserve sequences in destination folder... ;; Preserve sequences in destination folder...
(when mh-refile-preserves-sequences-flag (when mh-refile-preserves-sequences-flag
(clrhash dest-map) (clrhash dest-map)
(cl-loop (cl-loop
for i from (1+ (or last 0)) for i from (1+ (or last 0))
for msg in (sort (copy-sequence msgs) #'<) for msg in (sort (copy-sequence msgs) #'<)
do (cl-loop for seq-name in (gethash msg seq-map) do (cl-loop for seq-name in (gethash msg seq-map)
do (push i (gethash seq-name dest-map)))) do (push i (gethash seq-name dest-map))))
(maphash (maphash
#'(lambda (seq msgs) #'(lambda (seq msgs)
;; Can't be run in the background, since the ;; Can't be run in the background, since the
;; current folder is changed by mark this could ;; current folder is changed by mark this could
;; lead to a race condition with the next refile. ;; lead to a race condition with the next refile.
(apply #'mh-exec-cmd "mark" (apply #'mh-exec-cmd "mark"
"-sequence" (symbol-name seq) dest-folder "-sequence" (symbol-name seq) dest-folder
"-add" (mapcar #'(lambda (x) (format "%s" x)) "-add" (mapcar #'(lambda (x) (format "%s" x))
(mh-coalesce-msg-list msgs)))) (mh-coalesce-msg-list msgs))))
dest-map)))) dest-map))))
mh-refile-list) mh-refile-list)
(setq mh-refile-list ()) (setq mh-refile-list ())
@ -1614,14 +1614,14 @@ after the commands are processed."
do (cl-loop for seq-name in (gethash msg seq-map) do (cl-loop for seq-name in (gethash msg seq-map)
do (push i (gethash seq-name allow-map)))) do (push i (gethash seq-name allow-map))))
(maphash (maphash
#'(lambda (seq msgs) (lambda (seq msgs)
;; Can't be run in background, since the current ;; Can't be run in background, since the current
;; folder is changed by mark this could lead to a ;; folder is changed by mark this could lead to a
;; race condition with the next refile/allowlist. ;; race condition with the next refile/allowlist.
(apply #'mh-exec-cmd "mark" (apply #'mh-exec-cmd "mark"
"-sequence" (symbol-name seq) mh-inbox "-sequence" (symbol-name seq) mh-inbox
"-add" (mapcar #'(lambda(x) (format "%s" x)) "-add" (mapcar #'(lambda(x) (format "%s" x))
(mh-coalesce-msg-list msgs)))) (mh-coalesce-msg-list msgs))))
allow-map)) allow-map))
(setq mh-allowlist nil))) (setq mh-allowlist nil)))

View file

@ -238,24 +238,24 @@ usually reads the file \"/etc/mailcap\"."
(when (consp part-index) (setq part-index (car part-index))) (when (consp part-index) (setq part-index (car part-index)))
(mh-folder-mime-action (mh-folder-mime-action
part-index part-index
#'(lambda () (lambda ()
(let* ((part (get-text-property (point) 'mh-data)) (let* ((part (get-text-property (point) 'mh-data))
(type (mm-handle-media-type part)) (type (mm-handle-media-type part))
(methods (mapcar (lambda (x) (list (cdr (assoc 'viewer x)))) (methods (mapcar (lambda (x) (list (cdr (assoc 'viewer x))))
(mailcap-mime-info type 'all))) (mailcap-mime-info type 'all)))
(def (caar methods)) (def (caar methods))
(prompt (format-prompt "Viewer" def)) (prompt (format-prompt "Viewer" def))
(method (completing-read prompt methods nil nil nil nil def)) (method (completing-read prompt methods nil nil nil nil def))
(folder mh-show-folder-buffer) (folder mh-show-folder-buffer)
(buffer-read-only nil)) (buffer-read-only nil))
(when (string-match "^[^% \t]+$" method) (when (string-match "^[^% \t]+$" method)
(setq method (concat method " %s"))) (setq method (concat method " %s")))
(mh-flet (mh-flet
((mm-handle-set-external-undisplayer ((mm-handle-set-external-undisplayer
(handle function) (handle function)
(mh-handle-set-external-undisplayer folder handle function))) (mh-handle-set-external-undisplayer folder handle function)))
(unwind-protect (mm-display-external part method) (unwind-protect (mm-display-external part method)
(set-buffer-modified-p nil))))) (set-buffer-modified-p nil)))))
nil)) nil))
;;;###mh-autoload ;;;###mh-autoload

View file

@ -1209,8 +1209,8 @@ V%s 0 /%s-latin1 /%s Latin1Encoding put\n"
(ps-output-prologue (format "ETOP%d %d %d put\n" i (car font) index)) (ps-output-prologue (format "ETOP%d %d %d put\n" i (car font) index))
(setq index (1+ index)))) (setq index (1+ index))))
(ps-output-prologue (format "/VTOP%d [%s] def\n" i (ps-output-prologue (format "/VTOP%d [%s] def\n" i
(mapconcat #'(lambda (x) (mapconcat (lambda (x)
(format "F%02X" (cdr x))) (format "F%02X" (cdr x)))
font-list " "))))) font-list " ")))))
;; Redefine fonts f0, f1, f2, f3, h0, h1, H0. ;; Redefine fonts f0, f1, f2, f3, h0, h1, H0.

View file

@ -3855,7 +3855,7 @@ It can be retrieved with `(ps-get ALIST-SYM KEY)'."
(defun ps-color-scale (color) (defun ps-color-scale (color)
;; Scale 16-bit X-COLOR-VALUE to PostScript color value in [0, 1] interval. ;; Scale 16-bit X-COLOR-VALUE to PostScript color value in [0, 1] interval.
(mapcar #'(lambda (value) (/ value ps-print-color-scale)) (mapcar (lambda (value) (/ value ps-print-color-scale))
(color-values color))) (color-values color)))
@ -4747,11 +4747,11 @@ page-height == ((floor print-height ((th + ls) * zh)) * ((th + ls) * zh)) - th
(defun ps-background-pages (page-list func) (defun ps-background-pages (page-list func)
(if page-list (if page-list
(mapcar (mapcar
#'(lambda (pages) (lambda (pages)
(let ((start (if (consp pages) (car pages) pages)) (let ((start (if (consp pages) (car pages) pages))
(end (if (consp pages) (cdr pages) pages))) (end (if (consp pages) (cdr pages) pages)))
(and (integerp start) (integerp end) (<= start end) (and (integerp start) (integerp end) (<= start end)
(add-to-list 'ps-background-pages (vector start end func))))) (add-to-list 'ps-background-pages (vector start end func)))))
page-list) page-list)
(setq ps-background-all-pages (cons func ps-background-all-pages)))) (setq ps-background-all-pages (cons func ps-background-all-pages))))
@ -4789,76 +4789,76 @@ page-height == ((floor print-height ((th + ls) * zh)) * ((th + ls) * zh)) - th
(defun ps-background-text () (defun ps-background-text ()
(mapcar (mapcar
#'(lambda (text) (lambda (text)
(setq ps-background-text-count (1+ ps-background-text-count)) (setq ps-background-text-count (1+ ps-background-text-count))
(ps-output (format "/ShowBackText-%d{\n" ps-background-text-count)) (ps-output (format "/ShowBackText-%d{\n" ps-background-text-count))
(ps-output-string (nth 0 text)) ; text (ps-output-string (nth 0 text)) ; text
(ps-output (ps-output
"\n" "\n"
(ps-float-format (nth 4 text) 200.0) ; font size (ps-float-format (nth 4 text) 200.0) ; font size
(format "/%s " (or (nth 3 text) "Times-Roman")) ; font name (format "/%s " (or (nth 3 text) "Times-Roman")) ; font name
(ps-float-format (nth 6 text) (ps-float-format (nth 6 text)
"PrintHeight PrintPageWidth atan") ; rotation "PrintHeight PrintPageWidth atan") ; rotation
(ps-float-format (nth 5 text) 0.85) ; gray (ps-float-format (nth 5 text) 0.85) ; gray
(ps-float-format (nth 1 text) "0") ; x position (ps-float-format (nth 1 text) "0") ; x position
(ps-float-format (nth 2 text) "0") ; y position (ps-float-format (nth 2 text) "0") ; y position
"\nShowBackText}def\n") "\nShowBackText}def\n")
(ps-background-pages (nthcdr 7 text) ; page list (ps-background-pages (nthcdr 7 text) ; page list
(format "ShowBackText-%d\n" (format "ShowBackText-%d\n"
ps-background-text-count))) ps-background-text-count)))
ps-print-background-text)) ps-print-background-text))
(defun ps-background-image () (defun ps-background-image ()
(mapcar (mapcar
#'(lambda (image) (lambda (image)
(let ((image-file (expand-file-name (nth 0 image)))) (let ((image-file (expand-file-name (nth 0 image))))
(when (file-readable-p image-file) (when (file-readable-p image-file)
(setq ps-background-image-count (1+ ps-background-image-count)) (setq ps-background-image-count (1+ ps-background-image-count))
(ps-output (ps-output
(format "/ShowBackImage-%d{\n--back-- " (format "/ShowBackImage-%d{\n--back-- "
ps-background-image-count) ps-background-image-count)
(ps-float-format (nth 5 image) 0.0) ; rotation (ps-float-format (nth 5 image) 0.0) ; rotation
(ps-float-format (nth 3 image) 1.0) ; x scale (ps-float-format (nth 3 image) 1.0) ; x scale
(ps-float-format (nth 4 image) 1.0) ; y scale (ps-float-format (nth 4 image) 1.0) ; y scale
(ps-float-format (nth 1 image) ; x position (ps-float-format (nth 1 image) ; x position
"PrintPageWidth 2 div") "PrintPageWidth 2 div")
(ps-float-format (nth 2 image) ; y position (ps-float-format (nth 2 image) ; y position
"PrintHeight 2 div BottomMargin add") "PrintHeight 2 div BottomMargin add")
"\nBeginBackImage\n") "\nBeginBackImage\n")
(ps-insert-file image-file) (ps-insert-file image-file)
;; coordinate adjustment to center image ;; coordinate adjustment to center image
;; around x and y position ;; around x and y position
(let ((box (ps-get-boundingbox))) (let ((box (ps-get-boundingbox)))
(with-current-buffer ps-spool-buffer (with-current-buffer ps-spool-buffer
(save-excursion (save-excursion
(if (re-search-backward "^--back--" nil t) (if (re-search-backward "^--back--" nil t)
(replace-match (replace-match
(format "%s %s" (format "%s %s"
(ps-float-format (ps-float-format
(- (+ (/ (- (aref box 2) (aref box 0)) 2.0) (- (+ (/ (- (aref box 2) (aref box 0)) 2.0)
(aref box 0)))) (aref box 0))))
(ps-float-format (ps-float-format
(- (+ (/ (- (aref box 3) (aref box 1)) 2.0) (- (+ (/ (- (aref box 3) (aref box 1)) 2.0)
(aref box 1))))) (aref box 1)))))
t))))) t)))))
(ps-output "\nEndBackImage}def\n") (ps-output "\nEndBackImage}def\n")
(ps-background-pages (nthcdr 6 image) ; page list (ps-background-pages (nthcdr 6 image) ; page list
(format "ShowBackImage-%d\n" (format "ShowBackImage-%d\n"
ps-background-image-count))))) ps-background-image-count)))))
ps-print-background-image)) ps-print-background-image))
(defun ps-background (page-number) (defun ps-background (page-number)
(let (has-local-background) (let (has-local-background)
(mapc #'(lambda (range) (mapc (lambda (range)
(and (<= (aref range 0) page-number) (and (<= (aref range 0) page-number)
(<= page-number (aref range 1)) (<= page-number (aref range 1))
(if has-local-background (if has-local-background
(ps-output (aref range 2)) (ps-output (aref range 2))
(setq has-local-background t) (setq has-local-background t)
(ps-output "/printLocalBackground{\n" (ps-output "/printLocalBackground{\n"
(aref range 2))))) (aref range 2)))))
ps-background-pages) ps-background-pages)
(and has-local-background (ps-output "}def\n")))) (and has-local-background (ps-output "}def\n"))))
@ -5697,8 +5697,8 @@ XSTART YSTART are the relative position for the first page in a sheet.")
(> (car page) 0) (> (car page) 0)
(<= (car page) (cdr page)) (<= (car page) (cdr page))
(setq new (cons page new)))))) (setq new (cons page new))))))
(setq ps-selected-pages (sort new #'(lambda (one other) (setq ps-selected-pages (sort new (lambda (one other)
(< (car one) (car other)))) (< (car one) (car other))))
ps-last-selected-pages ps-selected-pages ps-last-selected-pages ps-selected-pages
ps-first-page nil ps-first-page nil
ps-last-page nil)) ps-last-page nil))
@ -5782,8 +5782,8 @@ XSTART YSTART are the relative position for the first page in a sheet.")
"unspecified-fg" "unspecified-fg"
0.0) 0.0)
ps-foreground-list (mapcar ps-foreground-list (mapcar
#'(lambda (arg) (lambda (arg)
(ps-rgb-color arg "unspecified-fg" 0.0)) (ps-rgb-color arg "unspecified-fg" 0.0))
(append (and (not (member ps-print-color-p (append (and (not (member ps-print-color-p
'(nil black-white))) '(nil black-white)))
ps-fg-list) ps-fg-list)
@ -6012,9 +6012,9 @@ XSTART YSTART are the relative position for the first page in a sheet.")
(if (and (boundp 'ucs-mule-8859-to-mule-unicode) (if (and (boundp 'ucs-mule-8859-to-mule-unicode)
(char-table-p ucs-mule-8859-to-mule-unicode)) (char-table-p ucs-mule-8859-to-mule-unicode))
(map-char-table (map-char-table
#'(lambda (k v) (lambda (k v)
(if (and v (eq (char-charset v) 'latin-iso8859-1) (/= k v)) (if (and v (eq (char-charset v) 'latin-iso8859-1) (/= k v))
(aset tbl k v))) (aset tbl k v)))
ucs-mule-8859-to-mule-unicode)) ucs-mule-8859-to-mule-unicode))
tbl) tbl)
"Translation table for PostScript printing. "Translation table for PostScript printing.

View file

@ -674,55 +674,55 @@ Return nil if file NAME is not one of the ten more recent."
"Sort the list of menu elements L in ascending order. "Sort the list of menu elements L in ascending order.
The MENU-ITEM part of each menu element is compared." The MENU-ITEM part of each menu element is compared."
(sort (copy-sequence l) (sort (copy-sequence l)
#'(lambda (e1 e2) (lambda (e1 e2)
(recentf-string-lessp (recentf-string-lessp
(recentf-menu-element-item e1) (recentf-menu-element-item e1)
(recentf-menu-element-item e2))))) (recentf-menu-element-item e2)))))
(defsubst recentf-sort-descending (l) (defsubst recentf-sort-descending (l)
"Sort the list of menu elements L in descending order. "Sort the list of menu elements L in descending order.
The MENU-ITEM part of each menu element is compared." The MENU-ITEM part of each menu element is compared."
(sort (copy-sequence l) (sort (copy-sequence l)
#'(lambda (e1 e2) (lambda (e1 e2)
(recentf-string-lessp (recentf-string-lessp
(recentf-menu-element-item e2) (recentf-menu-element-item e2)
(recentf-menu-element-item e1))))) (recentf-menu-element-item e1)))))
(defsubst recentf-sort-basenames-ascending (l) (defsubst recentf-sort-basenames-ascending (l)
"Sort the list of menu elements L in ascending order. "Sort the list of menu elements L in ascending order.
Only filenames sans directory are compared." Only filenames sans directory are compared."
(sort (copy-sequence l) (sort (copy-sequence l)
#'(lambda (e1 e2) (lambda (e1 e2)
(recentf-string-lessp (recentf-string-lessp
(file-name-nondirectory (recentf-menu-element-value e1)) (file-name-nondirectory (recentf-menu-element-value e1))
(file-name-nondirectory (recentf-menu-element-value e2)))))) (file-name-nondirectory (recentf-menu-element-value e2))))))
(defsubst recentf-sort-basenames-descending (l) (defsubst recentf-sort-basenames-descending (l)
"Sort the list of menu elements L in descending order. "Sort the list of menu elements L in descending order.
Only filenames sans directory are compared." Only filenames sans directory are compared."
(sort (copy-sequence l) (sort (copy-sequence l)
#'(lambda (e1 e2) (lambda (e1 e2)
(recentf-string-lessp (recentf-string-lessp
(file-name-nondirectory (recentf-menu-element-value e2)) (file-name-nondirectory (recentf-menu-element-value e2))
(file-name-nondirectory (recentf-menu-element-value e1)))))) (file-name-nondirectory (recentf-menu-element-value e1))))))
(defsubst recentf-sort-directories-ascending (l) (defsubst recentf-sort-directories-ascending (l)
"Sort the list of menu elements L in ascending order. "Sort the list of menu elements L in ascending order.
Compares directories then filenames to order the list." Compares directories then filenames to order the list."
(sort (copy-sequence l) (sort (copy-sequence l)
#'(lambda (e1 e2) (lambda (e1 e2)
(recentf-directory-compare (recentf-directory-compare
(recentf-menu-element-value e1) (recentf-menu-element-value e1)
(recentf-menu-element-value e2))))) (recentf-menu-element-value e2)))))
(defsubst recentf-sort-directories-descending (l) (defsubst recentf-sort-directories-descending (l)
"Sort the list of menu elements L in descending order. "Sort the list of menu elements L in descending order.
Compares directories then filenames to order the list." Compares directories then filenames to order the list."
(sort (copy-sequence l) (sort (copy-sequence l)
#'(lambda (e1 e2) (lambda (e1 e2)
(recentf-directory-compare (recentf-directory-compare
(recentf-menu-element-value e2) (recentf-menu-element-value e2)
(recentf-menu-element-value e1))))) (recentf-menu-element-value e1)))))
(defun recentf-show-basenames (l &optional no-dir) (defun recentf-show-basenames (l &optional no-dir)
"Filter the list of menu elements L to show filenames sans directory. "Filter the list of menu elements L to show filenames sans directory.
@ -1382,5 +1382,5 @@ buffers you switch to a lot, you can say something like the following:
(provide 'recentf) (provide 'recentf)
(run-hooks 'recentf-load-hook) (run-hooks 'recentf-load-hook)
;;; recentf.el ends here ;;; recentf.el ends here

View file

@ -2263,11 +2263,11 @@ See also `multi-occur'."
(defun occur-engine-add-prefix (lines &optional prefix-face) (defun occur-engine-add-prefix (lines &optional prefix-face)
(mapcar (mapcar
#'(lambda (line) (lambda (line)
(concat (if prefix-face (concat (if prefix-face
(propertize " :" 'font-lock-face prefix-face) (propertize " :" 'font-lock-face prefix-face)
" :") " :")
line "\n")) line "\n"))
lines)) lines))
(defun occur-accumulate-lines (count &optional keep-props pt) (defun occur-accumulate-lines (count &optional keep-props pt)

View file

@ -440,13 +440,13 @@ two markers or an overlay. Otherwise, it is nil."
(setq type 'C_STRING)) (setq type 'C_STRING))
(t (t
(let (non-latin-1 non-unicode eight-bit) (let (non-latin-1 non-unicode eight-bit)
(mapc #'(lambda (x) (mapc (lambda (x)
(if (>= x #x100) (if (>= x #x100)
(if (< x #x110000) (if (< x #x110000)
(setq non-latin-1 t) (setq non-latin-1 t)
(if (< x #x3FFF80) (if (< x #x3FFF80)
(setq non-unicode t) (setq non-unicode t)
(setq eight-bit t))))) (setq eight-bit t)))))
str) str)
(setq type (if (or non-unicode (setq type (if (or non-unicode
(and (and

View file

@ -90,12 +90,12 @@
(defcustom server-use-tcp nil (defcustom server-use-tcp nil
"If non-nil, use TCP sockets instead of local sockets." "If non-nil, use TCP sockets instead of local sockets."
:set #'(lambda (sym val) :set (lambda (sym val)
(unless (featurep 'make-network-process '(:family local)) (unless (featurep 'make-network-process '(:family local))
(setq val t) (setq val t)
(unless load-in-progress (unless load-in-progress
(message "Local sockets unsupported, using TCP sockets"))) (message "Local sockets unsupported, using TCP sockets")))
(set-default sym val)) (set-default sym val))
:type 'boolean :type 'boolean
:version "22.1") :version "22.1")

View file

@ -3554,7 +3554,7 @@ With prefix, sorts in REVERSE order."
(push (cons (buffer-substring-no-properties (point) end) (push (cons (buffer-substring-no-properties (point) end)
(+ minrow x)) (+ minrow x))
keys)) keys))
(setq keys (sort keys #'(lambda (x y) (string< (car x) (car y))))) (setq keys (sort keys (lambda (x y) (string< (car x) (car y)))))
;;Extract the lines in reverse sorted order ;;Extract the lines in reverse sorted order
(or reverse (or reverse
(setq keys (nreverse keys))) (setq keys (nreverse keys)))

View file

@ -540,8 +540,8 @@ Use \\[untabify] to convert tabs to spaces before sorting."
(narrow-to-region beg1 end1) (narrow-to-region beg1 end1)
(goto-char beg1) (goto-char beg1)
(sort-subr reverse 'forward-line 'end-of-line (sort-subr reverse 'forward-line 'end-of-line
#'(lambda () (move-to-column col-start) nil) (lambda () (move-to-column col-start) nil)
#'(lambda () (move-to-column col-end) nil)))))))) (lambda () (move-to-column col-end) nil))))))))
;;;###autoload ;;;###autoload
(defun reverse-region (beg end) (defun reverse-region (beg end)

View file

@ -867,10 +867,10 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.")
;; For Darwin nothing except UTF-8 makes sense. ;; For Darwin nothing except UTF-8 makes sense.
(when (eq system-type 'darwin) (when (eq system-type 'darwin)
(add-hook 'before-init-hook (add-hook 'before-init-hook
#'(lambda () (lambda ()
(setq locale-coding-system 'utf-8-unix) (setq locale-coding-system 'utf-8-unix)
(setq default-process-coding-system (setq default-process-coding-system
'(utf-8-unix . utf-8-unix))))) '(utf-8-unix . utf-8-unix)))))
;; Mac OS X Lion introduces PressAndHold, which is unsupported by this port. ;; Mac OS X Lion introduces PressAndHold, which is unsupported by this port.
;; See this thread for more details: ;; See this thread for more details:

View file

@ -214,8 +214,8 @@ Give the image the specified properties PROPS."
See also the option `widget-image-conversion'." See also the option `widget-image-conversion'."
(delq nil (delq nil
(mapcar (mapcar
#'(lambda (fmt) (lambda (fmt)
(and (image-type-available-p (car fmt)) fmt)) (and (image-type-available-p (car fmt)) fmt))
widget-image-conversion))) widget-image-conversion)))
;; Buffer local cache of theme data. ;; Buffer local cache of theme data.

View file

@ -1687,32 +1687,32 @@ cleaning up these problems."
(or whitespace-active-style whitespace-style))) (or whitespace-active-style whitespace-style)))
(bogus-list (bogus-list
(mapcar (mapcar
#'(lambda (option) (lambda (option)
(when force (when force
(push (car option) style)) (push (car option) style))
(goto-char rstart) (goto-char rstart)
(let ((regexp (let ((regexp
(cond (cond
((eq (car option) 'indentation) ((eq (car option) 'indentation)
(whitespace-indentation-regexp)) (whitespace-indentation-regexp))
((eq (car option) 'indentation::tab) ((eq (car option) 'indentation::tab)
(whitespace-indentation-regexp 'tab)) (whitespace-indentation-regexp 'tab))
((eq (car option) 'indentation::space) ((eq (car option) 'indentation::space)
(whitespace-indentation-regexp 'space)) (whitespace-indentation-regexp 'space))
((eq (car option) 'space-after-tab) ((eq (car option) 'space-after-tab)
(whitespace-space-after-tab-regexp)) (whitespace-space-after-tab-regexp))
((eq (car option) 'space-after-tab::tab) ((eq (car option) 'space-after-tab::tab)
(whitespace-space-after-tab-regexp 'tab)) (whitespace-space-after-tab-regexp 'tab))
((eq (car option) 'space-after-tab::space) ((eq (car option) 'space-after-tab::space)
(whitespace-space-after-tab-regexp 'space)) (whitespace-space-after-tab-regexp 'space))
((eq (car option) 'missing-newline-at-eof) ((eq (car option) 'missing-newline-at-eof)
"[^\n]\\'") "[^\n]\\'")
(t (t
(cdr option))))) (cdr option)))))
(when (re-search-forward regexp rend t) (when (re-search-forward regexp rend t)
(unless has-bogus (unless has-bogus
(setq has-bogus (memq (car option) style))) (setq has-bogus (memq (car option) style)))
t))) t)))
whitespace-report-list))) whitespace-report-list)))
(when (pcase report-if-bogus ('nil t) ('never nil) (_ has-bogus)) (when (pcase report-if-bogus ('nil t) ('never nil) (_ has-bogus))
(whitespace-kill-buffer whitespace-report-buffer-name) (whitespace-kill-buffer whitespace-report-buffer-name)
@ -2463,5 +2463,4 @@ It should be added buffer-locally to `write-file-functions'."
"use `with-eval-after-load' instead." "28.1") "use `with-eval-after-load' instead." "28.1")
(run-hooks 'whitespace-load-hook) (run-hooks 'whitespace-load-hook)
;;; whitespace.el ends here ;;; whitespace.el ends here