;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
(autoload 'widget-convert "wid-edit")
(autoload 'shell-mode "shell"))
+(defcustom idle-update-delay 0.5
+ "*Idle time delay before updating various things on the screen.
+Various Emacs features that update auxiliary information when point moves
+wait this many seconds after Emacs becomes idle before doing an update."
+ :type 'number
+ :group 'display
+ :version "22.1")
(defgroup killing nil
"Killing and yanking commands."
"Highlight (un)matching of parens and expressions."
:group 'matching)
-(define-key global-map [?\C-x right] 'next-buffer)
-(define-key global-map [?\C-x left] 'prev-buffer)
(defun next-buffer ()
"Switch to the next buffer in cyclic order."
(interactive)
:group 'next-error
:version "22.1")
+(defcustom next-error-hook nil
+ "*List of hook functions run by `next-error' after visiting source file."
+ :type 'hook
+ :group 'next-error)
+
+(defvar next-error-highlight-timer nil)
+
+(defvar next-error-overlay-arrow-position nil)
+(put 'next-error-overlay-arrow-position 'overlay-arrow-string "=>")
+(add-to-list 'overlay-arrow-variable-list 'next-error-overlay-arrow-position)
+
(defvar next-error-last-buffer nil
"The most recent next-error buffer.
A buffer becomes most recent when its compilation, grep, or
in question is treated as usable.
The function EXTRA-TEST-EXCLUSIVE, if non-nil is called in each buffer
-that would normally be considered usable. if it returns nil,
+that would normally be considered usable. If it returns nil,
that buffer is rejected."
(and (buffer-name buffer) ;First make sure it's live.
(not (and avoid-current (eq buffer (current-buffer))))
If AVOID-CURRENT is non-nil, treat the current buffer
as an absolute last resort only.
-The function EXTRA-TEST-INCLUSIVE, if non-nil, is called in each buffers
+The function EXTRA-TEST-INCLUSIVE, if non-nil, is called in each buffer
that normally would not qualify. If it returns t, the buffer
in question is treated as usable.
\\[next-error] in that buffer when it is the only one displayed
in the current frame.
-Once \\[next-error] has chosen the buffer for error messages,
-it stays with that buffer until you use it in some other buffer which
-uses Compilation mode or Compilation Minor mode.
+Once \\[next-error] has chosen the buffer for error messages, it
+runs `next-error-hook' with `run-hooks', and stays with that buffer
+until you use it in some other buffer which uses Compilation mode
+or Compilation Minor mode.
See variables `compilation-parse-errors-function' and
\`compilation-error-regexp-alist' for customization ideas."
(when (setq next-error-last-buffer (next-error-find-buffer))
;; we know here that next-error-function is a valid symbol we can funcall
(with-current-buffer next-error-last-buffer
- (funcall next-error-function (prefix-numeric-value arg) reset))))
+ (funcall next-error-function (prefix-numeric-value arg) reset)
+ (run-hooks 'next-error-hook))))
(defalias 'goto-next-locus 'next-error)
(defalias 'next-match 'next-error)
-(define-key ctl-x-map "`" 'next-error)
-
(defun previous-error (&optional n)
"Visit previous next-error message and corresponding source code.
When turned on, cursor motion in the compilation, grep, occur or diff
buffer causes automatic display of the corresponding source code
location."
- nil " Fol" nil
+ :group 'next-error :init-value " Fol"
(if (not next-error-follow-minor-mode)
(remove-hook 'post-command-hook 'next-error-follow-mode-post-command-hook t)
(add-hook 'post-command-hook 'next-error-follow-mode-post-command-hook nil t)
Other major modes are defined by comparison with this one."
(interactive)
(kill-all-local-variables)
- (run-hooks 'after-change-major-mode-hook))
+ (unless delay-mode-hooks
+ (run-hooks 'after-change-major-mode-hook)))
;; Making and deleting lines.
(defun goto-line (arg &optional buffer)
"Goto line ARG, counting from line 1 at beginning of buffer.
-Normally, move point in the curren buffer.
-With just C-u as argument, move point in the most recently displayed
-other buffer, and switch to it.
+Normally, move point in the current buffer.
+With just \\[universal-argument] as argument, move point in the most recently
+displayed other buffer, and switch to it. When called from Lisp code,
+the optional argument BUFFER specifies a buffer to switch to.
If there's a number in the buffer at point, it is the default for ARG."
(interactive
(defvar read-expression-history nil)
(defcustom eval-expression-print-level 4
- "*Value to use for `print-level' when printing value in `eval-expression'.
+ "Value for `print-level' while printing value in `eval-expression'.
A value of nil means no limit."
:group 'lisp
:type '(choice (const :tag "No Limit" nil) integer)
:version "21.1")
(defcustom eval-expression-print-length 12
- "*Value to use for `print-length' when printing value in `eval-expression'.
+ "Value for `print-length' while printing value in `eval-expression'.
A value of nil means no limit."
:group 'lisp
:type '(choice (const :tag "No Limit" nil) integer)
:version "21.1")
(defcustom eval-expression-debug-on-error t
- "*Non-nil means set `debug-on-error' when evaluating in `eval-expression'.
+ "If non-nil set `debug-on-error' to t in `eval-expression'.
If nil, don't change the value of `debug-on-error'."
:group 'lisp
:type 'boolean
(defalias 'advertised-undo 'undo)
(defconst undo-equiv-table (make-hash-table :test 'eq :weakness t)
- "Table mapping redo records to the corresponding undo one.")
+ "Table mapping redo records to the corresponding undo one.
+A redo record for undo-in-region maps to t.
+A redo record for ordinary undo maps to the following (earlier) undo.")
(defvar undo-in-region nil
"Non-nil if `pending-undo-list' is not just a tail of `buffer-undo-list'.")
(defvar pending-undo-list nil
"Within a run of consecutive undo commands, list remaining to be undone.
-t if we undid all the way to the end of it.")
+If t, we undid all the way to the end of it.")
(defun undo (&optional arg)
"Undo some previous changes.
(message (if undo-in-region
(if equiv "Redo in region!" "Undo in region!")
(if equiv "Redo!" "Undo!"))))
- (when (and equiv undo-no-redo)
+ (when (and (consp equiv) undo-no-redo)
;; The equiv entry might point to another redo record if we have done
;; undo-redo-undo-redo-... so skip to the very last equiv.
(while (let ((next (gethash equiv undo-equiv-table)))
(prefix-numeric-value arg)
1))
;; Record the fact that the just-generated undo records come from an
- ;; undo operation, so we can skip them later on.
+ ;; undo operation--that is, they are redo records.
+ ;; In the ordinary case (not within a region), map the redo
+ ;; record to the following undos.
;; I don't know how to do that in the undo-in-region case.
- (unless undo-in-region
- (puthash buffer-undo-list pending-undo-list undo-equiv-table))
+ (puthash buffer-undo-list
+ (if undo-in-region t pending-undo-list)
+ undo-equiv-table)
;; Don't specify a position in the undo record for the undo command.
;; Instead, undoing this should move point to where the change is.
(let ((tail buffer-undo-list)
Contrary to `undo', this will not redo a previous undo."
(interactive "*p")
(let ((undo-no-redo t)) (undo arg)))
-;; Richard said that we should not use C-x <uppercase letter> and I have
-;; no idea whereas to bind it. Any suggestion welcome. -stef
-;; (define-key ctl-x-map "U" 'undo-only)
(defvar undo-in-progress nil
"Non-nil while performing an undo.
Some change-hooks test this variable to do something different.")
-(defun undo-more (count)
+(defun undo-more (n)
"Undo back N undo-boundaries beyond what was already undone recently.
Call `undo-start' to get ready to undo recent changes,
then call `undo-more' one or more times to undo them."
(or (listp pending-undo-list)
- (error (format "No further undo information%s"
- (if (and transient-mark-mode mark-active)
- " for region" ""))))
+ (error (concat "No further undo information"
+ (and transient-mark-mode mark-active
+ " for region"))))
(let ((undo-in-progress t))
- (setq pending-undo-list (primitive-undo count pending-undo-list))
+ (setq pending-undo-list (primitive-undo n pending-undo-list))
(if (null pending-undo-list)
(setq pending-undo-list t))))
(reset-this-command-lengths)
(restore-overriding-map))
\f
+(defvar buffer-substring-filters nil
+ "List of filter functions for `filter-buffer-substring'.
+Each function must accept a single argument, a string, and return
+a string. The buffer substring is passed to the first function
+in the list, and the return value of each function is passed to
+the next. The return value of the last function is used as the
+return value of `filter-buffer-substring'.
+
+If this variable is nil, no filtering is performed.")
+
+(defun filter-buffer-substring (beg end &optional delete)
+ "Return the buffer substring between BEG and END, after filtering.
+The buffer substring is passed through each of the filter
+functions in `buffer-substring-filters', and the value from the
+last filter function is returned. If `buffer-substring-filters'
+is nil, the buffer substring is returned unaltered.
+
+If DELETE is non-nil, the text between BEG and END is deleted
+from the buffer.
+
+Point is temporarily set to BEG before calling
+`buffer-substring-filters', in case the functions need to know
+where the text came from.
+
+This function should be used instead of `buffer-substring' or
+`delete-and-extract-region' when you want to allow filtering to
+take place. For example, major or minor modes can use
+`buffer-substring-filters' to extract characters that are special
+to a buffer, and should not be copied into other buffers."
+ (save-excursion
+ (goto-char beg)
+ (let ((string (if delete (delete-and-extract-region beg end)
+ (buffer-substring beg end))))
+ (dolist (filter buffer-substring-filters string)
+ (setq string (funcall filter string))))))
+
;;;; Window system cut and paste hooks.
(defvar interprogram-cut-function nil
text. See `insert-for-yank'."
(interactive "r")
(condition-case nil
- (let ((string (delete-and-extract-region beg end)))
+ (let ((string (filter-buffer-substring beg end t)))
(when string ;STRING is nil if BEG = END
;; Add that string to the kill ring, one way or another.
(if (eq last-command 'kill-region)
system cut and paste."
(interactive "r")
(if (eq last-command 'kill-region)
- (kill-append (buffer-substring beg end) (< end beg))
- (kill-new (buffer-substring beg end)))
+ (kill-append (filter-buffer-substring beg end) (< end beg))
+ (kill-new (filter-buffer-substring beg end)))
(if transient-mark-mode
(setq deactivate-mark t))
nil)
;; This is actually used in subr.el but defcustom does not work there.
(defcustom yank-excluded-properties
'(read-only invisible intangible field mouse-face help-echo local-map keymap
- yank-handler)
+ yank-handler follow-link)
"*Text properties to discard when yanking.
The value should be a list of text properties to discard or t,
which means to discard all text properties."
If N is negative, this is a more recent kill.
The sequence of kills wraps around, so that after the oldest one
-comes the newest one."
+comes the newest one.
+
+When this command inserts killed text into the buffer, it honors
+`yank-excluded-properties' and `yank-handler' as described in the
+doc string for `insert-for-yank-1', which see."
(interactive "*p")
(if (not (eq last-command 'yank))
(error "Previous command was not a yank"))
With just \\[universal-argument] as argument, same but put point at beginning (and mark at end).
With argument N, reinsert the Nth most recently killed stretch of killed
text.
+
+When this command inserts killed text into the buffer, it honors
+`yank-excluded-properties' and `yank-handler' as described in the
+doc string for `insert-for-yank-1', which see.
+
See also the command \\[yank-pop]."
(interactive "*P")
(setq yank-window-start (window-start))
"Kill current line.
With prefix arg, kill that many lines starting from the current line.
If arg is negative, kill backward. Also kill the preceding newline.
-\(This is meant to make C-x z work well with negative arguments.\)
+\(This is meant to make \\[repeat] work well with negative arguments.\)
If arg is zero, kill current line but exclude the trailing newline."
(interactive "p")
(if (and (> arg 0) (eobp) (save-excursion (forward-visible-line 0) (eobp)))
mark position to be lost.
Normally, when a new mark is set, the old one should go on the stack.
-This is why most applications should use push-mark, not set-mark.
+This is why most applications should use `push-mark', not `set-mark'.
Novice Emacs Lisp programmers often try to use the mark for the wrong
purposes. The mark saves a location for the user's convenience.
commands which are sensitive to the Transient Mark mode."
:global t :group 'editing-basics :require nil)
+(defvar widen-automatically t
+ "Non-nil means it is ok for commands to call `widen' when they want to.
+Some commands will do this in order to go to positions outside
+the current accessible part of the buffer.
+
+If `widen-automatically' is nil, these commands will do something else
+as a fallback, and won't change the buffer bounds.")
+
(defun pop-global-mark ()
"Pop off global mark ring and jump to the top location."
(interactive)
(set-buffer buffer)
(or (and (>= position (point-min))
(<= position (point-max)))
- (widen))
+ (if widen-automatically
+ (error "Global mark position is outside accessible part of buffer")
+ (widen)))
(goto-char position)
(switch-to-buffer buffer)))
\f
(or (memq prop buffer-invisibility-spec)
(assq prop buffer-invisibility-spec)))))
-;; Perform vertical scrolling of tall images if necessary.
-;; Don't vscroll in a keyboard macro.
+;; This is like line-move-1 except that it also performs
+;; vertical scrolling of tall images if appropriate.
+;; That is not really a clean thing to do, since it mixes
+;; scrolling with cursor motion. But so far we don't have
+;; a cleaner solution to the problem of making C-n do something
+;; useful given a tall image.
(defun line-move (arg &optional noerror to-end try-vscroll)
(if (and auto-window-vscroll try-vscroll
+ ;; But don't vscroll in a keyboard macro.
(not defining-kbd-macro)
(not executing-kbd-macro))
(let ((forward (> arg 0))
(part (nth 2 (pos-visible-in-window-p (point) nil t))))
(if (and (consp part)
- (> (setq part (if forward (cdr part) (car part))) 0))
+ (> (if forward (cdr part) (car part)) 0))
(set-window-vscroll nil
(if forward
(+ (window-vscroll nil t)
- (min part
+ (min (cdr part)
(* (frame-char-height) arg)))
(max 0
(- (window-vscroll nil t)
- (min part
+ (min (car part)
(* (frame-char-height) (- arg))))))
t)
(set-window-vscroll nil 0)
(when (line-move-1 arg noerror to-end)
- (sit-for 0)
- (if (and (not forward)
- (setq part (nth 2 (pos-visible-in-window-p
- (line-beginning-position) nil t)))
- (> (cdr part) 0))
- (set-window-vscroll nil (cdr part) t))
+ (when (not forward)
+ ;; Update display before calling pos-visible-in-window-p,
+ ;; because it depends on window-start being up-to-date.
+ (sit-for 0)
+ ;; If the current line is partly hidden at the bottom,
+ ;; scroll it partially up so as to unhide the bottom.
+ (if (and (setq part (nth 2 (pos-visible-in-window-p
+ (line-beginning-position) nil t)))
+ (> (cdr part) 0))
+ (set-window-vscroll nil (cdr part) t)))
t)))
(line-move-1 arg noerror to-end)))
(goto-char (next-char-property-change (point))))
;; Now move a line.
(end-of-line)
- (and (zerop (vertical-motion 1))
- (if (not noerror)
- (signal 'end-of-buffer nil)
- (setq done t)))
+ ;; If there's no invisibility here, move over the newline.
+ (cond
+ ((eobp)
+ (if (not noerror)
+ (signal 'end-of-buffer nil)
+ (setq done t)))
+ ((and (> arg 1) ;; Use vertical-motion for last move
+ (not (integerp selective-display))
+ (not (line-move-invisible-p (point))))
+ ;; We avoid vertical-motion when possible
+ ;; because that has to fontify.
+ (forward-line 1))
+ ;; Otherwise move a more sophisticated way.
+ ((zerop (vertical-motion 1))
+ (if (not noerror)
+ (signal 'end-of-buffer nil)
+ (setq done t))))
(unless done
(setq arg (1- arg))))
+ ;; The logic of this is the same as the loop above,
+ ;; it just goes in the other direction.
(while (and (< arg 0) (not done))
(beginning-of-line)
-
- (if (zerop (vertical-motion -1))
- (if (not noerror)
- (signal 'beginning-of-buffer nil)
- (setq done t)))
+ (cond
+ ((bobp)
+ (if (not noerror)
+ (signal 'beginning-of-buffer nil)
+ (setq done t)))
+ ((and (< arg -1) ;; Use vertical-motion for last move
+ (not (integerp selective-display))
+ (not (line-move-invisible-p (1- (point)))))
+ (forward-line -1))
+ ((zerop (vertical-motion -1))
+ (if (not noerror)
+ (signal 'beginning-of-buffer nil)
+ (setq done t))))
(unless done
(setq arg (1+ arg))
(while (and ;; Don't move over previous invis lines
(or arg (setq arg 1))
(if (/= arg 1)
(line-move (1- arg) t))
- (let (done pos)
- (while (not done)
- (beginning-of-line 1)
- ;; (not bolp) means that it stopped at a field boundary.
- (if (or (bobp) (not (bolp)))
- (setq done t)
- (sit-for 0)
- (if (and (consp (setq pos (pos-visible-in-window-p (point) nil t)))
- (= (car pos) 0))
- (setq done t)
- (backward-char 1))))))
+ (beginning-of-line 1)
+ (let ((orig (point)))
+ (vertical-motion 0)
+ (if (/= orig (point))
+ (goto-char (constrain-to-field (point) orig (/= arg 1) t nil)))))
;;; Many people have said they rarely use this feature, and often type
(if (eq lines '-) nil
(if (null lines) '-
(- (prefix-numeric-value lines))))))
-(define-key esc-map [?\C-\S-v] 'scroll-other-window-down)
(defun beginning-of-buffer-other-window (arg)
"Move point to the beginning of the buffer in the other window.
This function is only called during auto-filling of a comment section.
The function should take a single optional argument, which is a flag
-indicating whether it should use soft newlines.
-
-Setting this variable automatically makes it local to the current buffer.")
+indicating whether it should use soft newlines.")
;; This function is used as the auto-fill-function of a buffer
;; when Auto-Fill mode is enabled.
"The function to use for `auto-fill-function' if Auto Fill mode is turned on.
Some major modes set this.")
+(put 'auto-fill-function :minor-mode-function 'auto-fill-mode)
;; FIXME: turn into a proper minor mode.
;; Add a global minor mode version of it.
(defun auto-fill-mode (&optional arg)
(setq blinkpos (scan-sexps oldpos -1)))
(error nil)))
(and blinkpos
- (not (eq (car (syntax-after blinkpos)) 8)) ;Not syntax '$'.
+ ;; Not syntax '$'.
+ (not (eq (syntax-class (syntax-after blinkpos)) 8))
(setq matching-paren
(let ((syntax (syntax-after blinkpos)))
(and (consp syntax)
- (eq (logand (car syntax) 255) 4)
+ (eq (syntax-class syntax) 4)
(cdr syntax)))
mismatch
(or (null matching-paren)
(setq defining-kbd-macro nil)
(signal 'quit nil))
-(define-key global-map "\C-g" 'keyboard-quit)
-
(defvar buffer-quit-function nil
"Function to call to \"quit\" the current buffer, or nil if none.
\\[keyboard-escape-quit] calls this function when its more local actions
(push 'sound sound)
(play-sound sound)))
-(define-key global-map "\e\e\e" 'keyboard-escape-quit)
\f
(defcustom read-mail-command 'rmail
"*Your preference for a mail reading package.
(defvar set-variable-value-history nil
"History of values entered with `set-variable'.")
-(defun set-variable (var val &optional make-local)
+(defun set-variable (variable value &optional make-local)
"Set VARIABLE to VALUE. VALUE is a Lisp object.
-When using this interactively, enter a Lisp object for VALUE.
-If you want VALUE to be a string, you must surround it with doublequotes.
+VARIABLE should be a user option variable name, a Lisp variable
+meant to be customized by users. You should enter VALUE in Lisp syntax,
+so if you want VALUE to be a string, you must surround it with doublequotes.
VALUE is used literally, not evaluated.
If VARIABLE has a `variable-interactive' property, that is used as if
(interactive
(let* ((default-var (variable-at-point))
(var (if (symbolp default-var)
- (read-variable (format "Set variable (default %s): " default-var)
- default-var)
- (read-variable "Set variable: ")))
+ (read-variable (format "Set variable (default %s): " default-var)
+ default-var)
+ (read-variable "Set variable: ")))
(minibuffer-help-form '(describe-variable var))
(prop (get var 'variable-interactive))
- (prompt (format "Set %s%s to value: " var
+ (obsolete (car (get var 'byte-obsolete-variable)))
+ (prompt (format "Set %s %s to value: " var
(cond ((local-variable-p var)
- " (buffer-local)")
+ "(buffer-local)")
((or current-prefix-arg
(local-variable-if-set-p var))
- " buffer-locally")
- (t " globally"))))
- (val (if prop
- ;; Use VAR's `variable-interactive' property
- ;; as an interactive spec for prompting.
- (call-interactively `(lambda (arg)
- (interactive ,prop)
- arg))
- (read
- (read-string prompt nil
- 'set-variable-value-history)))))
+ "buffer-locally")
+ (t "globally"))))
+ (val (progn
+ (when obsolete
+ (message (concat "`%S' is obsolete; "
+ (if (symbolp obsolete) "use `%S' instead" "%s"))
+ var obsolete)
+ (sit-for 3))
+ (if prop
+ ;; Use VAR's `variable-interactive' property
+ ;; as an interactive spec for prompting.
+ (call-interactively `(lambda (arg)
+ (interactive ,prop)
+ arg))
+ (read
+ (read-string prompt nil
+ 'set-variable-value-history))))))
(list var val current-prefix-arg)))
- (and (custom-variable-p var)
- (not (get var 'custom-type))
- (custom-load-symbol var))
- (let ((type (get var 'custom-type)))
+ (and (custom-variable-p variable)
+ (not (get variable 'custom-type))
+ (custom-load-symbol variable))
+ (let ((type (get variable 'custom-type)))
(when type
;; Match with custom type.
(require 'cus-edit)
(setq type (widget-convert type))
- (unless (widget-apply type :match val)
+ (unless (widget-apply type :match value)
(error "Value `%S' does not match type %S of %S"
- val (car type) var))))
+ value (car type) variable))))
(if make-local
- (make-local-variable var))
+ (make-local-variable variable))
- (set var val)
+ (set variable value)
;; Force a thorough redisplay for the case that the variable
;; has an effect on the display, like `tab-width' has.
(setq major-mode 'completion-list-mode)
(make-local-variable 'completion-base-size)
(setq completion-base-size nil)
- (run-hooks 'completion-list-mode-hook))
+ (run-mode-hooks 'completion-list-mode-hook))
(defun completion-list-mode-finish ()
"Finish setup of the completions buffer.
(- (point) (minibuffer-prompt-end)))))
;; Otherwise, in minibuffer, the whole input is being completed.
(if (minibufferp mainbuf)
- (setq completion-base-size 0)))
+ (if (and (symbolp minibuffer-completion-table)
+ (get minibuffer-completion-table 'completion-base-size-function))
+ (setq completion-base-size
+ (funcall (get minibuffer-completion-table 'completion-base-size-function)))
+ (setq completion-base-size 0))))
;; Put faces on first uncommon characters and common parts.
(when completion-base-size
(let* ((common-string-length
(defun clone-indirect-buffer (newname display-flag &optional norecord)
"Create an indirect buffer that is a twin copy of the current buffer.
-Give the indirect buffer name NEWNAME. Interactively, read NEW-NAME
+Give the indirect buffer name NEWNAME. Interactively, read NEWNAME
from the minibuffer when invoked with a prefix arg. If NEWNAME is nil
or if not called with a prefix arg, NEWNAME defaults to the current
buffer's name. The name is modified by adding a `<N>' suffix to it
(set-buffer buffer)
(clone-indirect-buffer nil t norecord)))
-(define-key ctl-x-4-map "c" 'clone-indirect-buffer-other-window)
\f
;;; Handling of Backspace and Delete keys.
(message "Delete key deletes %s"
(if normal-erase-is-backspace "forward" "backward"))))
\f
-(defcustom idle-update-delay 0.5
- "*Idle time delay before updating various things on the screen.
-Various Emacs features that update auxiliary information when point moves
-wait this many seconds after Emacs becomes idle before doing an update."
- :type 'number
- :group 'display
- :version "22.1")
-\f
(defvar vis-mode-saved-buffer-invisibility-spec nil
"Saved value of `buffer-invisibility-spec' when Visible mode is on.")
Disabling Visible mode turns off that effect. Visible mode
works by saving the value of `buffer-invisibility-spec' and setting it to nil."
:lighter " Vis"
+ :group 'editing-basics
(when (local-variable-p 'vis-mode-saved-buffer-invisibility-spec)
(setq buffer-invisibility-spec vis-mode-saved-buffer-invisibility-spec)
(kill-local-variable 'vis-mode-saved-buffer-invisibility-spec))