;;; simple.el --- basic editing commands for Emacs
;; Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-;; 2000, 2001, 2002, 2003, 2004, 2005
-;; Free Software Foundation, Inc.
+;; 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: internal
;; 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"))
+(defvar compilation-current-error)
+
(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
;;; next-error support framework
(defgroup next-error nil
- "next-error support framework."
+ "`next-error' support framework."
:group 'compilation
:version "22.1")
(defcustom next-error-highlight 0.1
"*Highlighting of locations in selected source buffers.
-If number, highlight the locus in next-error face for given time in seconds.
-If t, use persistent overlays fontified in next-error face.
+If number, highlight the locus in `next-error' face for given time in seconds.
+If t, use persistent overlays fontified in `next-error' face.
If nil, don't highlight the locus in the source buffer.
If `fringe-arrow', indicate the locus by the fringe arrow."
:type '(choice (number :tag "Delay")
(defcustom next-error-highlight-no-select 0.1
"*Highlighting of locations in non-selected source buffers.
-If number, highlight the locus in next-error face for given time in seconds.
-If t, use persistent overlays fontified in next-error face.
+If number, highlight the locus in `next-error' face for given time in seconds.
+If t, use persistent overlays fontified in `next-error' face.
If nil, don't highlight the locus in the source buffer.
If `fringe-arrow', indicate the locus by the fringe arrow."
:type '(choice (number :tag "Delay")
: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)
(add-to-list 'overlay-arrow-variable-list 'next-error-overlay-arrow-position)
(defvar next-error-last-buffer nil
- "The most recent next-error buffer.
+ "The most recent `next-error' buffer.
A buffer becomes most recent when its compilation, grep, or
similar mode is started, or when it is used with \\[next-error]
or \\[compile-goto-error].")
&optional avoid-current
extra-test-inclusive
extra-test-exclusive)
- "Test if BUFFER is a next-error capable buffer.
+ "Test if BUFFER is a `next-error' capable buffer.
If AVOID-CURRENT is non-nil, treat the current buffer
as an absolute last resort only.
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))))
(defun next-error-find-buffer (&optional avoid-current
extra-test-inclusive
extra-test-exclusive)
- "Return a next-error capable buffer.
+ "Return a `next-error' capable 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.
(error "No next-error capable buffer found")))
(defun next-error (&optional arg reset)
- "Visit next next-error message and corresponding source code.
+ "Visit next `next-error' message and corresponding source code.
If all the error messages parsed so far have been processed already,
the message buffer is checked for new ones.
\\[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)
(defun previous-error (&optional n)
- "Visit previous next-error message and corresponding source code.
+ "Visit previous `next-error' message and corresponding source code.
Prefix arg N says how many error messages to move backwards (or
forwards, if negative).
(next-error n t))
(defun next-error-no-select (&optional n)
- "Move point to the next error in the next-error buffer and highlight match.
+ "Move point to the next error in the `next-error' buffer and highlight match.
Prefix arg N says how many error messages to move forwards (or
backwards, if negative).
Finds and highlights the source line like \\[next-error], but does not
(pop-to-buffer next-error-last-buffer))
(defun previous-error-no-select (&optional n)
- "Move point to the previous error in the next-error buffer and highlight match.
+ "Move point to the previous error in the `next-error' buffer and highlight match.
Prefix arg N says how many error messages to move backwards (or
forwards, if negative).
Finds and highlights the source line like \\[previous-error], but does not
When turned on, cursor motion in the compilation, grep, occur or diff
buffer causes automatic display of the corresponding source code
location."
- :group 'next-error :init-value " Fol"
+ :group 'next-error :init-value nil :lighter " 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)
- (make-variable-buffer-local 'next-error-follow-last-line)))
+ (make-local-variable 'next-error-follow-last-line)))
;;; Used as a `post-command-hook' by `next-error-follow-mode'
;;; for the *Compilation* *grep* and *Occur* buffers.
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 open-line (n)
"Insert a newline and leave point before it.
-If there is a fill prefix and/or a left-margin, insert them on the new line
-if the line would have been blank.
+If there is a fill prefix and/or a `left-margin', insert them
+on the new line if the line would have been blank.
With arg N, insert N newlines."
(interactive "*p")
(let* ((do-fill-prefix (and fill-prefix (bolp)))
(defun split-line (&optional arg)
"Split current line, moving portion beyond point vertically down.
If the current line starts with `fill-prefix', insert it on the new
-line as well. With prefix ARG, don't insert fill-prefix on new line.
+line as well. With prefix ARG, don't insert `fill-prefix' on new line.
When called from Lisp code, ARG may be a prefix string to copy."
(interactive "*P")
(save-excursion (forward-char -1)
(looking-at "$\\|\\s(\\|\\s'")))
nil
- (insert ?\ ))))
+ (insert ?\s))))
(defun delete-horizontal-space (&optional backward-only)
"Delete all spaces and tabs around point.
(skip-chars-backward " \t")
(constrain-to-field nil orig-pos)
(dotimes (i (or n 1))
- (if (= (following-char) ?\ )
+ (if (= (following-char) ?\s)
(forward-char 1)
- (insert ?\ )))
+ (insert ?\s)))
(delete-region
(point)
(progn
;; For compatibility with the old subr of the same name.
(defun minibuffer-prompt-width ()
"Return the display width of the minibuffer prompt.
-Return 0 if current buffer is not a mini-buffer."
+Return 0 if current buffer is not a minibuffer."
;; Return the width of everything before the field at the end of
;; the buffer; this should be 0 for normal buffers.
(1- (minibuffer-prompt-end)))
(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.
"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))))
When the yank handler has a non-nil PARAM element, the original STRING
argument is not used by `insert-for-yank'. However, since Lisp code
-may access and use elements from the kill-ring directly, the STRING
+may access and use elements from the kill ring directly, the STRING
argument should still be a \"useful\" string for such uses."
(if (> (length string) 0)
(if yank-handler
(let ((col (current-column)))
(forward-char -1)
(setq col (- col (current-column)))
- (insert-char ?\ col)
+ (insert-char ?\s col)
(delete-char 1)))
(forward-char -1)
(setq count (1- count))))))
"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)))
(or (and (>= position (point-min))
(<= position (point-max)))
(if widen-automatically
- (error "Global mark position is outside accessible part of buffer")
- (widen)))
+ (widen)
+ (error "Global mark position is outside accessible part of buffer")))
(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))
;; 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))
;; Now move a line.
(end-of-line)
;; If there's no invisibility here, move over the newline.
- (if (and (not (integerp selective-display))
- (not (line-move-invisible-p (point))))
- ;; We avoid vertical-motion when possible
- ;; because that has to fontify.
- (if (eobp)
- (if (not noerror)
- (signal 'end-of-buffer nil)
- (setq done t))
- (forward-line 1))
- ;; Otherwise move a more sophisticated way.
- ;; (What's the logic behind this code?)
- (and (zerop (vertical-motion 1))
- (if (not noerror)
- (signal 'end-of-buffer nil)
- (setq done t))))
+ (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 (or (bobp)
- (and (not (integerp selective-display))
- (not (line-move-invisible-p (1- (point))))))
- (if (bobp)
- (if (not noerror)
- (signal 'beginning-of-buffer nil)
- (setq done t))
- (forward-line -1))
- (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
;; at least go to end of line.
(end-of-line))
((< arg 0)
- ;; If we did not move down as far as desired,
- ;; at least go to end of line.
+ ;; If we did not move up as far as desired,
+ ;; at least go to beginning of line.
(beginning-of-line))
(t
(line-move-finish (or goal-column temporary-goal-column)
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.
(setq arg (current-column)))
(if (not (integerp arg))
;; Disallow missing argument; it's probably a typo for C-x C-f.
- (error "Set-fill-column requires an explicit argument")
+ (error "set-fill-column requires an explicit argument")
(message "Fill column set to %d (was %d)" arg fill-column)
(setq fill-column arg)))
\f
typing characters do.
Note that binary overwrite mode is not its own minor mode; it is a
-specialization of overwrite-mode, entered by setting the
+specialization of overwrite mode, entered by setting the
`overwrite-mode' variable to `overwrite-mode-binary'."
(interactive "P")
(setq overwrite-mode
:group 'paren-blinking)
(defcustom blink-matching-paren-distance (* 25 1024)
- "*If non-nil, is maximum distance to search for matching open-paren."
- :type 'integer
+ "*If non-nil, maximum distance to search backwards for matching open-paren.
+If nil, search stops at the beginning of the accessible portion of the buffer."
+ :type '(choice (const nil) integer)
:group 'paren-blinking)
(defcustom blink-matching-delay 1
(defun blink-matching-open ()
"Move cursor momentarily to the beginning of the sexp before point."
(interactive)
- (and (> (point) (1+ (point-min)))
- blink-matching-paren
- ;; Verify an even number of quoting characters precede the close.
- (= 1 (logand 1 (- (point)
- (save-excursion
- (forward-char -1)
- (skip-syntax-backward "/\\")
- (point)))))
- (let* ((oldpos (point))
- (blinkpos)
- (mismatch)
- matching-paren)
- (save-excursion
- (save-restriction
- (if blink-matching-paren-distance
- (narrow-to-region (max (point-min)
- (- (point) blink-matching-paren-distance))
- oldpos))
- (condition-case ()
- (let ((parse-sexp-ignore-comments
- (and parse-sexp-ignore-comments
- (not blink-matching-paren-dont-ignore-comments))))
- (setq blinkpos (scan-sexps oldpos -1)))
- (error nil)))
- (and blinkpos
- ;; Not syntax '$'.
- (not (eq (syntax-class (syntax-after blinkpos)) 8))
- (setq matching-paren
- (let ((syntax (syntax-after blinkpos)))
- (and (consp syntax)
- (eq (syntax-class syntax) 4)
- (cdr syntax)))
- mismatch
- (or (null matching-paren)
- (/= (char-after (1- oldpos))
- matching-paren))))
- (if mismatch (setq blinkpos nil))
- (if blinkpos
- ;; Don't log messages about paren matching.
- (let (message-log-max)
- (goto-char blinkpos)
- (if (pos-visible-in-window-p)
- (and blink-matching-paren-on-screen
- (sit-for blink-matching-delay))
- (goto-char blinkpos)
- (message
- "Matches %s"
- ;; Show what precedes the open in its line, if anything.
- (if (save-excursion
- (skip-chars-backward " \t")
- (not (bolp)))
- (buffer-substring (progn (beginning-of-line) (point))
- (1+ blinkpos))
- ;; Show what follows the open in its line, if anything.
- (if (save-excursion
- (forward-char 1)
- (skip-chars-forward " \t")
- (not (eolp)))
- (buffer-substring blinkpos
- (progn (end-of-line) (point)))
- ;; Otherwise show the previous nonblank line,
- ;; if there is one.
- (if (save-excursion
- (skip-chars-backward "\n \t")
- (not (bobp)))
- (concat
- (buffer-substring (progn
+ (when (and (> (point) (1+ (point-min)))
+ blink-matching-paren
+ ;; Verify an even number of quoting characters precede the close.
+ (= 1 (logand 1 (- (point)
+ (save-excursion
+ (forward-char -1)
+ (skip-syntax-backward "/\\")
+ (point))))))
+ (let* ((oldpos (point))
+ blinkpos
+ message-log-max ; Don't log messages about paren matching.
+ matching-paren
+ open-paren-line-string)
+ (save-excursion
+ (save-restriction
+ (if blink-matching-paren-distance
+ (narrow-to-region (max (point-min)
+ (- (point) blink-matching-paren-distance))
+ oldpos))
+ (condition-case ()
+ (let ((parse-sexp-ignore-comments
+ (and parse-sexp-ignore-comments
+ (not blink-matching-paren-dont-ignore-comments))))
+ (setq blinkpos (scan-sexps oldpos -1)))
+ (error nil)))
+ (and blinkpos
+ ;; Not syntax '$'.
+ (not (eq (syntax-class (syntax-after blinkpos)) 8))
+ (setq matching-paren
+ (let ((syntax (syntax-after blinkpos)))
+ (and (consp syntax)
+ (eq (syntax-class syntax) 4)
+ (cdr syntax)))))
+ (cond
+ ((or (null matching-paren)
+ (/= (char-before oldpos)
+ matching-paren))
+ (message "Mismatched parentheses"))
+ ((not blinkpos)
+ (if (not blink-matching-paren-distance)
+ (message "Unmatched parenthesis")))
+ ((pos-visible-in-window-p blinkpos)
+ ;; Matching open within window, temporarily move to blinkpos but only
+ ;; if `blink-matching-paren-on-screen' is non-nil.
+ (when blink-matching-paren-on-screen
+ (save-excursion
+ (goto-char blinkpos)
+ (sit-for blink-matching-delay))))
+ (t
+ (save-excursion
+ (goto-char blinkpos)
+ (setq open-paren-line-string
+ ;; Show what precedes the open in its line, if anything.
+ (if (save-excursion
+ (skip-chars-backward " \t")
+ (not (bolp)))
+ (buffer-substring (line-beginning-position)
+ (1+ blinkpos))
+ ;; Show what follows the open in its line, if anything.
+ (if (save-excursion
+ (forward-char 1)
+ (skip-chars-forward " \t")
+ (not (eolp)))
+ (buffer-substring blinkpos
+ (line-end-position))
+ ;; Otherwise show the previous nonblank line,
+ ;; if there is one.
+ (if (save-excursion
+ (skip-chars-backward "\n \t")
+ (not (bobp)))
+ (concat
+ (buffer-substring (progn
(skip-chars-backward "\n \t")
- (beginning-of-line)
- (point))
- (progn (end-of-line)
- (skip-chars-backward " \t")
- (point)))
- ;; Replace the newline and other whitespace with `...'.
- "..."
- (buffer-substring blinkpos (1+ blinkpos)))
- ;; There is nothing to show except the char itself.
- (buffer-substring blinkpos (1+ blinkpos))))))))
- (cond (mismatch
- (message "Mismatched parentheses"))
- ((not blink-matching-paren-distance)
- (message "Unmatched parenthesis"))))))))
+ (line-beginning-position))
+ (progn (end-of-line)
+ (skip-chars-backward " \t")
+ (point)))
+ ;; Replace the newline and other whitespace with `...'.
+ "..."
+ (buffer-substring blinkpos (1+ blinkpos)))
+ ;; There is nothing to show except the char itself.
+ (buffer-substring blinkpos (1+ blinkpos)))))))
+ (message "Matches %s"
+ (substring-no-properties open-paren-line-string))))))))
;Turned off because it makes dbx bomb out.
(setq blink-paren-function 'blink-matching-open)
(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.
(if (minibufferp mainbuf)
(if (and (symbolp minibuffer-completion-table)
(get minibuffer-completion-table 'completion-base-size-function))
- (setq completion-base-size
+ (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.
(define-key function-key-map (vector keypad) (vector normal))))
'((kp-0 ?0) (kp-1 ?1) (kp-2 ?2) (kp-3 ?3) (kp-4 ?4)
(kp-5 ?5) (kp-6 ?6) (kp-7 ?7) (kp-8 ?8) (kp-9 ?9)
- (kp-space ?\ )
+ (kp-space ?\s)
(kp-tab ?\t)
(kp-enter ?\r)
(kp-multiply ?*)
(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
DISPLAY-FLAG non-nil means show the new buffer with `pop-to-buffer'.
This is always done when called interactively.
-Optional last arg NORECORD non-nil means do not put this buffer at the
+Optional third arg NORECORD non-nil means do not put this buffer at the
front of the list of recently selected ones."
(interactive
(progn