[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[nongnu] elpa/evil 0cbd61f2de: Some cleanups
|
From: |
ELPA Syncer |
|
Subject: |
[nongnu] elpa/evil 0cbd61f2de: Some cleanups |
|
Date: |
Sat, 12 Aug 2023 09:59:27 -0400 (EDT) |
branch: elpa/evil
commit 0cbd61f2de104fab16602d0418605cd0513b16f3
Author: Axel Forsman <axel@axelf.se>
Commit: Axel Forsman <axel@axelf.se>
Some cleanups
---
evil-command-window.el | 3 +-
evil-commands.el | 289 ++++++++++++++++++++-----------------------------
evil-common.el | 23 ++--
evil-core.el | 43 +++-----
evil-ex.el | 52 ++++-----
evil-maps.el | 10 +-
evil-search.el | 58 +++++-----
evil-tests.el | 13 +--
evil-vars.el | 3 -
9 files changed, 204 insertions(+), 290 deletions(-)
diff --git a/evil-command-window.el b/evil-command-window.el
index 68068a8384..c364e41868 100644
--- a/evil-command-window.el
+++ b/evil-command-window.el
@@ -44,8 +44,7 @@
(define-derived-mode evil-command-window-mode fundamental-mode "Evil-cmd"
"Major mode for the Evil command line window."
(auto-fill-mode 0)
- (setq-local after-change-functions
- (cons #'evil-command-window-draw-prefix after-change-functions)))
+ (add-hook 'after-change-functions #'evil-command-window-draw-prefix nil t))
(defun evil-command-window (history cmd-key execute-fn)
"Open a command line window for HISTORY with CMD-KEY and EXECUTE-FN.
diff --git a/evil-commands.el b/evil-commands.el
index 40a01320e5..7dfc1e0ae8 100644
--- a/evil-commands.el
+++ b/evil-commands.el
@@ -37,7 +37,6 @@
(require 'cl-lib)
(require 'reveal)
-(declare-function flyspell-overlay-p "flyspell")
(declare-function imenu--in-alist "imenu")
;;; Motions
@@ -215,10 +214,9 @@ move COUNT - 1 screen lines downward first."
"Move the cursor to COUNT % of the width of the current line.
If no COUNT is given, default to 50%."
:type exclusive
- (let ((line-length (- (line-end-position)
- (line-beginning-position)
+ (let ((line-length (- (line-end-position) (line-beginning-position)
(if evil-move-beyond-eol -1 0))))
- (move-to-column (truncate (* line-length (/ (or count 50) 100.0))))))
+ (move-to-column (truncate (* line-length (or count 50)) 100))))
(evil-define-motion evil-first-non-blank ()
"Move the cursor to the first non-blank character of the current line."
@@ -229,13 +227,9 @@ If no COUNT is given, default to 50%."
"Move the cursor to the last non-blank character of the current line.
If COUNT is given, move COUNT - 1 lines downward first."
:type inclusive
- (goto-char
- (save-excursion
- (evil-move-beginning-of-line count)
- (if (re-search-forward "[ \t]*$")
- (max (line-beginning-position)
- (1- (match-beginning 0)))
- (line-beginning-position)))))
+ (evil-move-end-of-line count)
+ (skip-chars-backward " \t")
+ (unless (bolp) (backward-char)))
(evil-define-motion evil-first-non-blank-of-visual-line ()
"Move the cursor to the first non blank character
@@ -498,30 +492,28 @@ and jump to the corresponding one."
(t
(let* ((open (point-max))
(close (point-max))
- (open-pair (condition-case nil
- (save-excursion
- ;; consider the character right before eol given
that
- ;; point may be placed there, e.g. in visual state
- (when (and (eolp) (not (bolp)))
- (backward-char))
- (setq open (1- (scan-lists (point) 1 -1)))
- (when (< open (line-end-position))
- (goto-char open)
- (forward-list)
- (1- (point))))
- (error nil)))
- (close-pair (condition-case nil
- (save-excursion
- ;; consider the character right before eol given
that
- ;; point may be placed there, e.g. in visual state
- (when (and (eolp) (not (bolp)))
- (backward-char))
- (setq close (1- (scan-lists (point) 1 1)))
- (when (< close (line-end-position))
- (goto-char (1+ close))
- (backward-list)
- (point)))
- (error nil))))
+ (open-pair (ignore-errors
+ (save-excursion
+ ;; consider the character right before eol given that
+ ;; point may be placed there, e.g. in visual state
+ (when (and (eolp) (not (bolp)))
+ (backward-char))
+ (setq open (1- (scan-lists (point) 1 -1)))
+ (when (< open (line-end-position))
+ (goto-char open)
+ (forward-list)
+ (1- (point))))))
+ (close-pair (ignore-errors
+ (save-excursion
+ ;; consider the character right before eol given
that
+ ;; point may be placed there, e.g. in visual state
+ (when (and (eolp) (not (bolp)))
+ (backward-char))
+ (setq close (1- (scan-lists (point) 1 1)))
+ (when (< close (line-end-position))
+ (goto-char (1+ close))
+ (backward-list)
+ (point))))))
(cond
((not (or open-pair close-pair))
;; nothing found, check if we are inside a string
@@ -548,6 +540,7 @@ and jump to the corresponding one."
((< open close) (goto-char open-pair))
(t (goto-char close-pair)))))))
+(declare-function flyspell-overlay-p "flyspell")
(evil-define-motion evil-next-flyspell-error (count)
"Go to the COUNT'th spelling mistake after point."
:jump t
@@ -608,27 +601,16 @@ and jump to the corresponding one."
(defun evil--next-mark (forwardp)
"Move to next lowercase mark.
-Move forward if FORWARDP is truthy or backward if falsey.
-Loop back to the top of buffer if the end is reached."
- (let ((pos (point))
- (sorted-markers (sort (evil--lowercase-markers)
- (lambda (a b) (< (cdr a) (cdr b))))))
- (cond
- ((null sorted-markers)
- (user-error "No marks in this buffer"))
- (forwardp
- (let ((next-marker (cl-some (lambda (x) (and (< pos (cdr x)) (cdr x)))
- sorted-markers)))
- (if next-marker
- (goto-char (marker-position next-marker))
- (goto-char (marker-position (cdar sorted-markers))))))
- (t
- (let* ((descending-markers (reverse sorted-markers))
- (prev-marker (cl-some (lambda (x) (and (> pos (cdr x)) (cdr x)))
- descending-markers)))
- (if prev-marker
- (goto-char (marker-position prev-marker))
- (goto-char (marker-position (cdar descending-markers)))))))))
+Move forward if FORWARDP is non-nil, and backward otherwise. Loop back
+to the beginning of buffer if the end is reached."
+ (let* ((pos (if forwardp (1+ (point)) (point)))
+ (centered-markers
+ (cl-sort
+ (or (evil--lowercase-markers) (user-error "No marks in this
buffer"))
+ (if forwardp #'< #'>)
+ :key (lambda (x) (+ (if (< (cdr x) pos) 0 most-negative-fixnum)
+ (cdr x))))))
+ (goto-char (cdar centered-markers))))
(evil-define-motion evil-next-mark (count)
"Go to COUNT next lowercase mark."
@@ -645,12 +627,11 @@ Loop back to the top of buffer if the end is reached."
:repeat nil
:type exclusive
:jump t
- (if (evil--lowercase-markers)
- (dotimes (_ (or count 1))
- (evil-end-of-line)
- (evil--next-mark t)
- (evil-first-non-blank))
- (user-error "No marks in this buffer")))
+ (unless (evil--lowercase-markers) (user-error "No marks in this buffer"))
+ (dotimes (_ (or count 1))
+ (move-end-of-line nil)
+ (evil--next-mark t))
+ (evil-first-non-blank))
(evil-define-motion evil-previous-mark (count)
"Go to COUNT previous lowercase mark."
@@ -667,15 +648,15 @@ Loop back to the top of buffer if the end is reached."
:repeat nil
:type exclusive
:jump t
- (if (evil--lowercase-markers)
- (dotimes (_ (or count 1))
- (evil-beginning-of-line)
- (evil--next-mark nil)
- (evil-first-non-blank))
- (user-error "No marks in this buffer")))
+ (unless (evil--lowercase-markers) (user-error "No marks in this buffer"))
+ (dotimes (_ (or count 1))
+ (move-beginning-of-line nil)
+ (evil--next-mark nil))
+ (evil-first-non-blank))
(evil-define-command evil-set-col-0-mark (beg end mark)
- "Set MARK at column 0 of line of END. Default is cursor line."
+ "Set MARK at column 0 of line of END.
+Default is cursor line."
(interactive "<r><a>")
(if (< 1 (length mark))
(user-error "Trailing characters")
@@ -686,7 +667,8 @@ Loop back to the top of buffer if the end is reached."
(evil-define-motion evil-find-char (count char)
"Move to the next COUNT'th occurrence of CHAR.
-Movement is restricted to the current line unless `evil-cross-lines' is
non-nil."
+Movement is restricted to the current line unless `evil-cross-lines'
+is non-nil."
:type inclusive
(interactive "<c><C>")
(setq count (or count 1))
@@ -725,12 +707,11 @@ Movement is restricted to the current line unless
`evil-cross-lines' is non-nil.
:type inclusive
(interactive "<c><C>")
(unwind-protect
- (progn
- (evil-find-char count char)
- (if (> (or count 1) 0)
- (backward-char)
- (forward-char)))
- (setcar evil-last-find #'evil-find-char-to)))
+ (evil-find-char count char)
+ (setcar evil-last-find #'evil-find-char-to))
+ (if (> (or count 1) 0)
+ (backward-char)
+ (forward-char)))
(evil-define-motion evil-find-char-to-backward (count char)
"Move before the previous COUNT'th occurrence of CHAR."
@@ -742,26 +723,22 @@ Movement is restricted to the current line unless
`evil-cross-lines' is non-nil.
"Repeat the last find COUNT times."
:type inclusive
(setq count (or count 1))
- (if evil-last-find
- (let ((cmd (car evil-last-find))
- (char (nth 1 evil-last-find))
- (fwd (nth 2 evil-last-find))
- evil-last-find)
- ;; ensure count is non-negative
- (when (< count 0)
- (setq count (- count)
- fwd (not fwd)))
- ;; skip next character when repeating t or T
- (and (eq cmd #'evil-find-char-to)
- evil-repeat-find-to-skip-next
- (= count 1)
- (or (and fwd (= (char-after (1+ (point))) char))
- (and (not fwd) (= (char-before) char)))
- (setq count (1+ count)))
- (funcall cmd (if fwd count (- count)) char)
- (unless (nth 2 evil-last-find)
- (setq evil-this-type 'exclusive)))
- (user-error "No previous search")))
+ (cl-destructuring-bind (cmd char fwd)
+ (or evil-last-find (user-error "No previous search"))
+ ;; ensure count is non-negative
+ (when (< count 0)
+ (setq count (- count)
+ fwd (not fwd)))
+ ;; skip next character when repeating t or T
+ (and (eq cmd #'evil-find-char-to)
+ evil-repeat-find-to-skip-next
+ (= count 1)
+ (eql (if fwd (char-after (1+ (point))) (char-before)) char)
+ (setq count (1+ count)))
+ (let (evil-last-find)
+ (funcall cmd (if fwd count (- count)) char)
+ (unless (nth 2 evil-last-find)
+ (setq evil-this-type 'exclusive)))))
(evil-define-motion evil-repeat-find-char-reverse (count)
"Repeat the last find COUNT times in the opposite direction."
@@ -2007,9 +1984,7 @@ If a `#' is included before the mark args, the lines are
numbered."
:move-point nil
:type line
(save-excursion
- (condition-case nil
- (fill-region beg end)
- (error nil))))
+ (ignore-errors (fill-region beg end))))
(evil-define-operator evil-fill-and-move (beg end)
"Fill text and move point to the end of the filled region."
@@ -2017,12 +1992,10 @@ If a `#' is included before the mark args, the lines
are numbered."
:type line
(let ((marker (make-marker)))
(move-marker marker (1- end))
- (condition-case nil
- (progn
- (fill-region beg end)
- (goto-char marker)
- (evil-first-non-blank))
- (error nil))))
+ (ignore-errors
+ (fill-region beg end)
+ (goto-char marker)
+ (evil-first-non-blank))))
(evil-define-operator evil-indent (beg end)
"Indent text."
@@ -2421,26 +2394,23 @@ leave the cursor just after the new text."
(defun evil-paste-from-register (register)
"Paste from REGISTER."
(interactive
- (let* ((opoint (point))
- (overlay (make-overlay opoint (+ opoint (if (evil-replace-state-p) 1
0)))))
+ (let ((ov (make-overlay (point) (+ (point) (if (evil-replace-state-p) 1
0)))))
(unwind-protect
(progn
- (overlay-put overlay 'invisible t)
- (overlay-put overlay 'after-string (propertize "\""
- 'face
'minibuffer-prompt
- 'cursor 1))
+ (overlay-put ov 'invisible t)
+ (overlay-put ov 'after-string
+ #("\"" 0 1 (face minibuffer-prompt cursor 1)))
(list (or evil-this-register (read-char))))
- (delete-overlay overlay))))
+ (delete-overlay ov))))
(let ((opoint (point))
- (evil-move-cursor-back nil)
- reg-length chars-to-delete)
+ evil-move-cursor-back)
(evil-paste-before nil register t)
(when (evil-replace-state-p)
- (setq reg-length (- (point) opoint)
- chars-to-delete (min (- (line-end-position) (point)) reg-length))
- ;; TODO: handle multi-line paste backspacing
- (evil-update-replace-alist (point) reg-length chars-to-delete
chars-to-delete)
- (delete-char chars-to-delete))))
+ (let* ((reg-length (- (point) opoint))
+ (chars-to-delete (min (- (line-end-position) (point))
reg-length)))
+ ;; TODO: handle multi-line paste backspacing
+ (evil-update-replace-alist (point) reg-length chars-to-delete
chars-to-delete)
+ (delete-char chars-to-delete)))))
(defun evil-paste-last-insertion ()
"Paste last insertion."
@@ -2496,10 +2466,8 @@ will be opened instead."
((eq register ?\C-g)
(keyboard-quit))
((and evil-this-macro defining-kbd-macro)
- (setq evil-macro-buffer nil)
- (condition-case nil
- (setq last-macro (evil-end-and-return-macro))
- (error nil))
+ (setq evil-macro-buffer nil
+ last-macro (ignore-errors (evil-end-and-return-macro)))
(when last-macro
(evil-set-register evil-this-macro last-macro))
(setq evil-this-macro nil))
@@ -2771,26 +2739,23 @@ switch to insert state."
(defun evil-quoted-insert (count)
"Like `quoted-insert' but delete COUNT chars forward in replace state.
-Adds a `^' overlay as an input prompt."
+Adds a \"^\" overlay as an input prompt."
(interactive "p")
(let* ((opoint (point))
- chars-to-delete insert-prompt)
+ chars-to-delete
+ (ov (if (not (evil-replace-state-p))
+ (make-overlay opoint opoint)
+ (setq chars-to-delete (min (- (line-end-position) opoint)
count))
+ (evil-update-replace-alist opoint count chars-to-delete)
+ (make-overlay opoint (+ chars-to-delete opoint)))))
(unwind-protect
(progn
- (if (evil-replace-state-p)
- (progn
- (setq chars-to-delete (min (- (line-end-position) opoint)
count)
- insert-prompt (make-overlay opoint (+ chars-to-delete
opoint)))
- (evil-update-replace-alist opoint count chars-to-delete))
- (setq insert-prompt (make-overlay opoint opoint)))
- (overlay-put insert-prompt 'invisible t)
- (overlay-put insert-prompt 'after-string (propertize "^"
- 'face
'escape-glyph
- 'cursor 1))
- (let (overwrite-mode) ;; Force `read-quoted-char'
+ (overlay-put ov 'invisible t)
+ (overlay-put ov 'after-string #("^" 0 1 (face escape-glyph cursor
1)))
+ (let (overwrite-mode) ; Force `read-quoted-char'
(quoted-insert count))
- (when (evil-replace-state-p) (delete-char chars-to-delete)))
- (when insert-prompt (delete-overlay insert-prompt)))))
+ (when chars-to-delete (delete-char chars-to-delete)))
+ (delete-overlay ov))))
(evil-define-command evil-open-above (count)
"Insert a new line above point and switch to Insert state.
@@ -3192,10 +3157,9 @@ The search is unbounded, i.e., the pattern is not
wrapped in
(let ((identifier (save-excursion
(goto-char position)
(xref-backend-identifier-at-point
(xref-find-backend)))))
- (condition-case ()
- (progn
- (xref-find-definitions identifier)
- t)
+ (condition-case nil
+ (progn (xref-find-definitions identifier)
+ t)
(user-error nil)))))
(defun evil-goto-definition-search (string _position)
@@ -3400,8 +3364,7 @@ files."
(evil-define-command evil-goto-error (count)
"Go to error number COUNT.
-
-If no COUNT supplied, move to the current error.
+If no COUNT is supplied, move to the current error.
Acts like `first-error' other than when given no counts, goes
to the current error instead of the first, like in Vim's :cc
@@ -3461,17 +3424,12 @@ for the last window in each frame."
;; if the buffer which was initiated by emacsclient,
;; call `server-edit' from server.el to avoid
;; "Buffer still has clients" message
- (if (and (fboundp 'server-edit)
- (boundp 'server-buffer-clients)
- server-buffer-clients)
+ (if (and (bound-and-true-p server-buffer-clients)
+ (fboundp 'server-edit))
(server-edit)
(kill-buffer nil))
;; close all windows that showed this buffer
- (mapc #'(lambda (w)
- (condition-case nil
- (delete-window w)
- (error nil)))
- wins))))
+ (dolist (w wins) (ignore-errors (delete-window w))))))
(evil-define-command evil-quit (&optional force)
"Close the current window, current frame, current tab, Emacs.
@@ -3482,10 +3440,9 @@ is closed."
(condition-case nil
(delete-window)
(error
- (if (and (boundp 'server-buffer-clients)
+ (if (and (bound-and-true-p server-buffer-clients)
(fboundp 'server-edit)
- (fboundp 'server-buffer-done)
- server-buffer-clients)
+ (fboundp 'server-buffer-done))
(if force
(server-buffer-done (current-buffer))
(server-edit))
@@ -3519,10 +3476,7 @@ The FORCE argument is only there for compatibility and
is ignored.
This function fails with an error if Emacs is run in server mode."
:repeat nil
(interactive "<!>")
- (if (and (boundp 'server-buffer-clients)
- (fboundp 'server-edit)
- (fboundp 'server-buffer-done)
- server-buffer-clients)
+ (if (bound-and-true-p server-buffer-clients)
(user-error "Cannot exit client process with error code.")
(kill-emacs 1)))
@@ -4525,17 +4479,14 @@ the deleted window's parent window are rebalanced."
(let ((p (window-parent)))
;; If tabs are enabled and this is the only visible window, then attempt to
;; close this tab.
- (if (and (boundp 'tab-bar-mode)
- tab-bar-mode
- (not p))
+ (if (and (bound-and-true-p tab-bar-mode)
+ (null p))
(tab-close)
- (delete-window))
- (when evil-auto-balance-windows
- ;; balance-windows raises an error if the parent does not have
- ;; any further children (then rebalancing is not necessary anyway)
- (condition-case nil
- (balance-windows p)
- (error)))))
+ (delete-window)
+ (when evil-auto-balance-windows
+ ;; balance-windows raises an error if the parent does not have
+ ;; any further children (then rebalancing is not necessary anyway)
+ (ignore-errors (balance-windows p))))))
(evil-define-command evil-window-split (&optional count file)
"Split the current window horizontally, COUNT lines height,
diff --git a/evil-common.el b/evil-common.el
index 9af0863260..84b0817c17 100644
--- a/evil-common.el
+++ b/evil-common.el
@@ -35,7 +35,6 @@
(declare-function evil-visual-restore "evil-states")
(declare-function evil-motion-state "evil-states")
(declare-function evil-replace-state-p "evil-states")
-(declare-function evil-ex-p "evil-ex")
(declare-function evil-set-jump "evil-jumps")
;;; Compatibility with different Emacs versions
@@ -58,8 +57,8 @@ If LOCAL is non-nil, the buffer-local value of HOOK is
modified."
(cl-destructuring-bind (hook-sym &optional append local name)
(mapcar #'macroexp-quote (if (consp hook) hook (list hook)))
(macroexp-let2* nil
- ((fun-name `',(make-symbol
- (or name (format "evil-delay-in-%s" hook-sym))))
+ ((fun-name `(make-symbol
+ ,(or name (format "evil-delay-in-%s" hook-sym))))
(fun `(lambda (&rest _)
(when ,(or condition t)
(remove-hook ,hook-sym ,fun-name ,local)
@@ -762,15 +761,14 @@ cursor type is either `evil-force-cursor' or the current
state."
(defmacro evil-save-cursor (&rest body)
"Save the current cursor; execute BODY; restore the cursor."
- (declare (indent defun)
- (debug t))
+ (declare (indent defun) (debug t) (obsolete nil "1.15.0"))
`(let ((cursor cursor-type)
(color (frame-parameter (selected-frame) 'cursor-color))
(inhibit-quit t))
(unwind-protect
(progn ,@body)
- (evil-set-cursor cursor)
- (evil-set-cursor color))))
+ (setq cursor-type cursor)
+ (evil-set-cursor-color color))))
(defun evil-echo (string &rest args)
"Display an unlogged message in the echo area.
@@ -798,15 +796,12 @@ Does not restore if `evil-write-echo-area' is non-nil."
(defmacro evil-save-echo-area (&rest body)
"Save the echo area; execute BODY; restore the echo area.
Intermittent messages are not logged in the *Messages* buffer."
- (declare (indent defun)
- (debug t))
+ (declare (indent defun) (debug t))
`(let ((inhibit-quit t)
- evil-echo-area-message
- evil-write-echo-area)
+ evil-echo-area-message evil-write-echo-area)
+ (evil-echo-area-save)
(unwind-protect
- (progn
- (evil-echo-area-save)
- ,@body)
+ (progn ,@body)
(evil-echo-area-restore))))
(defmacro evil-without-display (&rest body)
diff --git a/evil-core.el b/evil-core.el
index 22b665406a..23937e7d30 100644
--- a/evil-core.el
+++ b/evil-core.el
@@ -225,15 +225,10 @@ Restore the previous state afterwards."
(evil-change-state ',state)
,@body)))
-(defun evil-initialize-state (&optional state buffer)
- "Set up the initial state for BUFFER.
-BUFFER defaults to the current buffer.
-Uses STATE if specified, or calls `evil-initial-state-for-buffer'.
+(defun evil-initialize-state ()
+ "Set up the initial state for the current buffer.
See also `evil-set-initial-state'."
- (with-current-buffer (or buffer (current-buffer))
- (evil-change-state
- (or state (evil-initial-state-for-buffer buffer)))))
-(put 'evil-initialize-state 'permanent-local-hook t)
+ (evil-change-state (evil-initial-state-for-buffer)))
(defun evil-initial-state-for-buffer-name (&optional name default)
"Return the initial Evil state to use for a buffer with name NAME.
@@ -254,17 +249,12 @@ Matches the name against the regular expressions in
(defun evil-initial-state-for-buffer (&optional buffer)
"Return the initial Evil state to use for BUFFER.
-BUFFER defaults to the current buffer. Returns DEFAULT
-if no initial state is associated with BUFFER.
-See also `evil-initial-state'."
+BUFFER defaults to the current buffer. See also `evil-initial-state'."
(with-current-buffer (or buffer (current-buffer))
(or (evil-initial-state-for-buffer-name)
- (catch 'done
- (dolist (mode minor-mode-map-alist)
- (setq mode (car mode))
- (and (boundp mode) (symbol-value mode)
- (setq mode (evil-initial-state mode))
- (throw 'done mode))))
+ (cl-loop for (mode) in minor-mode-map-alist
+ when (and (boundp mode) (symbol-value mode))
+ thereis (evil-initial-state mode))
(evil-initial-state major-mode nil t)
evil-default-state)))
@@ -340,11 +330,10 @@ then this function does nothing."
;; otherwise, though, so advise this function to initialize Evil.
(defadvice set-window-buffer (before evil)
"Initialize Evil in the displayed buffer."
- (when evil-mode
- (when (get-buffer (ad-get-arg 1))
- (with-current-buffer (ad-get-arg 1)
- (unless evil-local-mode
- (save-match-data (evil-initialize)))))))
+ (when (and evil-mode (get-buffer (ad-get-arg 1)))
+ (with-current-buffer (ad-get-arg 1)
+ (unless evil-local-mode
+ (save-match-data (evil-initialize))))))
;; Refresh cursor color.
;; Cursor color can only be set for each frame but not for each buffer.
@@ -452,7 +441,7 @@ This allows input methods to be used in normal-state."
"Initialize a buffer-local value for local keymaps as necessary.
The initial value is that of `make-sparse-keymap'."
(dolist (entry evil-local-keymaps-alist)
- (let ((map (cdr entry)))
+ (let ((map (cdr entry)))
(unless (and (keymapp (symbol-value map))
(local-variable-p map))
(set map (make-sparse-keymap))))))
@@ -813,7 +802,6 @@ If AUX is nil, create a new auxiliary keymap."
(format "%s state" state)))))
(define-key map (vector (intern (format "%s-state" state))) aux)
aux)
-(put 'evil-set-auxiliary-keymap 'lisp-indent-function 'defun)
(defun evil-get-auxiliary-keymap (map state &optional create ignore-parent)
"Get the auxiliary keymap for MAP in STATE.
@@ -1284,9 +1272,7 @@ If ARG is nil, don't display a message in the echo
area.%s" name doc)
(deactivate-input-method)))
(unless evil-no-display
(evil-refresh-cursor ',state)
- (evil-refresh-mode-line ',state)
- (when (called-interactively-p 'any)
- (redisplay)))
+ (evil-refresh-mode-line ',state))
,@body
(run-hooks ',entry-hook)
(when (and evil-echo-state
@@ -1295,8 +1281,7 @@ If ARG is nil, don't display a message in the echo
area.%s" name doc)
(funcall ,message)
(evil-echo "%s" ,message))))))))
- (evil-set-command-property ',toggle :keep-visual t)
- (evil-set-command-property ',toggle :suppress-operator t)
+ (evil-add-command-properties ',toggle :keep-visual t :suppress-operator
t)
(evil-define-keymap ,keymap nil
:mode ,mode
diff --git a/evil-ex.el b/evil-ex.el
index 5ae3aa4225..f91c1a1447 100644
--- a/evil-ex.el
+++ b/evil-ex.el
@@ -44,7 +44,6 @@
(require 'evil-common)
(require 'evil-states)
-(require 'evil-types)
(declare-function evil-goto-line "evil-commands")
@@ -77,10 +76,9 @@
#'(evil-ex-char-marker-range $2 $4)))
(line
((\? base) (\? offset) search (\? offset)
- #'(let ((tmp (evil-ex-line $1 $2)))
- (save-excursion
- (goto-line tmp)
- (evil-ex-line $3 $4))))
+ #'(save-excursion
+ (goto-line (evil-ex-line $1 $2))
+ (evil-ex-line $3 $4)))
(base (\? offset) #'evil-ex-line)
(nil offset #'evil-ex-line))
(base
@@ -306,6 +304,9 @@ The following symbols have reserved meanings within a
grammar:
(defvar evil-ex-argument-types nil
"Association list of argument handlers.")
+(defvar evil-ex-commands nil
+ "Association list of command bindings and functions.")
+
(defvar evil-ex-reverse-range nil
"Whether the current Ex range was entered reversed.")
@@ -399,8 +400,9 @@ symbol, which defaults to `expression'."
#'delete-backward-char
#'abort-recursive-edit)))
-(define-obsolete-function-alias
- 'evil-ex-elisp-completion-at-point #'elisp-completion-at-point "1.15.0")
+(cl-defstruct (evil-ex-argument-handler (:type list) (:constructor nil)
+ (:copier nil) (:predicate nil))
+ (runner nil :read-only t) (completer nil :read-only t))
(defun evil-ex-setup ()
"Initialize Ex minibuffer.
@@ -413,10 +415,9 @@ actions during Ex state."
(defun evil-ex-teardown ()
"Deinitialize Ex minibuffer.
Clean up everything set up by `evil-ex-setup'."
- (when evil--ex-argument-handler
- (let ((runner (evil-ex-argument-handler-runner
- evil--ex-argument-handler)))
- (when runner (funcall runner 'stop)))))
+ (let ((runner (evil-ex-argument-handler-runner
+ evil--ex-argument-handler)))
+ (when runner (funcall runner 'stop))))
(put 'evil-ex-teardown 'permanent-local-hook t)
(defsubst evil--ex-bang-p (command)
@@ -489,13 +490,10 @@ in case of incomplete or unknown commands."
(defun evil--ex-remove-echo-overlay ()
"Remove echo overlay from Ex minibuffer."
- (when evil--ex-echo-overlay
- (delete-overlay evil--ex-echo-overlay)
- (setq evil--ex-echo-overlay nil))
+ (delete-overlay evil--ex-echo-overlay)
+ (setq evil--ex-echo-overlay nil)
(remove-hook 'pre-command-hook #'evil--ex-remove-echo-overlay t))
-(define-obsolete-function-alias 'evil-ex-completion #'completion-at-point
"1.15.0")
-
(cl-defun evil-ex-completion-at-point ()
"Function used for `completion-at-point-functions' in Ex state."
(cl-flet ((fix-beg (b) (min (save-excursion
@@ -526,9 +524,6 @@ in case of incomplete or unknown commands."
(`((expression) (sexp . ,_))
(when (fboundp 'elisp-completion-at-point)
(elisp-completion-at-point))))))
-(define-obsolete-function-alias
- 'evil-ex-command-completion-at-point #'evil-ex-completion-at-point "1.15.0")
-
(defun evil-ex-completion-table ()
(let ((ex-cmds
(cl-loop
@@ -577,10 +572,18 @@ in case of incomplete or unknown commands."
(p2 (eq (get-text-property 0 'face str2) 'evil-ex-commands)))
(if (eq p1 p2) (string< str1 str2) p1)))))
+(define-obsolete-function-alias 'evil-ex-completion #'completion-at-point
"1.15.0")
+
+(define-obsolete-function-alias
+ 'evil-ex-command-completion-at-point #'evil-ex-completion-at-point "1.15.0")
+
(defalias 'evil-ex-argument-completion-at-point #'ignore)
(make-obsolete
'evil-ex-argument-completion-at-point #'evil-ex-completion-at-point "1.15.0")
+(define-obsolete-function-alias
+ 'evil-ex-elisp-completion-at-point #'elisp-completion-at-point "1.15.0")
+
(defun evil-ex-define-cmd (cmd function)
"Bind the function FUNCTION to the command CMD."
(if (string-match "\\[\\(.*\\)\\]" cmd)
@@ -591,15 +594,6 @@ in case of incomplete or unknown commands."
abbrev full))
(evil--add-to-alist evil-ex-commands cmd function)))
-(defsubst evil-ex-make-argument-handler (runner completer)
- (list runner completer))
-
-(defun evil-ex-argument-handler-runner (arg-handler)
- (car arg-handler))
-
-(defun evil-ex-argument-handler-completer (arg-handler)
- (cadr arg-handler))
-
(defmacro evil-ex-define-argument-type (arg-type doc &rest body)
"Define a new handler for argument-type ARG-TYPE.
DOC is the documentation string. It is followed by a list of keywords
@@ -835,7 +829,7 @@ This function interprets special file names like # and %."
(defun evil-ex-last-visual-range ()
"Return a linewise range of the last visual selection."
- (evil-line-expand evil-visual-mark evil-visual-point))
+ (evil-range evil-visual-mark evil-visual-point 'line))
(defun evil-ex-marker (marker)
"Return MARKER's line number in the current buffer.
diff --git a/evil-maps.el b/evil-maps.el
index 678ebfd80d..fbf5af1695 100644
--- a/evil-maps.el
+++ b/evil-maps.el
@@ -25,14 +25,14 @@
;; You should have received a copy of the GNU General Public License
;; along with Evil. If not, see <http://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'evil-states)
(require 'evil-ex)
(require 'evil-commands)
(require 'evil-command-window)
(require 'evil-common)
-;;; Code:
-
;;; Normal state
(define-key evil-normal-state-map "a" 'evil-append)
@@ -668,10 +668,8 @@ included in `evil-insert-state-bindings' by default."
(define-key evil-read-key-map "\r" "\n")
;; command line window
-(evil-define-key 'normal
- evil-command-window-mode-map (kbd "RET") 'evil-command-window-execute)
-(evil-define-key 'insert
- evil-command-window-mode-map (kbd "RET") 'evil-command-window-execute)
+(evil-define-key* '(normal insert) evil-command-window-mode-map
+ (kbd "RET") 'evil-command-window-execute)
(provide 'evil-maps)
diff --git a/evil-search.el b/evil-search.el
index b81a7e2ba1..d4f870bcb6 100644
--- a/evil-search.el
+++ b/evil-search.el
@@ -389,9 +389,7 @@ letter, otherwise it will be case-insensitive."
((string-match "\\(?:^\\|[^\\\\]\\)\\(?:\\\\\\\\\\)*\\\\\\([cC]\\)" re)
(if (eq (aref (match-string 1 re) 0) ?c) 'insensitive 'sensitive))
((eq default-case 'smart)
- (if (isearch-no-upper-case-p re t)
- 'insensitive
- 'sensitive))
+ (if (isearch-no-upper-case-p re t) 'insensitive 'sensitive))
(t default-case)))
;; a pattern
@@ -399,17 +397,15 @@ letter, otherwise it will be case-insensitive."
"Create a PATTERN for substitution with FLAGS.
This function respects the values of `evil-ex-substitute-case'
and `evil-ex-substitute-global'."
- (evil-ex-make-pattern regexp
- (cond
- ((memq ?i flags) 'insensitive)
- ((memq ?I flags) 'sensitive)
- ((not evil-ex-substitute-case)
- evil-ex-search-case)
- (t evil-ex-substitute-case))
- (or (and evil-ex-substitute-global
- (not (memq ?g flags)))
- (and (not evil-ex-substitute-global)
- (memq ?g flags)))))
+ (evil-ex-make-pattern
+ regexp
+ (cond ((memq ?i flags) 'insensitive)
+ ((memq ?I flags) 'sensitive)
+ ((not evil-ex-substitute-case) evil-ex-search-case)
+ (t evil-ex-substitute-case))
+ (if (memq ?g flags)
+ (not evil-ex-substitute-global)
+ evil-ex-substitute-global)))
(defun evil-ex-make-search-pattern (regexp)
"Create a PATTERN for search.
@@ -433,15 +429,14 @@ style regular expression and is not transformed."
;; possibly transform regular expression from vim-style to
;; Emacs-style.
(if (and evil-ex-search-vim-style-regexp
- (not (or (string-match-p "\\`\\\\_<" regexp)
- (string-match-p "\\\\_>\\'" regexp))))
+ (not (or (string-prefix-p "\\_<" regexp)
+ (string-suffix-p "\\_>" regexp))))
(setq re (evil-transform-vim-style-regexp re))
;; Even for Emacs regular expressions we translate certain
;; whitespace sequences
- (setq re (evil-transform-regexp re
- '((?t . "\t")
- (?n . "\n")
- (?r . "\r")))))
+ (setq re (evil-transform-regexp re '((?t . "\t")
+ (?n . "\n")
+ (?r . "\r")))))
(list re ignore-case whole-line)))
(defun evil-ex-pattern-regex (pattern)
@@ -716,20 +711,20 @@ This function does nothing if
`evil-ex-search-interactive' or
(evil-ex-hl-change 'evil-ex-search pattern)))))
(defun evil-ex-search (&optional count)
- "Search forward or backward COUNT times for the current ex search pattern.
-The search pattern is determined by `evil-ex-search-pattern' and
-the direcion is determined by `evil-ex-search-direction'."
+ "Search forward or backward COUNT times for the current Ex search pattern.
+The search pattern is determined by `evil-ex-search-pattern', and the
+direction by `evil-ex-search-direction'."
(setq evil-ex-search-start-point (point)
evil-ex-last-was-search t
count (or count 1))
(let ((orig (point))
wrapped)
(dotimes (_ (or count 1))
- (when (eq evil-ex-search-direction 'forward)
- (unless (eobp) (forward-char))
+ (when (and (eq evil-ex-search-direction 'forward) (not (eobp)))
+ (forward-char)
;; maybe skip end-of-line
- (when (and (not evil-move-beyond-eol) (eolp) (not (eobp)))
- (forward-char)))
+ (and (not evil-move-beyond-eol) (eolp) (not (eobp))
+ (forward-char)))
(let ((res (evil-ex-find-next nil nil (not evil-search-wrap))))
(cond
((not res)
@@ -1040,10 +1035,11 @@ current search result."
evil-ex-search-match-end (match-end 0))
(evil-ex-search-goto-offset offset)
(evil-push-search-history search-string (eq direction 'forward))
- (when (and (not evil-ex-search-incremental)
evil-ex-search-highlight-all)
- (evil-ex-search-activate-highlight pattern))
- (when (and evil-ex-search-incremental (not
evil-ex-search-persistent-highlight))
- (evil-ex-delete-hl 'evil-ex-search)))
+ (if evil-ex-search-incremental
+ (unless evil-ex-search-persistent-highlight
+ (evil-ex-delete-hl 'evil-ex-search))
+ (when evil-ex-search-highlight-all
+ (evil-ex-search-activate-highlight pattern))))
(t
(goto-char evil-ex-search-start-point)
(evil-ex-delete-hl 'evil-ex-search)
diff --git a/evil-tests.el b/evil-tests.el
index cacc1b52bb..b1b3f797b0 100644
--- a/evil-tests.el
+++ b/evil-tests.el
@@ -85,22 +85,21 @@
(defun evil-tests-initialize (&optional tests profiler interactive)
(setq profiler (or profiler evil-tests-profiler))
- (when (listp profiler)
+ (when (consp profiler)
(setq profiler (car profiler)))
(when profiler
(setq evil-tests-profiler t)
(setq profiler
- (or (cdr (assq profiler
- '((call . elp-sort-by-call-count)
- (average . elp-sort-by-average-time)
- (total . elp-sort-by-total-time))))))
+ (cdr (assq profiler
+ '((call . elp-sort-by-call-count)
+ (average . elp-sort-by-average-time)
+ (total . elp-sort-by-total-time)))))
(setq elp-sort-by-function (or profiler 'elp-sort-by-call-count))
(elp-instrument-package "evil"))
(if interactive
(if (y-or-n-p-with-timeout "Run tests? " 2 t)
(evil-tests-run tests interactive)
- (message "You can run the tests at any time \
-with `M-x evil-tests-run'"))
+ (message "You can run the tests at any time with `M-x
evil-tests-run'"))
(evil-tests-run tests)))
(defun evil-tests-run (&optional tests interactive)
diff --git a/evil-vars.el b/evil-vars.el
index 47a2a3d203..f9de9074b6 100644
--- a/evil-vars.el
+++ b/evil-vars.el
@@ -1903,9 +1903,6 @@ Key sequences bound in this map are immediately
executed.")
This content of this variable is appended to the Ex command line
when Ex is started interactively.")
-(defvar evil-ex-commands nil
- "Association list of command bindings and functions.")
-
(defvar evil-ex-history nil
"History of Ex commands.")
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [nongnu] elpa/evil 0cbd61f2de: Some cleanups,
ELPA Syncer <=