mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-11-22 07:09:54 +00:00
Code Issues Releases Activity

Prefer defvar-local in remaining libraries

Browse Source 
* lisp/align.el (align-mode-rules-list)
(align-mode-exclude-rules-list):
* lisp/bookmark.el (bookmark-current-bookmark)
(bookmark-annotation-name)
(bookmark--annotation-from-bookmark-list):
* lisp/calc/calc-embed.el (calc-embedded-all-active)
(calc-embedded-some-active):
* lisp/comint.el (comint-password-function):
* lisp/completion.el (completion-syntax-table):
* lisp/dframe.el (dframe-track-mouse-function)
(dframe-help-echo-function, dframe-mouse-click-function)
(dframe-mouse-position-function, dframe-timer)
(dframe-attached-frame, dframe-controlled):
* lisp/ehelp.el (electric-help-orig-major-mode):
* lisp/eshell/esh-util.el (eshell-path-env):
* lisp/expand.el (expand-pos, expand-index, expand-point):
* lisp/face-remap.el (text-scale-mode-remapping)
(text-scale-mode-lighter, text-scale-mode-amount)
(text-scale-remap-header-line, buffer-face-mode-remapping):
* lisp/ffap.el (ffap-menu-alist):
* lisp/files-x.el (connection-local-variables-alist):
* lisp/foldout.el (foldout-fold-list, foldout-mode-line-string):
* lisp/follow.el (follow-start-end-invalid):
* lisp/forms.el (forms--mode-setup):
* lisp/gnus/message.el (message-cross-post-old-target)
(message-options):
* lisp/help-mode.el (help-xref-stack, help-xref-forward-stack)
(help-xref-stack-item, help-xref-stack-forward-item):
* lisp/hexl.el (hexl-mode--old-var-vals, hexl-ascii-overlay):
* lisp/hilit-chg.el (hilit-chg-string):
* lisp/ido.el (ido-eoinput):
* lisp/imenu.el (imenu-generic-expression)
(imenu-create-index-function, imenu-default-goto-function)
(imenu-prev-index-position-function)
(imenu-extract-index-name-function, imenu-name-lookup-function)
(imenu-syntax-alist, imenu-case-fold-search):
* lisp/jka-compr.el (jka-compr-really-do-compress):
* lisp/language/ethio-util.el (ethio-prefer-ascii-space):
* lisp/leim/quail/hangul.el (hangul-input-method-help-text):
* lisp/leim/quail/japanese.el (quail-japanese-package-saved):
* lisp/linum.el (linum-overlays, linum-available):
* lisp/man.el (Man-original-frame, Man-arguments, Man--sections)
(Man--refpages, Man-page-list, Man-current-page)
(Man-page-mode-string):
* lisp/pcomplete.el (pcomplete-current-completions)
(pcomplete-last-completion-length)
(pcomplete-last-completion-stub, pcomplete-last-completion-raw)
(pcomplete-last-window-config, pcomplete-window-restore-timer):
* lisp/reveal.el (reveal-open-spots, reveal-last-tick):
* lisp/ruler-mode.el (ruler-mode):
* lisp/scroll-lock.el (scroll-lock-preserve-screen-pos-save):
* lisp/server.el (server-buffer-clients, server-existing-buffer):
* lisp/tab-line.el (tab-line-exclude):
* lisp/tar-mode.el (tar-data-buffer, tar-data-swapped):
* lisp/thumbs.el (thumbs-current-tmp-filename)
(thumbs-current-image-filename, thumbs-extra-images)
(thumbs-image-num, thumbs-buffer, thumbs-marked-list):
* lisp/tutorial.el (tutorial--point-before-chkeys)
(tutorial--point-after-chkeys, tutorial--lang):
* lisp/url/url-vars.el (url-current-object)
(url-current-mime-headers, url-current-lastloc):
* lisp/view.el (view-mode, view-old-buffer-read-only)
(view-old-Helper-return-blurb, view-page-size)
(view-half-page-size, view-last-regexp, view-return-to-alist)
(view-exit-action, view-overlay):
* lisp/wid-edit.el (widget-global-map, widget-field-new)
(widget-field-list, widget-field-last, widget-field-was):
* lisp/woman.el (woman-imenu-done): Prefer defvar-local.
This commit is contained in:
Stefan Kangas 2021-02-02 09:55:40 +01:00
parent cfe8d9e0f7
commit e0fc879c0c
40 changed files with 114 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lisp/align.el
View File

@ -775,18 +775,14 @@ See the documentation for `align-rules-list' for more info."
;;; Internal Variables:
(defvar align-mode-rules-list nil
(defvar-local align-mode-rules-list nil
"Alignment rules specific to the current major mode.
See the variable `align-rules-list' for more details.")
(make-variable-buffer-local 'align-mode-rules-list)
(defvar align-mode-exclude-rules-list nil
(defvar-local align-mode-exclude-rules-list nil
"Alignment exclusion rules specific to the current major mode.
See the variable `align-exclude-rules-list' for more details.")
(make-variable-buffer-local 'align-mode-exclude-rules-list)
(defvar align-highlight-overlays nil
"The current overlays highlighting the text matched by a rule.")

10
lisp/bookmark.el
View File

@ -271,13 +271,11 @@ defaults to `bookmark-default-file' and MODTIME is its modification time.")
(defvar bookmark-file-coding-system nil
"The coding-system of the last loaded or saved bookmark file.")
(defvar bookmark-current-bookmark nil
(defvar-local bookmark-current-bookmark nil
"Name of bookmark most recently used in the current file.
It is buffer local, used to make moving a bookmark forward
through a file easier.")
(make-variable-buffer-local 'bookmark-current-bookmark)
(defvar bookmark-alist-modification-count 0
"Number of modifications to bookmark list since it was last saved.")
@ -903,13 +901,11 @@ Does not affect the kill ring."
(when (and newline-too (= (following-char) ?\n))
(delete-char 1))))
(defvar bookmark-annotation-name nil
(defvar-local bookmark-annotation-name nil
"Name of bookmark under edit in `bookmark-edit-annotation-mode'.")
(make-variable-buffer-local 'bookmark-annotation-name)
(defvar bookmark--annotation-from-bookmark-list nil
(defvar-local bookmark--annotation-from-bookmark-list nil
"If non-nil, `bookmark-edit-annotation-mode' should return to bookmark list.")
(make-variable-buffer-local 'bookmark--annotation-from-bookmark-list)
(defun bookmark-default-annotation-text (bookmark-name)
"Return default annotation text for BOOKMARK-NAME.

6
lisp/calc/calc-embed.el
View File

@ -46,10 +46,8 @@
(defvar calc-embedded-modes nil)
(defvar calc-embedded-globals nil)
(defvar calc-embedded-active nil)
(defvar calc-embedded-all-active nil)
(make-variable-buffer-local 'calc-embedded-all-active)
(defvar calc-embedded-some-active nil)
(make-variable-buffer-local 'calc-embedded-some-active)
(defvar-local calc-embedded-all-active nil)
(defvar-local calc-embedded-some-active nil)
;; The following variables are customizable and defined in calc.el.
(defvar calc-embedded-announce-formula)

3
lisp/comint.el
View File

@ -2375,12 +2375,11 @@ a buffer local variable."
;; saved -- typically passwords to ftp, telnet, or somesuch.
;; Just enter m-x comint-send-invisible and type in your line.
(defvar comint-password-function nil
(defvar-local comint-password-function nil
"Abnormal hook run when prompted for a password.
This function gets one argument, a string containing the prompt.
It may return a string containing the password, or nil if normal
password prompting should occur.")
(make-variable-buffer-local 'comint-password-function)
(defun comint-send-invisible (&optional prompt)
"Read a string without echoing.

3
lisp/completion.el
View File

@ -505,9 +505,8 @@ Used to decide whether to save completions.")
;; Old name, non-namespace-clean.
(defvaralias 'cmpl-syntax-table 'completion-syntax-table)
(defvar completion-syntax-table completion-standard-syntax-table
(defvar-local completion-syntax-table completion-standard-syntax-table
"This variable holds the current completion syntax table.")
(make-variable-buffer-local 'completion-syntax-table)
;;-----------------------------------------------
;; Symbol functions

21
lisp/dframe.el
View File

@ -146,42 +146,35 @@ selected frame and the focus will change to that frame."
:group 'dframe
:type 'hook)
(defvar dframe-track-mouse-function nil
(defvar-local dframe-track-mouse-function nil
"A function to call when the mouse is moved in the given frame.
Typically used to display info about the line under the mouse.")
(make-variable-buffer-local 'dframe-track-mouse-function)
(defvar dframe-help-echo-function nil
(defvar-local dframe-help-echo-function nil
"A function to call when help-echo is used in newer versions of Emacs.
Typically used to display info about the line under the mouse.")
(make-variable-buffer-local 'dframe-help-echo-function)
(defvar dframe-mouse-click-function nil
(defvar-local dframe-mouse-click-function nil
"A function to call when the mouse is clicked.
Valid clicks are mouse 2, our double mouse 1.")
(make-variable-buffer-local 'dframe-mouse-click-function)
(defvar dframe-mouse-position-function nil
(defvar-local dframe-mouse-position-function nil
"A function to call to position the cursor for a mouse click.")
(make-variable-buffer-local 'dframe-mouse-position-function)
(defvar dframe-power-click nil
"Never set this by hand. Value is t when S-mouse activity occurs.")
(defvar dframe-timer nil
(defvar-local dframe-timer nil
"The dframe timer used for updating the buffer.")
(make-variable-buffer-local 'dframe-timer)
(defvar dframe-attached-frame nil
(defvar-local dframe-attached-frame nil
"The frame which started a frame mode.
This is the frame from which all interesting activities will go
for the mode using dframe.")
(make-variable-buffer-local 'dframe-attached-frame)
(defvar dframe-controlled nil
(defvar-local dframe-controlled nil
"Is this buffer controlled by a dedicated frame.
Local to those buffers, as a function called that created it.")
(make-variable-buffer-local 'dframe-controlled)
(defun dframe-update-keymap (map)
"Update the keymap MAP for dframe default bindings."

3
lisp/ehelp.el
View File

@ -95,8 +95,7 @@
map)
"Keymap defining commands available in `electric-help-mode'.")
(defvar electric-help-orig-major-mode nil)
(make-variable-buffer-local 'electric-help-orig-major-mode)
(defvar-local electric-help-orig-major-mode nil)
(defun electric-help-mode ()
"`with-electric-help' temporarily places its buffer in this mode.

3
lisp/eshell/esh-util.el
View File

@ -235,11 +235,10 @@ If N or M is nil, it means the end of the list."
a (last a)))
a))
(defvar eshell-path-env (getenv "PATH")
(defvar-local eshell-path-env (getenv "PATH")
"Content of $PATH.
It might be different from \(getenv \"PATH\"), when
`default-directory' points to a remote host.")
(make-variable-buffer-local 'eshell-path-env)
(defun eshell-get-path ()
"Return $PATH as a list.

9
lisp/expand.el
View File

@ -289,17 +289,14 @@ If ARG is omitted, point is placed at the end of the expanded text."
(defvar expand-list nil "Temporary variable used by the Expand package.")
(defvar expand-pos nil
(defvar-local expand-pos nil
"If non-nil, store a vector with position markers defined by the last expansion.")
(make-variable-buffer-local 'expand-pos)
(defvar expand-index 0
(defvar-local expand-index 0
"Index of the last marker used in `expand-pos'.")
(make-variable-buffer-local 'expand-index)
(defvar expand-point nil
(defvar-local expand-point nil
"End of the expanded region.")
(make-variable-buffer-local 'expand-point)
(defun expand-add-abbrev (table abbrev expansion arg)
"Add one abbreviation and provide the hook to move to the specified positions."

21
lisp/face-remap.el
View File

@ -217,21 +217,17 @@ Each positive or negative step scales the default face height by this amount."
:type 'number
:version "23.1")
;; current remapping cookie for text-scale-mode
(defvar text-scale-mode-remapping nil)
(make-variable-buffer-local 'text-scale-mode-remapping)
(defvar-local text-scale-mode-remapping nil
"Current remapping cookie for text-scale-mode.")
;; Lighter displayed for text-scale-mode in mode-line minor-mode list
(defvar text-scale-mode-lighter "+0")
(make-variable-buffer-local 'text-scale-mode-lighter)
(defvar-local text-scale-mode-lighter "+0"
"Lighter displayed for text-scale-mode in mode-line minor-mode list.")
;; Number of steps that text-scale-mode will increase/decrease text height
(defvar text-scale-mode-amount 0)
(make-variable-buffer-local 'text-scale-mode-amount)
(defvar-local text-scale-mode-amount 0
"Number of steps that text-scale-mode will increase/decrease text height.")
(defvar text-scale-remap-header-line nil
(defvar-local text-scale-remap-header-line nil
"If non-nil, text scaling may change font size of header lines too.")
(make-variable-buffer-local 'text-scale-header-line)
(defun face-remap--clear-remappings ()
(dolist (remapping
@ -413,8 +409,7 @@ plist, etc."
:version "23.1")
;; current remapping cookie for buffer-face-mode
(defvar buffer-face-mode-remapping nil)
(make-variable-buffer-local 'buffer-face-mode-remapping)
(defvar-local buffer-face-mode-remapping nil)
;;;###autoload
(define-minor-mode buffer-face-mode

3
lisp/ffap.el
View File

@ -1675,9 +1675,8 @@ For example, try \":/\" for URL (and some FTP) references."
:type '(choice (const nil) regexp)
:group 'ffap)
(defvar ffap-menu-alist nil
(defvar-local ffap-menu-alist nil
"Buffer local cache of menu presented by `ffap-menu'.")
(make-variable-buffer-local 'ffap-menu-alist)
(defvar ffap-menu-text-plist
(cond

3
lisp/files-x.el
View File

@ -570,13 +570,12 @@ from the MODE alist ignoring the input argument VALUE."
(defvar enable-connection-local-variables t
"Non-nil means enable use of connection-local variables.")
(defvar connection-local-variables-alist nil
(defvar-local connection-local-variables-alist nil
"Alist of connection-local variable settings in the current buffer.
Each element in this list has the form (VAR . VALUE), where VAR
is a connection-local variable (a symbol) and VALUE is its value.
The actual value in the buffer may differ from VALUE, if it is
changed by the user.")
(make-variable-buffer-local 'connection-local-variables-alist)
(setq ignored-local-variables
(cons 'connection-local-variables-alist ignored-local-variables))

6
lisp/foldout.el
View File

@ -209,14 +209,12 @@
(require 'outline)
(defvar foldout-fold-list nil
(defvar-local foldout-fold-list nil
"List of start and end markers for the folds currently entered.
An end marker of nil means the fold ends after (point-max).")
(make-variable-buffer-local 'foldout-fold-list)
(defvar foldout-mode-line-string nil
(defvar-local foldout-mode-line-string nil
"Mode line string announcing that we are in an outline fold.")
(make-variable-buffer-local 'foldout-mode-line-string)
;; put our minor mode string immediately following outline-minor-mode's
(or (assq 'foldout-mode-line-string minor-mode-alist)

3
lisp/follow.el
View File

@ -1140,9 +1140,8 @@ Otherwise, return nil."
;; is nil. Start every window directly after the end of the previous
;; window, to make sure long lines are displayed correctly.
(defvar follow-start-end-invalid t
(defvar-local follow-start-end-invalid t
"When non-nil, indicates `follow-windows-start-end-cache' is invalid.")
(make-variable-buffer-local 'follow-start-end-invalid)
(defun follow-redisplay (&optional windows win preserve-win)
"Reposition the WINDOWS around WIN.

3
lisp/forms.el
View File

@ -418,9 +418,8 @@ Also, initial position is at last record."
(defvar forms--parser nil
"Forms parser routine.")
(defvar forms--mode-setup nil
(defvar-local forms--mode-setup nil
"To keep track of forms-mode being set-up.")
(make-variable-buffer-local 'forms--mode-setup)
(defvar forms--dynamic-text nil
"Array that holds dynamic texts to insert between fields.")

6
lisp/gnus/message.el
View File

@ -394,9 +394,8 @@ If nil, don't insert any text in the body."
;; inspired by JoH-followup-to by Jochem Huhman <joh at gmx.de>
;; new suggestions by R. Weikusat <rw at another.de>
(defvar message-cross-post-old-target nil
(defvar-local message-cross-post-old-target nil
"Old target for cross-posts or follow-ups.")
(make-variable-buffer-local 'message-cross-post-old-target)
(defcustom message-cross-post-default t
"When non-nil `message-cross-post-followup-to' will perform a crosspost.
@ -2004,9 +2003,8 @@ You must have the \"hashcash\" binary installed, see `hashcash-path'."
(User-Agent))
"Alist used for formatting headers.")
(defvar message-options nil
(defvar-local message-options nil
"Some saved answers when sending message.")
(make-variable-buffer-local 'message-options)
(defvar message-send-mail-real-function nil
"Internal send mail function.")

12
lisp/help-mode.el
View File

@ -62,33 +62,29 @@
["Move to Next Button" forward-button
:help "Move to the Next Button in the help buffer"]))
(defvar help-xref-stack nil
(defvar-local help-xref-stack nil
"A stack of ways by which to return to help buffers after following xrefs.
Used by `help-follow' and `help-xref-go-back'.
An element looks like (POSITION FUNCTION ARGS...).
To use the element, do (apply FUNCTION ARGS) then goto the point.")
(put 'help-xref-stack 'permanent-local t)
(make-variable-buffer-local 'help-xref-stack)
(defvar help-xref-forward-stack nil
(defvar-local help-xref-forward-stack nil
"A stack used to navigate help forwards after using the back button.
Used by `help-follow' and `help-xref-go-forward'.
An element looks like (POSITION FUNCTION ARGS...).
To use the element, do (apply FUNCTION ARGS) then goto the point.")
(put 'help-xref-forward-stack 'permanent-local t)
(make-variable-buffer-local 'help-xref-forward-stack)
(defvar help-xref-stack-item nil
(defvar-local help-xref-stack-item nil
"An item for `help-follow' in this buffer to push onto `help-xref-stack'.
The format is (FUNCTION ARGS...).")
(put 'help-xref-stack-item 'permanent-local t)
(make-variable-buffer-local 'help-xref-stack-item)
(defvar help-xref-stack-forward-item nil
(defvar-local help-xref-stack-forward-item nil
"An item for `help-go-back' to push onto `help-xref-forward-stack'.
The format is (FUNCTION ARGS...).")
(put 'help-xref-stack-forward-item 'permanent-local t)
(make-variable-buffer-local 'help-xref-stack-forward-item)
(setq-default help-xref-stack nil help-xref-stack-item nil)
(setq-default help-xref-forward-stack nil help-xref-forward-stack-item nil)

6
lisp/hexl.el
View File

@ -209,12 +209,10 @@ as that will override any bit grouping options set here."
(defvar hl-line-face)
;; Variables where the original values are stored to.
(defvar hexl-mode--old-var-vals ())
(make-variable-buffer-local 'hexl-mode--old-var-vals)
(defvar-local hexl-mode--old-var-vals ())
(defvar hexl-ascii-overlay nil
(defvar-local hexl-ascii-overlay nil
"Overlay used to highlight ASCII element corresponding to current point.")
(make-variable-buffer-local 'hexl-ascii-overlay)
(defvar hexl-font-lock-keywords
'(("^\\([0-9a-f]+:\\)\\( \\).\\{39\\}\\( \\)\\(.+$\\)"

4
lisp/hilit-chg.el
View File

@ -296,9 +296,7 @@ remove it from existing buffers."
;; These are for internal use.
(defvar hilit-chg-list nil)
(defvar hilit-chg-string " ??")
(make-variable-buffer-local 'hilit-chg-string)
(defvar-local hilit-chg-string " ??")

3
lisp/ido.el
View File

@ -1037,10 +1037,9 @@ Should never be set permanently.")
(defvar ido-completion-map nil
"Currently active keymap for Ido commands.")
(defvar ido-eoinput 1
(defvar-local ido-eoinput 1
"Point where minibuffer input ends and completion info begins.
Copied from `icomplete-eoinput'.")
(make-variable-buffer-local 'ido-eoinput)
(defvar ido-common-match-string nil
"Stores the string that is common to all matching files.")

35
lisp/imenu.el
View File

@ -187,7 +187,7 @@ uses `imenu--generic-function')."
:version "24.4")
;;;###autoload
(defvar imenu-generic-expression nil
(defvar-local imenu-generic-expression nil
"List of definition matchers for creating an Imenu index.
Each element of this list should have the form
@ -223,13 +223,10 @@ characters which normally have \"symbol\" syntax are considered to have
\"word\" syntax during matching.")
;;;###autoload(put 'imenu-generic-expression 'risky-local-variable t)
;;;###autoload
(make-variable-buffer-local 'imenu-generic-expression)
;;;; Hooks
;;;###autoload
(defvar imenu-create-index-function 'imenu-default-create-index-function
(defvar-local imenu-create-index-function 'imenu-default-create-index-function
"The function to use for creating an index alist of the current buffer.
It should be a function that takes no arguments and returns
@ -237,11 +234,9 @@ an index alist of the current buffer. The function is
called within a `save-excursion'.
See `imenu--index-alist' for the format of the buffer index alist.")
;;;###autoload
(make-variable-buffer-local 'imenu-create-index-function)
;;;###autoload
(defvar imenu-prev-index-position-function 'beginning-of-defun
(defvar-local imenu-prev-index-position-function 'beginning-of-defun
"Function for finding the next index position.
If `imenu-create-index-function' is set to
@ -251,21 +246,17 @@ file.
The function should leave point at the place to be connected to the
index and it should return nil when it doesn't find another index.")
;;;###autoload
(make-variable-buffer-local 'imenu-prev-index-position-function)
;;;###autoload
(defvar imenu-extract-index-name-function nil
(defvar-local imenu-extract-index-name-function nil
"Function for extracting the index item name, given a position.
This function is called after `imenu-prev-index-position-function'
finds a position for an index item, with point at that position.
It should return the name for that index item.")
;;;###autoload
(make-variable-buffer-local 'imenu-extract-index-name-function)
;;;###autoload
(defvar imenu-name-lookup-function nil
(defvar-local imenu-name-lookup-function nil
"Function to compare string with index item.
This function will be called with two strings, and should return
@ -275,15 +266,11 @@ If nil, comparison is done with `string='.
Set this to some other function for more advanced comparisons,
such as \"begins with\" or \"name matches and number of
arguments match\".")
;;;###autoload
(make-variable-buffer-local 'imenu-name-lookup-function)
;;;###autoload
(defvar imenu-default-goto-function 'imenu-default-goto-function
(defvar-local imenu-default-goto-function 'imenu-default-goto-function
"The default function called when selecting an Imenu item.
The function in this variable is called when selecting a normal index-item.")
;;;###autoload
(make-variable-buffer-local 'imenu-default-goto-function)
(defun imenu--subalist-p (item)
@ -554,7 +541,8 @@ Non-nil arguments are in recursive calls."
(setq alist nil res elt))))
res))
(defvar imenu-syntax-alist nil
;;;###autoload
(defvar-local imenu-syntax-alist nil
"Alist of syntax table modifiers to use while in `imenu--generic-function'.
The car of the assocs may be either a character or a string and the
@ -564,8 +552,6 @@ a string, all the characters in the string get the specified syntax.
This is typically used to give word syntax to characters which
normally have symbol syntax to simplify `imenu-expression'
and speed-up matching.")
;;;###autoload
(make-variable-buffer-local 'imenu-syntax-alist)
(defun imenu-default-create-index-function ()
"Default function to create an index alist of the current buffer.
@ -607,14 +593,13 @@ The alternate method, which is the one most often used, is to call
;;; Generic index gathering function.
;;;
(defvar imenu-case-fold-search t
;;;###autoload
(defvar-local imenu-case-fold-search t
"Defines whether `imenu--generic-function' should fold case when matching.
This variable should be set (only) by initialization code
for modes which use `imenu--generic-function'. If it is not set, but
`font-lock-defaults' is set, then font-lock's setting is used.")
;;;###autoload
(make-variable-buffer-local 'imenu-case-fold-search)
;; This function can be called with quitting disabled,
;; so it needs to be careful never to loop!

3
lisp/jka-compr.el
View File

@ -101,11 +101,10 @@ NOTE: Not used in MS-DOS and Windows systems."
(defvar jka-compr-use-shell
(not (memq system-type '(ms-dos windows-nt))))
(defvar jka-compr-really-do-compress nil
(defvar-local jka-compr-really-do-compress nil
"Non-nil in a buffer whose visited file was uncompressed on visiting it.
This means compress the data on writing the file, even if the
data appears to be compressed already.")
(make-variable-buffer-local 'jka-compr-really-do-compress)
(put 'jka-compr-really-do-compress 'permanent-local t)

3
lisp/language/ethio-util.el
View File

@ -972,8 +972,7 @@ Otherwise, [0-9A-F]."
;; Ethiopic word separator vs. ASCII space
;;
(defvar ethio-prefer-ascii-space t)
(make-variable-buffer-local 'ethio-prefer-ascii-space)
(defvar-local ethio-prefer-ascii-space t)
(defun ethio-toggle-space nil
"Toggle ASCII space and Ethiopic separator for keyboard input."

3
lisp/leim/quail/hangul.el
View File

@ -511,8 +511,7 @@ When a Korean input method is off, convert the following hangul character."
;; Text shown by describe-input-method. Set to a proper text by
;; hangul-input-method-activate.
(defvar hangul-input-method-help-text nil)
(make-variable-buffer-local 'hangul-input-method-help-text)
(defvar-local hangul-input-method-help-text nil)
;;;###autoload
(defun hangul-input-method-activate (input-method func help-text &rest args)

3
lisp/leim/quail/japanese.el
View File

@ -113,8 +113,7 @@
(?h . "japanese")
(?q . ("japanese-ascii"))))
(defvar quail-japanese-package-saved nil)
(make-variable-buffer-local 'quail-japanese-package-saved)
(defvar-local quail-japanese-package-saved nil)
(put 'quail-japanese-package-saved 'permanent-local t)
(defun quail-japanese-switch-package (key idx)

6
lisp/linum.el
View File

@ -34,13 +34,11 @@
(defconst linum-version "0.9x")
(make-obsolete-variable 'linum-version nil "28.1")
(defvar linum-overlays nil "Overlays used in this buffer.")
(defvar linum-available nil "Overlays available for reuse.")
(defvar-local linum-overlays nil "Overlays used in this buffer.")
(defvar-local linum-available nil "Overlays available for reuse.")
(defvar linum-before-numbering-hook nil
"Functions run in each buffer before line numbering starts.")
(mapc #'make-variable-buffer-local '(linum-overlays linum-available))
(defgroup linum nil
"Show line numbers in the left margin."
:group 'convenience)

21
lisp/man.el
View File

@ -399,22 +399,15 @@ Otherwise, the value is whatever the function
;; other variables and keymap initializations
(defvar Man-original-frame)
(make-variable-buffer-local 'Man-original-frame)
(defvar Man-arguments)
(make-variable-buffer-local 'Man-arguments)
(defvar-local Man-original-frame nil)
(defvar-local Man-arguments nil)
(put 'Man-arguments 'permanent-local t)
(defvar Man--sections nil)
(make-variable-buffer-local 'Man--sections)
(defvar Man--refpages nil)
(make-variable-buffer-local 'Man--refpages)
(defvar Man-page-list nil)
(make-variable-buffer-local 'Man-page-list)
(defvar Man-current-page 0)
(make-variable-buffer-local 'Man-current-page)
(defvar Man-page-mode-string "1 of 1")
(make-variable-buffer-local 'Man-page-mode-string)
(defvar-local Man--sections nil)
(defvar-local Man--refpages nil)
(defvar-local Man-page-list nil)
(defvar-local Man-current-page 0)
(defvar-local Man-page-mode-string "1 of 1")
(defconst Man-sysv-sed-script "\
/\b/ { s/_\b//g

19
lisp/pcomplete.el
View File

@ -330,19 +330,12 @@ modified to be an empty string, or the desired separation string."
;;; Internal Variables:
;; for cycling completion support
(defvar pcomplete-current-completions nil)
(defvar pcomplete-last-completion-length)
(defvar pcomplete-last-completion-stub)
(defvar pcomplete-last-completion-raw)
(defvar pcomplete-last-window-config nil)
(defvar pcomplete-window-restore-timer nil)
(make-variable-buffer-local 'pcomplete-current-completions)
(make-variable-buffer-local 'pcomplete-last-completion-length)
(make-variable-buffer-local 'pcomplete-last-completion-stub)
(make-variable-buffer-local 'pcomplete-last-completion-raw)
(make-variable-buffer-local 'pcomplete-last-window-config)
(make-variable-buffer-local 'pcomplete-window-restore-timer)
(defvar-local pcomplete-current-completions nil)
(defvar-local pcomplete-last-completion-length nil)
(defvar-local pcomplete-last-completion-stub nil)
(defvar-local pcomplete-last-completion-raw nil)
(defvar-local pcomplete-last-window-config nil)
(defvar-local pcomplete-window-restore-timer nil)
;; used for altering pcomplete's behavior. These global variables
;; should always be nil.

6
lisp/reveal.el
View File

@ -67,13 +67,11 @@ revealed text manually."
:type 'boolean
:version "28.1")
(defvar reveal-open-spots nil
(defvar-local reveal-open-spots nil
"List of spots in the buffer which are open.
Each element has the form (WINDOW . OVERLAY).")
(make-variable-buffer-local 'reveal-open-spots)
(defvar reveal-last-tick nil)
(make-variable-buffer-local 'reveal-last-tick)
(defvar-local reveal-last-tick nil)
;; Actual code

3
lisp/ruler-mode.el
View File

@ -572,10 +572,9 @@ This variable is expected to be made buffer-local by modes.")
Call `ruler-mode-ruler-function' to compute the ruler value.")
;;;###autoload
(defvar ruler-mode nil
(defvar-local ruler-mode nil
"Non-nil if Ruler mode is enabled.
Use the command `ruler-mode' to change this variable.")
(make-variable-buffer-local 'ruler-mode)
(defun ruler--save-header-line-format ()
"Install the header line format for Ruler mode.

3
lisp/scroll-lock.el
View File

@ -40,9 +40,8 @@
map)
"Keymap for Scroll Lock mode.")
(defvar scroll-lock-preserve-screen-pos-save scroll-preserve-screen-position
(defvar-local scroll-lock-preserve-screen-pos-save scroll-preserve-screen-position
"Used for saving the state of `scroll-preserve-screen-position'.")
(make-variable-buffer-local 'scroll-lock-preserve-screen-pos-save)
(defvar scroll-lock-temporary-goal-column 0
"Like `temporary-goal-column' but for scroll-lock-* commands.")

6
lisp/server.el
View File

@ -197,9 +197,8 @@ The created frame is selected when the hook is called."
"List of current server clients.
Each element is a process.")
(defvar server-buffer-clients nil
(defvar-local server-buffer-clients nil
"List of client processes requesting editing of current buffer.")
(make-variable-buffer-local 'server-buffer-clients)
;; Changing major modes should not erase this local.
(put 'server-buffer-clients 'permanent-local t)
@ -239,11 +238,10 @@ in this way."
:type 'boolean
:version "21.1")
(defvar server-existing-buffer nil
(defvar-local server-existing-buffer nil
"Non-nil means the buffer existed before the server was asked to visit it.
This means that the server should not kill the buffer when you say you
are done with it in the server.")
(make-variable-buffer-local 'server-existing-buffer)
(defvar server--external-socket-initialized nil
"When an external socket is passed into Emacs, we need to call

4
lisp/tab-line.el
View File

@ -810,9 +810,7 @@ from the tab line."
:version "27.1")
;;;###autoload
(defvar tab-line-exclude nil)
;;;###autoload
(make-variable-buffer-local 'tab-line-exclude)
(defvar-local tab-line-exclude nil)
(defun tab-line-mode--turn-on ()
"Turn on `tab-line-mode'."

7
lisp/tar-mode.el
View File

@ -149,12 +149,11 @@ This information is useful, but it takes screen space away from file names."
;; So instead, we now keep the two pieces of data in separate buffers, and
;; use the new buffer-swap-text primitive when we need to change which data
;; is associated with "the" buffer.
(defvar tar-data-buffer nil "Buffer that holds the actual raw tar bytes.")
(make-variable-buffer-local 'tar-data-buffer)
(defvar-local tar-data-buffer nil
"Buffer that holds the actual raw tar bytes.")
(defvar tar-data-swapped nil
(defvar-local tar-data-swapped nil
"If non-nil, `tar-data-buffer' indeed holds raw tar bytes.")
(make-variable-buffer-local 'tar-data-swapped)
(defun tar-data-swapped-p ()
"Return non-nil if the tar-data is in `tar-data-buffer'."

18
lisp/thumbs.el
View File

@ -148,36 +148,30 @@ this value can let another user see some of your images."
:group 'thumbs)
;; Initialize some variable, for later use.
(defvar thumbs-current-tmp-filename nil
(defvar-local thumbs-current-tmp-filename nil
"Temporary filename of current image.")
(make-variable-buffer-local 'thumbs-current-tmp-filename)
(defvar thumbs-current-image-filename nil
(defvar-local thumbs-current-image-filename nil
"Filename of current image.")
(make-variable-buffer-local 'thumbs-current-image-filename)
(defvar thumbs-extra-images 1
(defvar-local thumbs-extra-images 1
"Counter for showing extra images in thumbs buffer.")
(make-variable-buffer-local 'thumbs-extra-images)
(put 'thumbs-extra-images 'permanent-local t)
(defvar thumbs-current-image-size nil
"Size of current image.")
(defvar thumbs-image-num nil
(defvar-local thumbs-image-num nil
"Number of current image.")
(make-variable-buffer-local 'thumbs-image-num)
(defvar thumbs-buffer nil
(defvar-local thumbs-buffer nil
"Name of buffer containing thumbnails associated with image.")
(make-variable-buffer-local 'thumbs-buffer)
(defvar thumbs-current-dir nil
"Current directory.")
(defvar thumbs-marked-list nil
(defvar-local thumbs-marked-list nil
"List of marked files.")
(make-variable-buffer-local 'thumbs-marked-list)
(put 'thumbs-marked-list 'permanent-local t)
(defsubst thumbs-temp-dir ()

9
lisp/tutorial.el
View File

@ -38,17 +38,14 @@
"Face used to highlight warnings in the tutorial."
:group 'help)
(defvar tutorial--point-before-chkeys 0
(defvar-local tutorial--point-before-chkeys 0
"Point before display of key changes.")
(make-variable-buffer-local 'tutorial--point-before-chkeys)
(defvar tutorial--point-after-chkeys 0
(defvar-local tutorial--point-after-chkeys 0
"Point after display of key changes.")
(make-variable-buffer-local 'tutorial--point-after-chkeys)
(defvar tutorial--lang nil
(defvar-local tutorial--lang nil
"Tutorial language.")
(make-variable-buffer-local 'tutorial--lang)
(defvar tutorial--buffer nil
"The selected tutorial buffer.")

13
lisp/url/url-vars.el
View File

@ -55,26 +55,19 @@
:group 'url)
(defvar url-current-object nil
(defvar-local url-current-object nil
"A parsed representation of the current URL.")
(defvar url-current-mime-headers nil
(defvar-local url-current-mime-headers nil
"A parsed representation of the MIME headers for the current URL.")
(defvar url-current-lastloc nil
(defvar-local url-current-lastloc nil
"A parsed representation of the URL to be considered as the last location.
Use of this value on outbound connections is subject to
`url-privacy-level' and `url-lastloc-privacy-level'. This is never set
by the url library, applications are expected to set this
variable in buffers representing a displayed location.")
(mapc 'make-variable-buffer-local
'(
url-current-object
url-current-mime-headers
url-current-lastloc
))
(defcustom url-honor-refresh-requests t
"Whether to do automatic page reloads.
These are done at the request of the document author or the server via

30
lisp/view.el
View File

@ -96,38 +96,31 @@ interactive command; otherwise the help message is not shown."
:version "22.1")
;;;###autoload
(defvar view-mode nil
(defvar-local view-mode nil
"Non-nil if View mode is enabled.
Don't change this variable directly, you must change it by one of the
functions that enable or disable view mode.")
;;;###autoload
(make-variable-buffer-local 'view-mode)
(defcustom view-mode-hook nil
"Normal hook run when starting to view a buffer or file."
:type 'hook
:group 'view)
(defvar view-old-buffer-read-only nil)
(make-variable-buffer-local 'view-old-buffer-read-only)
(defvar-local view-old-buffer-read-only nil)
(defvar view-old-Helper-return-blurb)
(make-variable-buffer-local 'view-old-Helper-return-blurb)
(defvar-local view-old-Helper-return-blurb nil)
(defvar view-page-size nil
(defvar-local view-page-size nil
"Default number of lines to scroll by View page commands.
If nil that means use the window size.")
(make-variable-buffer-local 'view-page-size)
(defvar view-half-page-size nil
(defvar-local view-half-page-size nil
"Default number of lines to scroll by View half page commands.
If nil that means use half the window size.")
(make-variable-buffer-local 'view-half-page-size)
(defvar view-last-regexp nil)
(make-variable-buffer-local 'view-last-regexp) ; Global is better???
(defvar-local view-last-regexp nil) ; Global is better???
(defvar view-return-to-alist nil
(defvar-local view-return-to-alist nil
"What to do with used windows and where to go when finished viewing buffer.
This is local in each buffer being viewed.
It is added to by `view-mode-enter' when starting to view a buffer and
@ -136,18 +129,16 @@ subtracted from by `view-mode-exit' when finished viewing the buffer.
See RETURN-TO-ALIST argument of function `view-mode-exit' for the format of
`view-return-to-alist'.")
(make-obsolete-variable
'view-return-to-alist "this variable is no more used." "24.1")
(make-variable-buffer-local 'view-return-to-alist)
'view-return-to-alist "this variable is no longer used." "24.1")
(put 'view-return-to-alist 'permanent-local t)
(defvar view-exit-action nil
(defvar-local view-exit-action nil
"If non-nil, a function called when finished viewing.
The function should take one argument (a buffer).
Commands like \\[view-file] and \\[view-file-other-window] may
set this to bury or kill the viewed buffer.
Observe that the buffer viewed might not appear in any window at
the time this function is called.")
(make-variable-buffer-local 'view-exit-action)
(defvar view-no-disable-on-exit nil
"If non-nil, View mode \"exit\" commands don't actually disable View mode.
@ -155,10 +146,9 @@ Instead, these commands just switch buffers or windows.
This is set in certain buffers by specialized features such as help commands
that use View mode automatically.")
(defvar view-overlay nil
(defvar-local view-overlay nil
"Overlay used to display where a search operation found its match.
This is local in each buffer, once it is used.")
(make-variable-buffer-local 'view-overlay)
;; Define keymap inside defvar to make it easier to load changes.
;; Some redundant "less"-like key bindings below have been commented out.

19
lisp/wid-edit.el
View File

@ -1019,9 +1019,8 @@ button end points."
Recommended as a parent keymap for modes using widgets.
Note that such modes will need to require wid-edit.")
(defvar widget-global-map global-map
(defvar-local widget-global-map global-map
"Keymap used for events a widget does not handle itself.")
(make-variable-buffer-local 'widget-global-map)
(defvar widget-field-keymap
(let ((map (copy-keymap widget-keymap)))
@ -1326,13 +1325,11 @@ When not inside a field, signal an error."
;;; Setting up the buffer.
(defvar widget-field-new nil
(defvar-local widget-field-new nil
"List of all newly created editable fields in the buffer.")
(make-variable-buffer-local 'widget-field-new)
(defvar widget-field-list nil
(defvar-local widget-field-list nil
"List of all editable fields in the buffer.")
(make-variable-buffer-local 'widget-field-list)
(defun widget-at (&optional pos)
"The button or field at POS (default, point)."
@ -1359,13 +1356,11 @@ When not inside a field, signal an error."
(widget-clear-undo)
(widget-add-change))
(defvar widget-field-last nil)
;; Last field containing point.
(make-variable-buffer-local 'widget-field-last)
(defvar-local widget-field-last nil
"Last field containing point.")
(defvar widget-field-was nil)
;; The widget data before the change.
(make-variable-buffer-local 'widget-field-was)
(defvar-local widget-field-was nil
"The widget data before the change.")
(defun widget-field-at (pos)
"Return the widget field at POS, or nil if none."

3
lisp/woman.el
View File

@ -1078,9 +1078,8 @@ Set by `.ns' request; reset by any output or `.rs' request")
;; Could end with "\\( +\\|$\\)" instead of " *"
"Regexp to match a ?roff request plus trailing white space.")
(defvar woman-imenu-done nil
(defvar-local woman-imenu-done nil
"Buffer-local: set to true if function `woman-imenu' has been called.")
(make-variable-buffer-local 'woman-imenu-done)
;; From imenu.el -- needed when reformatting a file in its old buffer.
;; The latest buffer index used to update the menu bar menu.