diff options
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/evil-20180517.1300/evil-vars.el')
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/evil-20180517.1300/evil-vars.el | 1879 |
1 files changed, 1879 insertions, 0 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/evil-20180517.1300/evil-vars.el b/configs/shared/emacs/.emacs.d/elpa/evil-20180517.1300/evil-vars.el new file mode 100644 index 0000000000..33cb44b8e6 --- /dev/null +++ b/configs/shared/emacs/.emacs.d/elpa/evil-20180517.1300/evil-vars.el @@ -0,0 +1,1879 @@ +;;; evil-vars.el --- Settings and variables + +;; Author: Vegard Øye <vegard_oye at hotmail.com> +;; Maintainer: Vegard Øye <vegard_oye at hotmail.com> + +;; Version: 1.2.13 + +;; +;; This file is NOT part of GNU Emacs. + +;;; License: + +;; This file is part of Evil. +;; +;; Evil is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. +;; +;; Evil is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License +;; along with Evil. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(declare-function evil-add-command-properties "evil-common" + (command &rest properties)) +(declare-function evil-update-insert-state-bindings "evil-maps" + (&optional _option-name remove force)) + +;;; Hooks + +(defvar evil-after-load-hook nil + "Functions to be run when loading of evil is finished. +This hook can be used the execute some initialization routines +when evil is completely loaded.") + +;;; Initialization + +(defvar evil-pending-custom-initialize nil + "A list of pending initializations for custom variables. +Each element is a triple (FUNC VAR VALUE). When evil is +completely loaded then the functions (funcall FUNC VAR VALUE) is +called for each element. FUNC should be a function suitable for +the :initialize property of `defcustom'.") + +(defun evil-custom-initialize-pending-reset (var value) + "Add a pending customization with `custom-initialize-reset'." + (push (list 'custom-initialize-reset var value) + evil-pending-custom-initialize)) + +(defun evil-run-pending-custom-initialize () + "Executes the pending initializations. +See `evil-pending-custom-initialize'." + (dolist (init evil-pending-custom-initialize) + (apply (car init) (cdr init))) + (remove-hook 'evil-after-load-hook 'evil-run-pending-custom-initialize)) +(add-hook 'evil-after-load-hook 'evil-run-pending-custom-initialize) + +;;; Setters + +(defun evil-set-toggle-key (key) + "Set `evil-toggle-key' to KEY. +KEY must be readable by `read-kbd-macro'." + (let ((old-key (read-kbd-macro + (if (boundp 'evil-toggle-key) + evil-toggle-key + "C-z"))) + (key (read-kbd-macro key))) + (with-no-warnings + (dolist (pair '((evil-motion-state-map evil-emacs-state) + (evil-insert-state-map evil-emacs-state) + (evil-emacs-state-map evil-exit-emacs-state))) + (when (boundp (car pair)) + (let ((map (symbol-value (car pair))) + (fun (cadr pair))) + (when (keymapp map) + (define-key map key fun) + (define-key map old-key nil)))))))) + +(defun evil-set-custom-state-maps (var pending-var key make newlist) + "Changes the list of special keymaps. +VAR is the variable containing the list of keymaps. +PENDING-VAR is the variable containing the list of the currently pending + keymaps. +KEY the special symbol to be stored in the keymaps. +MAKE the creation function of the special keymaps. +NEWLIST the list of new special keymaps." + (set-default pending-var newlist) + (when (default-boundp var) + (dolist (map (default-value var)) + (when (and (boundp (car map)) + (keymapp (default-value (car map)))) + (define-key (default-value (car map)) (vector key) nil)))) + (set-default var newlist) + (evil-update-pending-maps)) + +(defun evil-update-pending-maps (&optional file) + "Tries to set pending special keymaps. +This function should be called from an `after-load-functions' +hook." + (let ((maps '((evil-make-overriding-map . evil-pending-overriding-maps) + (evil-make-intercept-map . evil-pending-intercept-maps)))) + (while maps + (let* ((map (pop maps)) + (make (car map)) + (pending-var (cdr map)) + (pending (symbol-value pending-var)) + newlist) + (while pending + (let* ((map (pop pending)) + (kmap (and (boundp (car map)) + (keymapp (symbol-value (car map))) + (symbol-value (car map)))) + (state (cdr map))) + (if kmap + (funcall make kmap state) + (push map newlist)))) + (set-default pending-var newlist))))) + +(defun evil-set-visual-newline-commands (var value) + "Set the value of `evil-visual-newline-commands'. +Setting this variable changes the properties of the appropriate +commands." + (with-no-warnings + (when (default-boundp var) + (dolist (cmd (default-value var)) + (evil-set-command-property cmd :exclude-newline nil))) + (set-default var value) + (dolist (cmd (default-value var)) + (evil-set-command-property cmd :exclude-newline t)))) + +(defun evil-set-custom-motions (var values) + "Sets the list of motion commands." + (with-no-warnings + (when (default-boundp var) + (dolist (motion (default-value var)) + (evil-add-command-properties motion :keep-visual nil :repeat nil))) + (set-default var values) + (mapc #'evil-declare-motion (default-value var)))) + +;;; Customization group + +(defgroup evil nil + "Extensible vi layer." + :group 'emulations + :prefix 'evil-) + +(defcustom evil-auto-indent t + "Whether to auto-indent when opening lines." + :type 'boolean + :group 'evil) +(make-variable-buffer-local 'evil-auto-indent) + +(defcustom evil-shift-width 4 + "The offset used by \\<evil-normal-state-map>\\[evil-shift-right] \ +and \\[evil-shift-left]." + :type 'integer + :group 'evil) +(make-variable-buffer-local 'evil-shift-width) + +(defcustom evil-shift-round t + "Whether \\<evil-normal-state-map>\\[evil-shift-right] \ +and \\[evil-shift-left] round to the nearest multiple \ +of `evil-shift-width'." + :type 'boolean + :group 'evil) +(make-variable-buffer-local 'evil-shift-round) + +(defcustom evil-indent-convert-tabs t + "If non-nil `evil-indent' converts between leading tabs and spaces. + Whether tabs are converted to spaces or vice versa depends on the + value of `indent-tabs-mode'." + :type 'boolean + :group 'evil) + +(defcustom evil-default-cursor t + "The default cursor. +May be a cursor type as per `cursor-type', a color string as passed +to `set-cursor-color', a zero-argument function for changing the +cursor, or a list of the above." + :type '(set symbol (cons symbol symbol) string function) + :group 'evil) + +(defvar evil-force-cursor nil + "Overwrite the current states default cursor.") + +(defcustom evil-repeat-move-cursor t + "Whether \"\\<evil-normal-state-map>\\[evil-repeat]\" \ +moves the cursor." + :type 'boolean + :group 'evil) + +(defcustom evil-cross-lines nil + "Whether motions may cross newlines." + :type 'boolean + :group 'evil) + +(defcustom evil-backspace-join-lines t + "Whether backward delete in insert state may join lines." + :type 'boolean + :group 'evil) + +(defcustom evil-move-cursor-back t + "Whether the cursor is moved backwards when exiting Insert state." + :type 'boolean + :group 'evil) + +(defcustom evil-move-beyond-eol nil + "Whether the cursor is allowed to move past the last character of \ +a line." + :type 'boolean + :group 'evil) + +(defcustom evil-respect-visual-line-mode nil + "Whether to remap movement commands when `visual-line-mode' is active. +This variable must be set before evil is loaded. The commands +swapped are + +`evil-next-line' <-> `evil-next-visual-line' +`evil-previous-line' <-> `evil-previous-visual-line' +`evil-beginning-of-line' <-> `evil-beginning-of-visual-line' +`evil-end-of-line' <-> `evil-end-of-visual-line'" + :type 'boolean + :group 'evil) + +(defcustom evil-repeat-find-to-skip-next t + "Whether a repeat of t or T should skip an adjacent character." + :type 'boolean + :group 'evil) + +(defcustom evil-kbd-macro-suppress-motion-error nil + "Whether left/right motions signal errors during keyboard-macro definition. +If this variable is set to non-nil, then the function +`evil-forward-char' and `evil-backward-char' do not signal +`end-of-line' or `beginning-of-line' errors when a keyboard macro +is being defined and/or it is being executed. This may be desired +because such an error would cause the macro definition/execution +being terminated." + :type '(radio (const :tag "No" :value nil) + (const :tag "Record" :value record) + (const :tag "Replay" :value replay) + (const :tag "Both" :value t)) + :group 'evil) + +(defcustom evil-track-eol t + "If non-nil line moves after a call to `evil-end-of-line' stay at eol. +This is analogous to `track-eol' but deals with the end-of-line +interpretation of evil." + :type 'boolean + :group 'evil) + +(defcustom evil-mode-line-format 'before + "The position of the mode line tag. +Either a symbol or a cons-cell. If it is a symbol it should be +one of 'before, 'after or 'nil. 'before means the tag is +placed before the mode-list, 'after means it is placed after the +mode-list, and 'nil means no mode line tag. If it is a cons cell +it should have the form (WHERE . WHICH) where WHERE is either +'before or 'after and WHICH is a symbol in +`mode-line-format'. The tag is then placed right before or after +that symbol." + :type '(radio :value 'before + (const before) + (const after) + (cons :tag "Next to symbol" + (choice :value after + (const before) + (const after)) + symbol)) + :group 'evil) + +(defcustom evil-mouse-word 'evil-word + "The thing-at-point symbol for double click selection. +The double-click starts visual state in a special word selection +mode. This symbol is used to determine the words to be +selected. Possible values are 'evil-word or +'evil-WORD." + :type 'symbol + :group 'evil) + +(defcustom evil-bigword "^ \t\r\n" + "The characters to be considered as a big word. +This should be a regexp set without the enclosing []." + :type 'string + :group 'evil) +(make-variable-buffer-local 'evil-bigword) + +(defcustom evil-want-fine-undo nil + "Whether actions like \"cw\" are undone in several steps. +There are three possible choices. \"No\" means all changes made +during insert state including a possible delete after a change +operation are collected in a single undo step. If \"Yes\" is +selected, undo steps are determined according to Emacs heuristics +and no attempt is made to further aggregate changes. + +As of 1.2.13, the option \"fine\" is ignored and means the same +thing as \"No\". It used to be the case that fine would only try +to merge the first two changes in an insert operation. For +example, merging the delete and first insert operation after +\"cw\", but this option was removed because it did not work +consistently." + :type '(radio (const :tag "No" :value nil) + (const :tag "Fine (obsolete)" :value fine) + (const :tag "Yes" :value t)) + :group 'evil) + +(defcustom evil-regexp-search t + "Whether to use regular expressions for searching." + :type 'boolean + :group 'evil) + +(defcustom evil-search-wrap t + "Whether search wraps around." + :type 'boolean + :group 'evil) + +(defcustom evil-flash-delay 2 + "Time in seconds to flash search matches." + :type 'number + :group 'evil) + +(defcustom evil-fold-level 0 + "Default fold level." + :type 'integer + :group 'evil) + +(defcustom evil-auto-balance-windows t + "If non-nil creating/deleting a window causes a rebalance." + :type 'boolean + :group 'evil) + +(defcustom evil-split-window-below nil + "If non-nil split windows are created below." + :type 'boolean + :group 'evil) + +(defcustom evil-vsplit-window-right nil + "If non-nil vsplit windows are created to the right." + :type 'boolean + :group 'evil) + +(defcustom evil-esc-delay 0.01 + "Time in seconds to wait for another key after ESC." + :type 'number + :group 'evil) + +(defvar evil-esc-mode nil + "Non-nil if `evil-esc-mode' is enabled.") + +(defvar evil-esc-map nil + "Original ESC prefix map in `input-decode-map'. +Used by `evil-esc-mode'.") + +(defvar evil-inhibit-esc nil + "If non-nil, the \\e event will never be translated to 'escape.") + +(defcustom evil-intercept-esc 'always + "Whether evil should intercept the ESC key. +In terminal, a plain ESC key and a meta-key-sequence both +generate the same event. In order to distinguish both evil +modifies `input-decode-map'. This is necessary in terminal but +not in X mode. However, the terminal ESC is equivalent to C-[, so +if you want to use C-[ instead of ESC in X, then Evil must +intercept the ESC event in X, too. This variable determines when +Evil should intercept the event." + :type '(radio (const :tag "Never" :value nil) + (const :tag "In terminal only" :value t) + (const :tag "Always" :value always)) + :group 'evil) + +(defcustom evil-show-paren-range 0 + "The minimal distance between point and a parenthesis +which causes the parenthesis to be highlighted." + :type 'integer + :group 'evil) + +(defcustom evil-ex-hl-update-delay 0.02 + "Time in seconds of idle before updating search highlighting. +Setting this to a period shorter than that of keyboard's repeat +rate allows highlights to update while scrolling." + :type 'number + :group 'evil) + +(defcustom evil-highlight-closing-paren-at-point-states + '(not emacs insert replace) + "The states in which the closing parenthesis at point should be highlighted. +All states listed here highlight the closing parenthesis at +point (which is Vim default behavior), all others highlight the +parenthesis before point (which is Emacs default behavior). If +this list contains the symbol 'not then its meaning is inverted, +i.e., all states listed here highlight the closing parenthesis +before point." + :type '(repeat symbol) + :group 'evil) + +(defcustom evil-kill-on-visual-paste t + "Whether `evil-visual-paste' adds the replaced text to the kill +ring, making it the default for the next paste. The default, t, +replicates the default vim behavior." + :type 'boolean + :group 'evil) + +(defcustom evil-want-C-i-jump t + "Whether \"C-i\" jumps forward like in Vim." + :type 'boolean + :group 'evil + :set #'(lambda (sym value) + (set-default sym value) + (when (boundp 'evil-motion-state-map) + (cond + ((and (not value) + (eq (lookup-key evil-motion-state-map (kbd "C-i")) + 'evil-jump-forward)) + (define-key evil-motion-state-map (kbd "C-i") nil)) + ((and value + (not (lookup-key evil-motion-state-map (kbd "C-i")))) + (define-key evil-motion-state-map (kbd "C-i") 'evil-jump-forward)))))) + +(defcustom evil-want-C-u-scroll nil + "Whether \"C-u\" scrolls like in Vim." + :type 'boolean + :group 'evil + :set #'(lambda (sym value) + (set-default sym value) + (when (boundp 'evil-motion-state-map) + (cond + ((and (not value) + (eq (lookup-key evil-motion-state-map (kbd "C-u")) + 'evil-scroll-up)) + (define-key evil-motion-state-map (kbd "C-u") nil)) + ((and value + (not (lookup-key evil-motion-state-map (kbd "C-u")))) + (define-key evil-motion-state-map (kbd "C-u") 'evil-scroll-up)))))) + +(defcustom evil-want-C-d-scroll t + "Whether \"C-d\" scrolls like in Vim." + :type 'boolean + :group 'evil + :set #'(lambda (sym value) + (set-default sym value) + (when (boundp 'evil-motion-state-map) + (cond + ((and (not value) + (eq (lookup-key evil-motion-state-map (kbd "C-d")) + 'evil-scroll-down)) + (define-key evil-motion-state-map (kbd "C-d") nil)) + ((and value + (not (lookup-key evil-motion-state-map (kbd "C-d")))) + (define-key evil-motion-state-map (kbd "C-d") 'evil-scroll-down)))))) + +(defcustom evil-want-C-w-delete t + "Whether \"C-w\" deletes a word in Insert state." + :type 'boolean + :group 'evil + :set #'(lambda (sym value) + (set-default sym value) + (when (boundp 'evil-insert-state-map) + (cond + ((and (not value) + (eq (lookup-key evil-insert-state-map (kbd "C-w")) + 'evil-delete-backward-word)) + (define-key evil-insert-state-map (kbd "C-w") 'evil-window-map)) + ((and value + (eq (lookup-key evil-insert-state-map (kbd "C-w")) + 'evil-window-map)) + (define-key evil-insert-state-map (kbd "C-w") 'evil-delete-backward-word)))))) + +(defcustom evil-want-C-w-in-emacs-state nil + "Whether \"C-w\" prefixes windows commands in Emacs state." + :type 'boolean + :group 'evil + :set #'(lambda (sym value) + (set-default sym value) + (when (boundp 'evil-emacs-state-map) + (cond + ((and (not value) + (eq (lookup-key evil-emacs-state-map (kbd "C-w")) + 'evil-window-map)) + (define-key evil-emacs-state-map (kbd "C-w") nil)) + ((and value + (not (lookup-key evil-emacs-state-map (kbd "C-w")))) + (define-key evil-emacs-state-map (kbd "C-w") 'evil-window-map)))))) + +(defcustom evil-want-change-word-to-end t + "Whether \"cw\" behaves like \"ce\"." + :type 'boolean + :group 'evil) + +(defcustom evil-want-Y-yank-to-eol nil + "Whether \"Y\" yanks to the end of the line. +The default behavior is to yank the whole line." + :group 'evil + :type 'boolean + :initialize #'evil-custom-initialize-pending-reset + :set #'(lambda (sym value) + (evil-add-command-properties + 'evil-yank-line + :motion (if value 'evil-end-of-line 'evil-line)))) + +(defcustom evil-disable-insert-state-bindings nil + "Whether insert state bindings should be used. Excludes +bindings for escape, delete and `evil-toggle-key'." + :group 'evil + :type 'boolean + :initialize #'evil-custom-initialize-pending-reset + :set #'evil-update-insert-state-bindings) + +(defcustom evil-echo-state t + "Whether to signal the current state in the echo area." + :type 'boolean + :group 'evil) + +(defcustom evil-complete-all-buffers t + "Whether completion looks for matches in all buffers." + :type 'boolean + :group 'evil) + +(defcustom evil-complete-next-func + #'(lambda (arg) + (require 'dabbrev) + (let ((dabbrev-search-these-buffers-only + (unless evil-complete-all-buffers + (list (current-buffer)))) + dabbrev-case-distinction) + (condition-case nil + (if (eq last-command this-command) + (dabbrev-expand nil) + (dabbrev-expand (- (abs (or arg 1))))) + (error (dabbrev-expand nil))))) + "Completion function used by \ +\\<evil-insert-state-map>\\[evil-complete-next]." + :type 'function + :group 'evil) + +(defcustom evil-complete-previous-func + #'(lambda (arg) + (require 'dabbrev) + (let ((dabbrev-search-these-buffers-only + (unless evil-complete-all-buffers + (list (current-buffer)))) + dabbrev-case-distinction) + (dabbrev-expand arg))) + "Completion function used by \ +\\<evil-insert-state-map>\\[evil-complete-previous]." + :type 'function + :group 'evil) + +(defcustom evil-complete-next-minibuffer-func 'minibuffer-complete + "Minibuffer completion function used by \ +\\<evil-insert-state-map>\\[evil-complete-next]." + :type 'function + :group 'evil) + +(defcustom evil-complete-previous-minibuffer-func 'minibuffer-complete + "Minibuffer completion function used by \ +\\<evil-insert-state-map>\\[evil-complete-previous]." + :type 'function + :group 'evil) + +(defcustom evil-complete-next-line-func + #'(lambda (arg) + (let ((hippie-expand-try-functions-list + '(try-expand-line + try-expand-line-all-buffers))) + (hippie-expand arg))) + "Minibuffer completion function used by \ +\\<evil-insert-state-map>\\[evil-complete-next-line]." + :type 'function + :group 'evil) + +(defcustom evil-complete-previous-line-func + evil-complete-next-line-func + "Minibuffer completion function used by \ +\\<evil-insert-state-map>\\[evil-complete-previous-line]." + :type 'function + :group 'evil) + +(defcustom evil-lookup-func #'woman + "Lookup function used by \ +\"\\<evil-motion-state-map>\\[evil-lookup]\"." + :type 'function + :group 'evil) + +(defcustom evil-toggle-key "C-z" + "The key used to change to and from Emacs state. +Must be readable by `read-kbd-macro'. For example: \"C-z\"." + :type 'string + :group 'evil + :set #'(lambda (sym value) + (evil-set-toggle-key value) + (set-default sym value))) + +(defcustom evil-default-state 'normal + "The default state. +This is the state a mode comes up in when it is not listed +in `evil-emacs-state-modes', `evil-insert-state-modes' or +`evil-motion-state-modes'. The value may be one of `normal', +`insert', `visual', `replace', `operator', `motion' and +`emacs'." + :type 'symbol + :group 'evil) + +(defcustom evil-buffer-regexps + '(("^ \\*load\\*" . nil)) + "Regular expression determining the initial state for a buffer. +Entries have the form (REGEXP . STATE), where REGEXP is a regular +expression matching the buffer's name and STATE is one of `normal', +`insert', `visual', `replace', `operator', `motion', `emacs' and nil. +If STATE is nil, Evil is disabled in the buffer." + :type '(alist :key-type string :value-type symbol) + :group 'evil) + +(defcustom evil-emacs-state-modes + '(5x5-mode + archive-mode + bbdb-mode + biblio-selection-mode + blackbox-mode + bookmark-bmenu-mode + bookmark-edit-annotation-mode + browse-kill-ring-mode + bubbles-mode + bzr-annotate-mode + calc-mode + cfw:calendar-mode + completion-list-mode + Custom-mode + custom-theme-choose-mode + debugger-mode + delicious-search-mode + desktop-menu-blist-mode + desktop-menu-mode + doc-view-mode + dun-mode + dvc-bookmarks-mode + dvc-diff-mode + dvc-info-buffer-mode + dvc-log-buffer-mode + dvc-revlist-mode + dvc-revlog-mode + dvc-status-mode + dvc-tips-mode + ediff-mode + ediff-meta-mode + efs-mode + Electric-buffer-menu-mode + emms-browser-mode + emms-mark-mode + emms-metaplaylist-mode + emms-playlist-mode + ess-help-mode + etags-select-mode + fj-mode + gc-issues-mode + gdb-breakpoints-mode + gdb-disassembly-mode + gdb-frames-mode + gdb-locals-mode + gdb-memory-mode + gdb-registers-mode + gdb-threads-mode + gist-list-mode + git-commit-mode + git-rebase-mode + gnus-article-mode + gnus-browse-mode + gnus-group-mode + gnus-server-mode + gnus-summary-mode + gomoku-mode + google-maps-static-mode + ibuffer-mode + jde-javadoc-checker-report-mode + magit-cherry-mode + magit-diff-mode + magit-log-mode + magit-log-select-mode + magit-popup-mode + magit-popup-sequence-mode + magit-process-mode + magit-reflog-mode + magit-refs-mode + magit-revision-mode + magit-stash-mode + magit-stashes-mode + magit-status-mode + ;; Obsolete as of Magit v2.1.0 + magit-mode + magit-branch-manager-mode + magit-commit-mode + magit-key-mode + magit-rebase-mode + magit-wazzup-mode + ;; end obsolete + mh-folder-mode + monky-mode + mpuz-mode + mu4e-main-mode + mu4e-headers-mode + mu4e-view-mode + notmuch-hello-mode + notmuch-search-mode + notmuch-show-mode + notmuch-tree-mode + occur-mode + org-agenda-mode + package-menu-mode + pdf-outline-buffer-mode + pdf-view-mode + proced-mode + rcirc-mode + rebase-mode + recentf-dialog-mode + reftex-select-bib-mode + reftex-select-label-mode + reftex-toc-mode + sldb-mode + slime-inspector-mode + slime-thread-control-mode + slime-xref-mode + snake-mode + solitaire-mode + sr-buttons-mode + sr-mode + sr-tree-mode + sr-virtual-mode + tar-mode + tetris-mode + tla-annotate-mode + tla-archive-list-mode + tla-bconfig-mode + tla-bookmarks-mode + tla-branch-list-mode + tla-browse-mode + tla-category-list-mode + tla-changelog-mode + tla-follow-symlinks-mode + tla-inventory-file-mode + tla-inventory-mode + tla-lint-mode + tla-logs-mode + tla-revision-list-mode + tla-revlog-mode + tla-tree-lint-mode + tla-version-list-mode + twittering-mode + urlview-mode + vc-annotate-mode + vc-dir-mode + vc-git-log-view-mode + vc-hg-log-view-mode + vc-svn-log-view-mode + vm-mode + vm-summary-mode + w3m-mode + wab-compilation-mode + xgit-annotate-mode + xgit-changelog-mode + xgit-diff-mode + xgit-revlog-mode + xhg-annotate-mode + xhg-log-mode + xhg-mode + xhg-mq-mode + xhg-mq-sub-mode + xhg-status-extra-mode) + "Modes that should come up in Emacs state." + :type '(repeat symbol) + :group 'evil) + +(defcustom evil-insert-state-modes + '(comint-mode + erc-mode + eshell-mode + geiser-repl-mode + gud-mode + inferior-apl-mode + inferior-caml-mode + inferior-emacs-lisp-mode + inferior-j-mode + inferior-python-mode + inferior-scheme-mode + inferior-sml-mode + internal-ange-ftp-mode + prolog-inferior-mode + reb-mode + shell-mode + slime-repl-mode + term-mode + wdired-mode) + "Modes that should come up in Insert state." + :type '(repeat symbol) + :group 'evil) + +(defcustom evil-motion-state-modes + '(apropos-mode + Buffer-menu-mode + calendar-mode + color-theme-mode + command-history-mode + compilation-mode + dictionary-mode + ert-results-mode + help-mode + Info-mode + Man-mode + speedbar-mode + undo-tree-visualizer-mode + woman-mode) + "Modes that should come up in Motion state." + :type '(repeat symbol) + :group 'evil) + +(defvar evil-pending-overriding-maps nil + "An alist of pending overriding maps.") + +(defvar evil-pending-intercept-maps nil + "An alist of pending intercept maps.") + +(defcustom evil-overriding-maps + '((Buffer-menu-mode-map . nil) + (color-theme-mode-map . nil) + (comint-mode-map . nil) + (compilation-mode-map . nil) + (grep-mode-map . nil) + (dictionary-mode-map . nil) + (ert-results-mode-map . motion) + (Info-mode-map . motion) + (speedbar-key-map . nil) + (speedbar-file-key-map . nil) + (speedbar-buffers-key-map . nil)) + "Keymaps that should override Evil maps. +Entries have the form (MAP-VAR . STATE), where MAP-VAR is +a keymap variable and STATE is the state whose bindings +should be overridden. If STATE is nil, all states are +overridden." + :type '(alist :key-type symbol :value-type symbol) + :group 'evil + :set #'(lambda (var values) + (evil-set-custom-state-maps 'evil-overriding-maps + 'evil-pending-overriding-maps + 'override-state + 'evil-make-overriding-map + values)) + :initialize 'evil-custom-initialize-pending-reset) + +(add-hook 'after-load-functions #'evil-update-pending-maps) + +(defcustom evil-intercept-maps + '((edebug-mode-map . nil)) + "Keymaps that should intercept Evil maps. +Entries have the form (MAP-VAR . STATE), where MAP-VAR is +a keymap variable and STATE is the state whose bindings +should be intercepted. If STATE is nil, all states are +intercepted." + :type '(alist :key-type symbol :value-type symbol) + :group 'evil + :set #'(lambda (var values) + (evil-set-custom-state-maps 'evil-intercept-maps + 'evil-pending-intercept-maps + 'intercept-state + 'evil-make-intercept-map + values)) + :initialize 'evil-custom-initialize-pending-reset) + +(defcustom evil-motions + '(back-to-indentation + backward-char + backward-list + backward-paragraph + backward-sentence + backward-sexp + backward-up-list + backward-word + beginning-of-buffer + beginning-of-defun + beginning-of-line + beginning-of-visual-line + c-beginning-of-defun + c-end-of-defun + diff-file-next + diff-file-prev + diff-hunk-next + diff-hunk-prev + down-list + end-of-buffer + end-of-defun + end-of-line + end-of-visual-line + exchange-point-and-mark + forward-char + forward-list + forward-paragraph + forward-sentence + forward-sexp + forward-word + goto-last-change + ibuffer-backward-line + ibuffer-forward-line + isearch-abort + isearch-cancel + isearch-complete + isearch-del-char + isearch-delete-char + isearch-edit-string + isearch-exit + isearch-highlight-regexp + isearch-occur + isearch-other-control-char + isearch-other-meta-char + isearch-printing-char + isearch-query-replace + isearch-query-replace-regexp + isearch-quote-char + isearch-repeat-backward + isearch-repeat-forward + isearch-ring-advance + isearch-ring-retreat + isearch-toggle-case-fold + isearch-toggle-input-method + isearch-toggle-regexp + isearch-toggle-specified-input-method + isearch-toggle-word + isearch-yank-char + isearch-yank-kill + isearch-yank-line + isearch-yank-word-or-char + keyboard-quit + left-char + left-word + mouse-drag-region + mouse-save-then-kill + mouse-set-point + mouse-set-region + mwheel-scroll + move-beginning-of-line + move-end-of-line + next-error + next-line + paredit-backward + paredit-backward-down + paredit-backward-up + paredit-forward + paredit-forward-down + paredit-forward-up + pop-global-mark + pop-tag-mark + pop-to-mark-command + previous-error + previous-line + right-char + right-word + scroll-down + scroll-down-command + scroll-up + scroll-up-command + sgml-skip-tag-backward + sgml-skip-tag-forward + up-list) + "Non-Evil commands to initialize to motions." + :type '(repeat symbol) + :group 'evil + :set 'evil-set-custom-motions + :initialize 'evil-custom-initialize-pending-reset) + +(defcustom evil-visual-newline-commands + '(LaTeX-section + TeX-font) + "Commands excluding the trailing newline of a Visual Line selection. +These commands work better without this newline." + :type '(repeat symbol) + :group 'evil + :set 'evil-set-visual-newline-commands + :initialize 'evil-custom-initialize-pending-reset) + +(defcustom evil-want-visual-char-semi-exclusive nil + "Visual character selection to beginning/end of line is exclusive. +If non nil then an inclusive visual character selection which +ends at the beginning or end of a line is turned into an +exclusive selection. Thus if the selected (inclusive) range ends +at the beginning of a line it is changed to not include the first +character of that line, and if the selected range ends at the end +of a line it is changed to not include the newline character of +that line." + :type 'boolean + :group 'evil) + +(defcustom evil-text-object-change-visual-type t + "Text objects change the current visual state type. +If non-nil then a text-object changes the type of the visual state to +its default selection type (e.g. a word object always changes to +charwise visual state). Otherwise the current visual state type is +preserved." + :type 'boolean + :group 'evil) + +(defgroup evil-cjk nil + "CJK support" + :prefix "evil-cjk-" + :group 'evil) + +(defcustom evil-cjk-emacs-word-boundary nil + "Determine word boundary exactly the same way as Emacs does." + :type 'boolean + :group 'evil-cjk) + +(defcustom evil-cjk-word-separating-categories + '(;; Kanji + (?C . ?H) (?C . ?K) (?C . ?k) (?C . ?A) (?C . ?G) + ;; Hiragana + (?H . ?C) (?H . ?K) (?H . ?k) (?H . ?A) (?H . ?G) + ;; Katakana + (?K . ?C) (?K . ?H) (?K . ?k) (?K . ?A) (?K . ?G) + ;; half-width Katakana + (?k . ?C) (?k . ?H) (?k . ?K) ; (?k . ?A) (?k . ?G) + ;; full-width alphanumeric + (?A . ?C) (?A . ?H) (?A . ?K) ; (?A . ?k) (?A . ?G) + ;; full-width Greek + (?G . ?C) (?G . ?H) (?G . ?K) ; (?G . ?k) (?G . ?A) + ) + "List of pair (cons) of categories to determine word boundary +used in `evil-cjk-word-boundary-p'. See the documentation of +`word-separating-categories'. Use `describe-categories' to see +the list of categories." + :type '(alist :key-type (choice character (const nil)) + :value-type (choice character (const nil))) + :group 'evil-cjk) + +(defcustom evil-cjk-word-combining-categories + '(;; default value in word-combining-categories + (nil . ?^) (?^ . nil) + ;; Roman + (?r . ?k) (?r . ?A) (?r . ?G) + ;; half-width Katakana + (?k . ?r) (?k . ?A) (?k . ?G) + ;; full-width alphanumeric + (?A . ?r) (?A . ?k) (?A . ?G) + ;; full-width Greek + (?G . ?r) (?G . ?k) (?G . ?A) + ) + "List of pair (cons) of categories to determine word boundary +used in `evil-cjk-word-boundary-p'. See the documentation of +`word-combining-categories'. Use `describe-categories' to see the +list of categories." + :type '(alist :key-type (choice character (const nil)) + :value-type (choice character (const nil))) + :group 'evil-cjk) + +(defcustom evil-ex-complete-emacs-commands 'in-turn + "TAB-completion for Emacs commands in ex command line. +This variable determines when Emacs commands are considered for +completion, always, never, or only if no Evil ex command is +available for completion." + :group 'evil + :type '(radio (const :tag "Only if no ex-command." :value in-turn) + (const :tag "Never" :value nil) + (const :tag "Always" :value t))) + +(defface evil-ex-commands '(( nil + :underline t + :slant italic)) + "Face for the evil command in completion in ex mode." + :group 'evil) + +(defface evil-ex-info '(( ((supports :slant)) + :slant italic + :foreground "red")) + "Face for the info message in ex mode." + :group 'evil) + +(defcustom evil-ex-visual-char-range nil + "Type of default ex range in visual char state. +If non-nil the default range when starting an ex command from +character visual state is `<,`> otherwise it is '<,'>. In the +first case the ex command will be passed a region covering only +the visual selection. In the second case the passed region will +be extended to contain full lines." + :group 'evil + :type 'boolean) + +;; Searching +(defcustom evil-symbol-word-search nil + "If nil then * and # search for words otherwise for symbols." + :group 'evil + :type 'boolean) +(make-variable-buffer-local 'evil-symbol-word-search) + +(defcustom evil-magic t + "Meaning which characters in a pattern are magic. +The meaning of those values is the same as in Vim. Note that it +only has influence if the evil search module is chosen in +`evil-search-module'." + :group 'evil + :type '(radio (const :tag "Very magic." :value very-magic) + (const :tag "Magic" :value t) + (const :tag "Nomagic" :value nil) + (const :tag "Very nomagic" :value very-nomagic))) + +(defcustom evil-ex-search-vim-style-regexp nil + "If non-nil Vim-style backslash codes are supported in search patterns. +See `evil-transform-vim-style-regexp' for the supported backslash +codes. Note that this only affects the search command if +`evil-search-module' is set to 'evil-search. The isearch module +always uses plain Emacs regular expressions." + :type 'boolean + :group 'evil) + +(defcustom evil-ex-interactive-search-highlight 'all-windows + "Determine in which windows the interactive highlighting should be shown." + :type '(radio (const :tag "All windows." all-windows) + (const :tag "Selected window." selected-window) + (const :tag "Disable highlighting." nil)) + :group 'evil) + +(defcustom evil-ex-search-persistent-highlight t + "If non-nil matches remain highlighted when the search ends." + :type 'boolean + :group 'evil) + +(defcustom evil-ex-search-case 'smart + "The case behaviour of the search command. +Smart case means that the pattern is case sensitive if and only +if it contains an upper case letter, otherwise it is case +insensitive." + :type '(radio (const :tag "Case sensitive." sensitive) + (const :tag "Case insensitive." insensitive) + (const :tag "Smart case." smart)) + :group 'evil) + +(defcustom evil-ex-substitute-case nil + "The case behaviour of the search command. +Smart case means that the pattern is case sensitive if and only +if it contains an upper case letter, otherwise it is case +insensitive. If nil then the setting of `evil-ex-search-case' is +used." + :type '(radio (const :tag "Same as interactive search." nil) + (const :tag "Case sensitive." sensitive) + (const :tag "Case insensitive." insensitive) + (const :tag "Smart case." smart)) + :group 'evil) + +(defcustom evil-ex-search-interactive t + "If t search is interactive." + :type 'boolean + :group 'evil) + +(defcustom evil-ex-search-highlight-all t + "If t and interactive search is enabled, all matches are +highlighted." + :type 'boolean + :group 'evil) + +(defcustom evil-ex-substitute-highlight-all t + "If t all matches for the substitute pattern are highlighted." + :type 'boolean + :group 'evil) + +(defcustom evil-ex-substitute-interactive-replace t + "If t and substitute patterns are highlighted, +the replacement is shown interactively." + :type 'boolean + :group 'evil) + +(defcustom evil-ex-substitute-global nil + "If non-nil substitute patterns are global by default. +Usually (if this variable is nil) a substitution works only on +the first match of a pattern in a line unless the 'g' flag is +given, in which case the substitution happens on all matches in a +line. If this option is non-nil, this behaviour is reversed: the +substitution works on all matches unless the 'g' pattern is +specified, then is works only on the first match." + :type 'boolean + :group 'evil) + +(defface evil-ex-search '((t :inherit isearch)) + "Face for interactive search." + :group 'evil) + +(defface evil-ex-lazy-highlight '((t :inherit lazy-highlight)) + "Face for highlighting all matches in interactive search." + :group 'evil) + +(defface evil-ex-substitute-matches '((t :inherit lazy-highlight)) + "Face for interactive substitute matches." + :group 'evil) + +(defface evil-ex-substitute-replacement '((((supports :underline)) + :underline t + :foreground "red")) + "Face for interactive replacement text." + :group 'evil) + +(defcustom evil-command-window-height 8 + "Height (in lines) of the command line window. +Set to 0 to use the default height for `split-window'." + :type 'integer + :group 'evil) + +(defcustom evil-display-shell-error-in-message nil + "Show error output of a shell command in the error buffer. +If this variable is non-nil the error output of a shell command +goes to the messages buffer instead of being mixed with the +regular output. This happens only if the exit status of the +command is non-zero." + :type 'boolean + :group 'evil) + +(defcustom evil-want-abbrev-expand-on-insert-exit t + "If non-nil abbrevs will be expanded when leaving Insert state +like in Vim. This variable is read only on load." + :type 'boolean + :group 'evil) + +;;; Variables + +(defmacro evil-define-local-var (symbol &optional initvalue docstring) + "Define SYMBOL as permanent buffer local variable, and return SYMBOL. +The parameters are the same as for `defvar', but the variable +SYMBOL is made permanent buffer local." + (declare (indent defun) + (debug (symbolp &optional form stringp))) + `(progn + (defvar ,symbol ,initvalue ,docstring) + (make-variable-buffer-local ',symbol) + (put ',symbol 'permanent-local t))) + +(evil-define-local-var evil-scroll-count 0 + "Holds last used prefix for `evil-scroll-up' +and `evil-scroll-down'. +Determines how many lines should be scrolled. +Default value is 0 - scroll half the screen.") + +(evil-define-local-var evil-state nil + "The current Evil state. +To change the state, use `evil-change-state' +or call the state function (e.g., `evil-normal-state').") + +;; these may be used inside `evil-define-state' +(evil-define-local-var evil-next-state nil + "The Evil state being switched to.") + +(evil-define-local-var evil-previous-state-alist nil + "For Each evil state the Evil state being switched from.") + +(evil-define-local-var evil-previous-state nil + "The Evil state being switched from.") + +(defvar evil-execute-in-emacs-state-buffer nil + "The buffer of the latest `evil-execute-in-emacs-state'. +When this command is being executed the current buffer is stored +in this variable. This is necessary in case the Emacs-command to +be called changes the current buffer.") + +(evil-define-local-var evil-mode-line-tag nil + "Mode-Line indicator for the current state.") +(put 'evil-mode-line-tag 'risky-local-variable t) + +(defvar evil-global-keymaps-alist nil + "Association list of keymap variables. +Entries have the form (MODE . KEYMAP), where KEYMAP +is the variable containing the keymap for MODE.") + +(defvar evil-local-keymaps-alist nil + "Association list of keymap variables that must be +reinitialized in each buffer. Entries have the form +\(MODE . KEYMAP), where KEYMAP is the variable containing +the keymap for MODE.") + +(defvar evil-minor-mode-keymaps-alist nil + "Association list of evil states to minor-mode keymap alists. +Entries have the form (STATE . MODE-MAP-ALIST), where +MODE-MAP-ALIST is an alist taking the form of +`minor-mode-map-alist'.") + +(defvar evil-state-properties nil + "Specifications made by `evil-define-state'. +Entries have the form (STATE . PLIST), where PLIST is a property +list specifying various aspects of the state. To access a property, +use `evil-state-property'.") + +(evil-define-local-var evil-mode-map-alist nil + "Association list of keymaps to use for Evil modes. +Elements have the form (MODE . KEYMAP), with the first keymaps +having higher priority.") + +(defvar evil-command-properties nil + "Specifications made by `evil-define-command'.") + +(defvar evil-change-commands '(evil-change) + "Commands that wrap or replace `evil-change'. +This list exists to apply an inconsistency with vim's change command +to commands that wrap or redefine it. See emacs-evil/evil#916.") + +(defvar evil-transient-vars '(cua-mode transient-mark-mode select-active-regions) + "List of variables pertaining to Transient Mark mode.") + +(defvar evil-transient-vals nil + "Association list of old values for Transient Mark mode variables. +Entries have the form (VARIABLE VALUE LOCAL), where LOCAL is +whether the variable was previously buffer-local.") + +(evil-define-local-var evil-no-display nil + "If non-nil, various Evil displays are inhibited. +Use the macro `evil-without-display' to set this variable.") + +(defvar evil-type-properties nil + "Specifications made by `evil-define-type'. +Entries have the form (TYPE . PLIST), where PLIST is a property +list specifying functions for handling the type: expanding it, +describing it, etc.") + +(defvar evil-interactive-alist nil + "Association list of Evil-specific interactive codes.") + +(evil-define-local-var evil-motion-marker nil + "Marker for storing the starting position of a motion.") + +(evil-define-local-var evil-this-type nil + "Current motion type.") + +(evil-define-local-var evil-this-type-modified nil + "Non-nil iff current motion type has been modified by the user. +If the type has been modified, this variable contains the new +type.") + +(evil-define-local-var evil-this-register nil + "Current register.") + +(defvar evil-this-macro nil + "Current macro register.") + +(evil-define-local-var evil-this-operator nil + "Current operator.") + +(evil-define-local-var evil-this-motion nil + "Current motion.") + +(evil-define-local-var evil-this-motion-count nil + "Current motion count.") + +(defvar evil-last-register nil + "The last executed register.") + +(defvar evil-inhibit-operator nil + "Inhibit current operator. +If an operator calls a motion and the motion sets this variable +to t, the operator code is not executed.") + +(defvar evil-inhibit-operator-value nil + "This variable is used to transfer the value +of `evil-inhibit-operator' from one local scope to another.") + +;; used by `evil-define-operator' +(defvar evil-operator-range-beginning nil + "Beginning of `evil-operator-range'.") + +(defvar evil-operator-range-end nil + "End of `evil-operator-range'.") + +(defvar evil-operator-range-type nil + "Type of `evil-operator-range'.") + +(defvar evil-operator-range-motion nil + "Motion of `evil-operator-range'.") + +(defvar evil-restriction-stack nil + "List of previous restrictions. +Using `evil-with-restriction' stores the previous values of +`point-min' and `point-max' as a pair in this list.") + +(evil-define-local-var evil-markers-alist + '((?\( . evil-backward-sentence) + (?\) . evil-forward-sentence) + (?{ . evil-backward-paragraph) + (?} . evil-forward-paragraph) + (?' . evil-jump-backward-swap) + (?` . evil-jump-backward-swap) + (?< . evil-visual-beginning) + (?> . evil-visual-goto-end) + (?. . (lambda () + (let (last-command) + (goto-last-change nil))))) + "Association list for markers. +Entries have the form (CHAR . DATA), where CHAR is the marker's +name and DATA is either a marker object as returned by `make-marker', +a variable, a movement function, or a cons cell (STRING NUMBER), +where STRING is a file path and NUMBER is a buffer position. +The global value of this variable holds markers available from +every buffer, while the buffer-local value holds markers available +only in the current buffer.") + +(defconst evil-suppress-map (make-keymap) + "Full keymap disabling default bindings to `self-insert-command'.") +(suppress-keymap evil-suppress-map t) + +(defvar evil-read-key-map (make-sparse-keymap) + "Keymap active during `evil-read-key'. +This keymap can be used to bind some commands during the +execution of `evil-read-key' which is usually used to read a +character argument for some commands, e.g. `evil-replace'.") + +;; TODO: customize size of ring +(defvar evil-repeat-ring (make-ring 10) + "A ring of repeat-informations to repeat the last command.") + +(defvar evil-repeat-types + '((t . evil-repeat-keystrokes) + (change . evil-repeat-changes) + (motion . evil-repeat-motion) + (insert-at-point . evil-repeat-insert-at-point) + (ignore . nil)) + "An alist of defined repeat-types.") + +(defvar evil-recording-repeat nil + "Whether we are recording a repeat.") + +(defvar evil-recording-current-command nil + "Whether we are recording the current command for repeat.") + +(defvar evil-repeat-changes nil + "Accumulated buffer changes for changed-based commands.") + +(defvar evil-repeat-info nil + "Information accumulated during current repeat.") + +(defvar evil-repeat-buffer nil + "The buffer in which the repeat started. +If the buffer is changed, the repeat is cancelled.") + +(defvar evil-repeat-pos nil + "The position of point at the beginning of an change-tracking + editing command.") + +(defvar evil-repeat-keys nil + "The keys that invoked the current command.") + +(defvar evil-last-repeat nil + "Information about the latest repeat command. +This is a list of three elements (POINT COUNT UNDO-POINTER), +where POINT is the position of point before the latest repeat, +COUNT the count-argument of the latest repeat command and +UNDO-POINTER the head of the undo-list before the last command +has been repeated.") + +(defvar evil-repeat-count nil + "The explicit count when repeating a command.") + +(defvar evil-maybe-remove-spaces nil + "Flag to determine if newly inserted spaces should be removed. +See the function `evil-maybe-remove-spaces'.") + +(evil-define-local-var evil-insert-count nil + "The explicit count passed to an command starting Insert state.") + +(evil-define-local-var evil-insert-vcount nil + "The information about the number of following lines the +insertion should be repeated. This is list (LINE COLUMN COUNT) +where LINE is the line-number where the original insertion +started and COLUMN is either a number or function determining the +column where the repeated insertions should take place. COUNT is +number of repeats (including the original insertion).") + +(defvar evil-insert-skip-empty-lines nil + "Non-nil of the current insertion should not take place on + lines at which the insertion point is behind the end of the + line.") + +(evil-define-local-var evil-insert-lines nil + "Non-nil if the current insertion command is a line-insertion +command o or O.") + +(evil-define-local-var evil-insert-repeat-info nil + "Repeat information accumulated during an insertion.") + +(evil-define-local-var evil-replace-alist nil + "Association list of characters overwritten in Replace state. +The format is (POS . CHAR).") + +(evil-define-local-var evil-echo-area-message nil + "Previous value of `current-message'.") + +(defvar evil-write-echo-area nil + "If set to t inside `evil-save-echo-area', then the echo area +is not restored.") + +(defvar evil-last-find nil + "A pair (FUNCTION . CHAR) describing the lastest character + search command.") + +(defvar evil-last-paste nil + "Information about the latest paste. +This should be a list (CMD COUNT POINT BEG END FIRSTVISUAL) where +CMD is the last paste-command (`evil-paste-before', +`evil-paste-after' or `evil-visual-paste'), COUNT is the repeat +count of the paste, POINT is the position of point before the +paste, BEG end END are the region of the inserted +text. FIRSTVISUAL is t if and only if the previous command was +the first visual paste (i.e. before any paste-pop).") + +(evil-define-local-var evil-last-undo-entry nil + "Information about the latest undo entry in the buffer. +This should be a pair (OBJ . CONS) where OBJ is the entry as an +object, and CONS is a copy of the entry.") + +(evil-define-local-var evil-current-insertion nil + "Information about the latest insertion in insert state. +This should be a pair (BEG . END) that describes the +buffer-region of the newly inserted text.") + +(defvar evil-last-insertion nil + "The last piece of inserted text.") + +(defvar evil-last-small-deletion nil + "The last piece of deleted text. +The text should be less than a line.") + +(defvar evil-was-yanked-without-register t + "Whether text being saved to the numbered-register ring was +not deleted and not yanked to a specific register.") + +(defvar evil-paste-count nil + "The count argument of the current paste command.") + +(defvar evil-temporary-undo nil + "When undo is disabled in current buffer. +Certain commands depending on undo use this variable +instead of `buffer-undo-list'.") + +(evil-define-local-var evil-undo-list-pointer nil + "Everything up to this mark is united in the undo-list.") + +(defvar evil-in-single-undo nil + "Set to non-nil if the current undo steps are connected.") + +(defvar evil-flash-timer nil + "Timer for flashing search results.") + +(defvar evil-search-prompt nil + "String to use for search prompt.") + +(defvar evil-search-forward-history nil + "History of forward searches.") + +(defvar evil-search-backward-history nil + "History of backward searches.") + +(defvar evil-inner-text-objects-map (make-sparse-keymap) + "Keymap for inner text objects.") + +(defvar evil-outer-text-objects-map (make-sparse-keymap) + "Keymap for outer text objects.") + +(defvar evil-window-map (make-sparse-keymap) + "Keymap for window-related commands.") + +(evil-define-local-var evil-input-method nil + "Input method used in Insert state and Emacs state.") + +;;; Visual state + +(evil-define-local-var evil-visual-beginning nil + "The beginning of the Visual selection, a marker.") + +(evil-define-local-var evil-visual-end nil + "The end of the Visual selection, a marker.") + +(evil-define-local-var evil-visual-point nil + "The position of point in Visual state, a marker.") + +(evil-define-local-var evil-visual-mark nil + "The position of mark in Visual state, a marker.") + +(evil-define-local-var evil-visual-previous-mark nil + "The position of mark before Visual state, a marker.") + +(evil-define-local-var evil-visual-selection nil + "The kind of Visual selection. +This is a selection as defined by `evil-define-visual-selection'.") + +;; we could infer the direction by comparing `evil-visual-mark' +;; and `evil-visual-point', but destructive operations may +;; displace the markers +(evil-define-local-var evil-visual-direction 0 + "Whether point follows mark in Visual state. +Negative if point precedes mark, otherwise positive. +See also the function `evil-visual-direction'.") + +(evil-define-local-var evil-visual-properties nil + "Property list of miscellaneous Visual properties.") + +(evil-define-local-var evil-visual-region-expanded nil + "Whether the region matches the Visual selection. +That is, whether the positions of point and mark have been +expanded to coincide with the selection's boundaries. +This makes the selection available to functions acting +on Emacs' region.") + +(evil-define-local-var evil-visual-overlay nil + "Overlay for highlighting the Visual selection. +Not used for blockwise selections, in which case +see `evil-visual-block-overlays'.") + +(evil-define-local-var evil-visual-block-overlays nil + "Overlays for Visual Block selection, one for each line. +They are reused to minimize flicker.") + +(defvar evil-visual-alist nil + "Association list of Visual selection functions. +Elements have the form (NAME . FUNCTION).") + +(evil-define-local-var evil-visual-x-select-timer nil + "Timer for updating the X selection in visual state.") + +(defvar evil-visual-x-select-timeout 0.1 + "Time in seconds for the update of the X selection.") + +(declare-function origami-open-all-nodes "origami.el") +(declare-function origami-close-all-nodes "origami.el") +(declare-function origami-toggle-node "origami.el") +(declare-function origami-open-node "origami.el") +(declare-function origami-open-node-recursively "origami.el") +(declare-function origami-close-node "origami.el") + +(defvar evil-fold-list + `(((hs-minor-mode) + :open-all hs-show-all + :close-all hs-hide-all + :toggle hs-toggle-hiding + :open hs-show-block + :open-rec nil + :close hs-hide-block) + ((hide-ifdef-mode) + :open-all show-ifdefs + :close-all hide-ifdefs + :toggle nil + :open show-ifdef-block + :open-rec nil + :close hide-ifdef-block) + ((outline-mode + outline-minor-mode + org-mode + markdown-mode) + :open-all show-all + :close-all ,(lambda () + (with-no-warnings (hide-sublevels 1))) + :toggle outline-toggle-children + :open ,(lambda () + (with-no-warnings + (show-entry) + (show-children))) + :open-rec show-subtree + :close hide-subtree) + ((origami-mode) + :open-all ,(lambda () (origami-open-all-nodes (current-buffer))) + :close-all ,(lambda () (origami-close-all-nodes (current-buffer))) + :toggle ,(lambda () (origami-toggle-node (current-buffer) (point))) + :open ,(lambda () (origami-open-node (current-buffer) (point))) + :open-rec ,(lambda () (origami-open-node-recursively (current-buffer) (point))) + :close ,(lambda () (origami-close-node (current-buffer) (point)))) + ((vdiff-mode) + :open-all vdiff-open-all-folds + :close-all vdiff-close-all-folds + :toggle nil + :open ,(lambda () (call-interactively 'vdiff-open-fold)) + :open-rec ,(lambda () (call-interactively 'vdiff-open-fold)) + :close ,(lambda () (call-interactively 'vdiff-close-fold)))) + "Actions to be performed for various folding operations. + +The value should be a list of fold handlers, were a fold handler has +the format: + + ((MODES) PROPERTIES) + +MODES acts as a predicate, containing the symbols of all major or +minor modes for which the handler should match. For example: + + '((outline-minor-mode org-mode) ...) + +would match for either outline-minor-mode or org-mode, even though the +former is a minor mode and the latter is a major. + +PROPERTIES specifies possible folding actions and the functions to be +applied in the event of a match on one (or more) of the MODES; the +supported properties are: + + - `:open-all' + Open all folds. + - `:close-all' + Close all folds. + - `:toggle' + Toggle the display of the fold at point. + - `:open' + Open the fold at point. + - `:open-rec' + Open the fold at point recursively. + - `:close' + Close the fold at point. + +Each value must be a function. A value of `nil' will cause the action +to be ignored for that respective handler. For example: + + `((org-mode) + :close-all nil + :open ,(lambda () + (show-entry) + (show-children)) + :close hide-subtree) + +would ignore `:close-all' actions and invoke the provided functions on +`:open' or `:close'.") + +;;; Ex + +(defvar evil-ex-map (make-sparse-keymap) + "Keymap for Ex. +Key sequences bound in this map are immediately executed.") + +(defvar evil-ex-completion-map (make-sparse-keymap) + "Completion keymap for Ex.") + +(defvar evil-ex-initial-input nil + "Additional initial content of the ex command line. +This content of this variable is appended to the ex command line +if ex is started interactively.") + +(defvar evil-ex-shell-argument-initialized nil + "This variable is set to t if shell command completion has been initialized. +See `evil-ex-init-shell-argument-completion'.") + +(defvar evil-ex-commands nil + "Association list of command bindings and functions.") + +(defvar evil-ex-history nil + "History of Ex commands.") + +(defvar evil-ex-current-buffer nil + "The buffer from which Ex was started.") + +(defvar evil-ex-expression nil + "The evaluation tree.") + +(defvar evil-ex-tree nil + "The syntax tree.") + +(defvar evil-ex-command nil + "The current Ex command.") + +(defvar evil-ex-previous-command nil + "The previously executed Ex command.") + +(defvar evil-ex-cmd nil + "The current Ex command string.") + +(defvar evil-ex-point nil + "The position of `point' when the ex command has been called.") + +(defvar evil-ex-range nil + "The current range of the Ex command.") + +(defvar evil-ex-bang nil + "The \"!\" argument of the current Ex command.") + +(defvar evil-ex-argument nil + "The current argument of the Ex command.") + +(defvar evil-ex-argument-handler nil + "The argument handler for the current Ex command.") + +(defvar evil-ex-argument-types nil + "Association list of argument handlers.") + +(defvar evil-previous-shell-command nil + "The last shell command.") + +;; Searching +(defvar evil-ex-search-history nil + "The history for the search command.") + +(defvar evil-ex-search-direction nil + "The direction of the current search, either 'forward or 'backward.") + +(defvar evil-ex-search-count nil + "The count if the current search.") + +(defvar evil-ex-search-start-point nil + "The point where the search started.") + +(defvar evil-ex-search-overlay nil + "The overlay for the current search result.") + +(defvar evil-ex-search-pattern nil + "The last search pattern.") + +(defvar evil-ex-search-offset nil + "The last search offset.") + +(defvar evil-ex-search-match-beg nil + "The beginning position of the last match.") + +(defvar evil-ex-search-match-end nil + "The end position of the last match.") + +(defvar evil-ex-substitute-pattern nil + "The last substitute pattern.") + +(defvar evil-ex-substitute-replacement nil + "The last substitute replacement.") + +(defvar evil-ex-substitute-flags nil + "The last substitute flags.") + +(defvar evil-ex-substitute-current-replacement nil + "The actual replacement.") + +(defvar evil-ex-last-was-search nil + "Non-nil if the previous was a search. +Otherwise the previous command is assumed as substitute.") + +;;; Command line window + +(defvar evil-command-window-current-buffer nil + "The buffer from which the command line window was called.") + +(evil-define-local-var evil-command-window-execute-fn nil + "The command to execute when exiting the command line window.") + +(evil-define-local-var evil-command-window-cmd-key nil + "The key for the command that opened the command line window (:, /, or ?).") + +;; The lazy-highlighting framework. +(evil-define-local-var evil-ex-active-highlights-alist nil + "An alist of currently active highlights.") + +(evil-define-local-var evil-ex-hl-update-timer nil + "Time used for updating highlights.") + +(defvar evil-ex-search-keymap (make-sparse-keymap) + "Keymap used in ex-search-mode.") +(define-key evil-ex-search-keymap [escape] 'abort-recursive-edit) +(set-keymap-parent evil-ex-search-keymap minibuffer-local-map) + +(defconst evil-version + (eval-when-compile + (with-temp-buffer + (let ((dir (file-name-directory (or load-file-name + byte-compile-current-file)))) + ;; git repository + (if (and (file-exists-p (concat dir "/.git")) + (ignore-errors + (zerop (call-process "git" nil '(t nil) nil + "rev-parse" + "--short" "HEAD")))) + (progn + (goto-char (point-min)) + (concat "evil-git-" + (buffer-substring (point-min) + (line-end-position)))) + ;; no repo, use plain version + "1.2.13")))) + "The current version of Evil") + +(defcustom evil-want-integration t + "Whether to load evil-integration.el. +This variable must be set before evil is loaded." + :type 'boolean + :group 'evil) + +(defun evil-version () + (interactive) + (message "Evil version %s" evil-version)) + +(provide 'evil-vars) + +;;; evil-vars.el ends here |