* lisp/minibuffer.el (completion-pcm--merge-try): Merge trailing / with

[gnu-emacs] / lisp / simple.el

diff --git a/lisp/simple.el b/lisp/simple.el
index 1f1b5cb376fa5effebc7d274bb9d73963c803c47..36d2d0b3a15ef8a1f69e5d2800b692b53f0f7c23 100644 (file)
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -1,8 +1,8 @@
 ;;; simple.el --- basic editing commands for Emacs  -*- lexical-binding: t -*-
 
 ;;; simple.el --- basic editing commands for Emacs  -*- lexical-binding: t -*-
 

-;; Copyright (C) 1985-1987, 1993-2013 Free Software Foundation, Inc.
+;; Copyright (C) 1985-1987, 1993-2014 Free Software Foundation, Inc.

 
 

-;; Maintainer: FSF
+;; Maintainer: emacs-devel@gnu.org

 ;; Keywords: internal
 ;; Package: emacs
 
 ;; Keywords: internal
 ;; Package: emacs
 


@@ -382,7 +382,12 @@ Other major modes are defined by comparison with this one."
 If option `use-hard-newlines' is non-nil, the newline is marked with the
 text-property `hard'.
 With ARG, insert that many newlines.
 If option `use-hard-newlines' is non-nil, the newline is marked with the
 text-property `hard'.
 With ARG, insert that many newlines.

-Call `auto-fill-function' if the current column number is greater
+
+If `electric-indent-mode' is enabled, this indents the final new line
+that it adds, and reindents the preceding line.  To just insert
+a newline, use \\[electric-indent-just-newline].
+
+Calls `auto-fill-function' if the current column number is greater

 than the value of `fill-column' and ARG is nil.
 A non-nil INTERACTIVE argument means to run the `post-self-insert-hook'."
   (interactive "*P\np")
 than the value of `fill-column' and ARG is nil.
 A non-nil INTERACTIVE argument means to run the `post-self-insert-hook'."
   (interactive "*P\np")


@@ -606,7 +611,7 @@ In some text modes, where TAB inserts a tab, this command indents to the
 column specified by the function `current-left-margin'."
   (interactive "*")
   (delete-horizontal-space t)
 column specified by the function `current-left-margin'."
   (interactive "*")
   (delete-horizontal-space t)

-  (newline)
+  (newline nil t)

   (indent-according-to-mode))
 
 (defun reindent-then-newline-and-indent ()
   (indent-according-to-mode))
 
 (defun reindent-then-newline-and-indent ()


@@ -636,6 +641,67 @@ column specified by the function `current-left-margin'."
       (delete-horizontal-space t))
     (indent-according-to-mode)))
 
       (delete-horizontal-space t))
     (indent-according-to-mode)))
 

+(defcustom read-quoted-char-radix 8
+  "Radix for \\[quoted-insert] and other uses of `read-quoted-char'.
+Legitimate radix values are 8, 10 and 16."
+ :type '(choice (const 8) (const 10) (const 16))
+ :group 'editing-basics)
+
+(defun read-quoted-char (&optional prompt)
+  "Like `read-char', but do not allow quitting.
+Also, if the first character read is an octal digit,
+we read any number of octal digits and return the
+specified character code.  Any nondigit terminates the sequence.
+If the terminator is RET, it is discarded;
+any other terminator is used itself as input.
+
+The optional argument PROMPT specifies a string to use to prompt the user.
+The variable `read-quoted-char-radix' controls which radix to use
+for numeric input."
+  (let ((message-log-max nil) done (first t) (code 0) translated)
+    (while (not done)
+      (let ((inhibit-quit first)
+           ;; Don't let C-h get the help message--only help function keys.
+           (help-char nil)
+           (help-form
+            "Type the special character you want to use,
+or the octal character code.
+RET terminates the character code and is discarded;
+any other non-digit terminates the character code and is then used as input."))
+       (setq translated (read-key (and prompt (format "%s-" prompt))))
+       (if inhibit-quit (setq quit-flag nil)))
+      (if (integerp translated)
+         (setq translated (char-resolve-modifiers translated)))
+      (cond ((null translated))
+           ((not (integerp translated))
+            (setq unread-command-events
+                   (listify-key-sequence (this-single-command-raw-keys))
+                  done t))
+           ((/= (logand translated ?\M-\^@) 0)
+            ;; Turn a meta-character into a character with the 0200 bit set.
+            (setq code (logior (logand translated (lognot ?\M-\^@)) 128)
+                  done t))
+           ((and (<= ?0 translated)
+                  (< translated (+ ?0 (min 10 read-quoted-char-radix))))
+            (setq code (+ (* code read-quoted-char-radix) (- translated ?0)))
+            (and prompt (setq prompt (message "%s %c" prompt translated))))
+           ((and (<= ?a (downcase translated))
+                 (< (downcase translated)
+                     (+ ?a -10 (min 36 read-quoted-char-radix))))
+            (setq code (+ (* code read-quoted-char-radix)
+                          (+ 10 (- (downcase translated) ?a))))
+            (and prompt (setq prompt (message "%s %c" prompt translated))))
+           ((and (not first) (eq translated ?\C-m))
+            (setq done t))
+           ((not first)
+            (setq unread-command-events
+                   (listify-key-sequence (this-single-command-raw-keys))
+                  done t))
+           (t (setq code translated
+                    done t)))
+      (setq first nil))
+    code))
+

 (defun quoted-insert (arg)
   "Read next input character and insert it.
 This is useful for inserting control characters.
 (defun quoted-insert (arg)
   "Read next input character and insert it.
 This is useful for inserting control characters.


@@ -673,6 +739,9 @@ useful for editing binary files."
     ;;          (>= char ?\240)
     ;;          (<= char ?\377))
     ;;     (setq char (unibyte-char-to-multibyte char)))
     ;;          (>= char ?\240)
     ;;          (<= char ?\377))
     ;;     (setq char (unibyte-char-to-multibyte char)))

+    (unless (characterp char)
+      (user-error "%s is not a valid character"
+                 (key-description (vector char))))

     (if (> arg 0)
        (if (eq overwrite-mode 'overwrite-mode-binary)
            (delete-char arg)))
     (if (> arg 0)
        (if (eq overwrite-mode 'overwrite-mode-binary)
            (delete-char arg)))


@@ -729,7 +798,8 @@ If BACKWARD-ONLY is non-nil, only delete them before point."
 
 (defun just-one-space (&optional n)
   "Delete all spaces and tabs around point, leaving one space (or N spaces).
 
 (defun just-one-space (&optional n)
   "Delete all spaces and tabs around point, leaving one space (or N spaces).

-If N is negative, delete newlines as well, leaving -N spaces."
+If N is negative, delete newlines as well, leaving -N spaces.
+See also `cycle-spacing'."

   (interactive "*p")
   (cycle-spacing n nil t))
 
   (interactive "*p")
   (cycle-spacing n nil t))
 


@@ -740,31 +810,22 @@ position and original spacing around the point in this
 variable.")
 
 (defun cycle-spacing (&optional n preserve-nl-back single-shot)
 variable.")
 
 (defun cycle-spacing (&optional n preserve-nl-back single-shot)

-  "Manipulate spaces around the point in a smart way.
-
-When run as an interactive command, the first time it's called
-in a sequence, deletes all spaces and tabs around point leaving
-one (or N spaces).  If this does not change content of the
-buffer, skips to the second step:
-
-When run for the second time in a sequence, deletes all the
-spaces it has previously inserted.
+  "Manipulate whitespace around point in a smart way.
+In interactive use, this function behaves differently in successive
+consecutive calls.

 
 

-When run for the third time, returns the whitespace and point in
-a state encountered when it had been run for the first time.
+The first call in a sequence acts like `just-one-space'.
+It deletes all spaces and tabs around point, leaving one space
+\(or N spaces).  N is the prefix argument.  If N is negative,
+it deletes newlines as well, leaving -N spaces.
+\(If PRESERVE-NL-BACK is non-nil, it does not delete newlines before point.)

 
 

-For example, if buffer contains \"foo ^ bar\" with \"^\" denoting the
-point, calling `cycle-spacing' command will replace two spaces with
-a single space, calling it again immediately after, will remove all
-spaces, and calling it for the third time will bring two spaces back
-together.
+The second call in a sequence (or the first call if the above does
+not result in any changes) deletes all spaces.

 
 

-If N is negative, delete newlines as well.  However, if
-PRESERVE-NL-BACK is t new line characters prior to the point
-won't be removed.
+The third call in a sequence restores the original whitespace (and point).

 
 

-If SINGLE-SHOT is non-nil, will only perform the first step.  In
-other words, it will work just like `just-one-space' command."
+If SINGLE-SHOT is non-nil, it only performs the first step in the sequence."

   (interactive "*p")
   (let ((orig-pos       (point))
        (skip-characters (if (and n (< n 0)) " \t\n\r" " \t"))
   (interactive "*p")
   (let ((orig-pos       (point))
        (skip-characters (if (and n (< n 0)) " \t\n\r" " \t"))


@@ -827,6 +888,8 @@ Don't use this command in Lisp programs!
                        (/ (+ 10 (* size (prefix-numeric-value arg))) 10)))
                 (point-min))))
   (if (and arg (not (consp arg))) (forward-line 1)))
                        (/ (+ 10 (* size (prefix-numeric-value arg))) 10)))
                 (point-min))))
   (if (and arg (not (consp arg))) (forward-line 1)))

+(put 'beginning-of-buffer 'interactive-only
+     "use `(goto-char (point-min))' instead.")

 
 (defun end-of-buffer (&optional arg)
   "Move point to the end of the buffer.
 
 (defun end-of-buffer (&optional arg)
   "Move point to the end of the buffer.


@@ -859,6 +922,7 @@ Don't use this command in Lisp programs!
         ;; then scroll specially to put it near, but not at, the bottom.
         (overlay-recenter (point))
         (recenter -3))))
         ;; then scroll specially to put it near, but not at, the bottom.
         (overlay-recenter (point))
         (recenter -3))))

+(put 'end-of-buffer 'interactive-only "use `(goto-char (point-max))' instead.")

 
 (defcustom delete-active-region t
   "Whether single-char deletion commands delete an active region.
 
 (defcustom delete-active-region t
   "Whether single-char deletion commands delete an active region.


@@ -874,6 +938,18 @@ instead of deleted."
   :group 'killing
   :version "24.1")
 
   :group 'killing
   :version "24.1")
 

+(defvar region-extract-function
+  (lambda (delete)
+    (when (region-beginning)
+      (if (eq delete 'delete-only)
+          (delete-region (region-beginning) (region-end))
+        (filter-buffer-substring (region-beginning) (region-end) delete))))
+  "Function to get the region's content.
+Called with one argument DELETE.
+If DELETE is `delete-only', then only delete the region and the return value
+is undefined.  If DELETE is nil, just return the content as a string.
+If anything else, delete the region and return its content as a string.")
+

 (defun delete-backward-char (n &optional killflag)
   "Delete the previous N characters (following if N is negative).
 If Transient Mark mode is enabled, the mark is active, and N is 1,
 (defun delete-backward-char (n &optional killflag)
   "Delete the previous N characters (following if N is negative).
 If Transient Mark mode is enabled, the mark is active, and N is 1,


@@ -895,8 +971,8 @@ the end of the line."
              (= n 1))
         ;; If a region is active, kill or delete it.
         (if (eq delete-active-region 'kill)
              (= n 1))
         ;; If a region is active, kill or delete it.
         (if (eq delete-active-region 'kill)

-            (kill-region (region-beginning) (region-end))
-          (delete-region (region-beginning) (region-end))))
+            (kill-region (region-beginning) (region-end) 'region)
+           (funcall region-extract-function 'delete-only)))

        ;; In Overwrite mode, maybe untabify while deleting
        ((null (or (null overwrite-mode)
                   (<= n 0)
        ;; In Overwrite mode, maybe untabify while deleting
        ((null (or (null overwrite-mode)
                   (<= n 0)


@@ -909,6 +985,7 @@ the end of the line."
             (insert-char ?\s (- ocol (current-column)) nil))))
        ;; Otherwise, do simple deletion.
        (t (delete-char (- n) killflag))))
             (insert-char ?\s (- ocol (current-column)) nil))))
        ;; Otherwise, do simple deletion.
        (t (delete-char (- n) killflag))))

+(put 'delete-backward-char 'interactive-only 'delete-char)

 
 (defun delete-forward-char (n &optional killflag)
   "Delete the following N characters (previous if N is negative).
 
 (defun delete-forward-char (n &optional killflag)
   "Delete the following N characters (previous if N is negative).


@@ -927,10 +1004,12 @@ KILLFLAG is set if N was explicitly specified."
              (= n 1))
         ;; If a region is active, kill or delete it.
         (if (eq delete-active-region 'kill)
              (= n 1))
         ;; If a region is active, kill or delete it.
         (if (eq delete-active-region 'kill)

-            (kill-region (region-beginning) (region-end))
-          (delete-region (region-beginning) (region-end))))
+            (kill-region (region-beginning) (region-end) 'region)
+          (funcall region-extract-function 'delete-only)))
+

        ;; Otherwise, do simple deletion.
        (t (delete-char n killflag))))
        ;; Otherwise, do simple deletion.
        (t (delete-char n killflag))))

+(put 'delete-forward-char 'interactive-only 'delete-char)

 
 (defun mark-whole-buffer ()
   "Put point at beginning and mark at end of buffer.
 
 (defun mark-whole-buffer ()
   "Put point at beginning and mark at end of buffer.


@@ -1005,6 +1084,7 @@ rather than line counts."
     (if (eq selective-display t)
        (re-search-forward "[\n\C-m]" nil 'end (1- line))
       (forward-line (1- line)))))
     (if (eq selective-display t)
        (re-search-forward "[\n\C-m]" nil 'end (1- line))
       (forward-line (1- line)))))

+(put 'goto-line 'interactive-only 'forward-line)

 
 (defun count-words-region (start end &optional arg)
   "Count the number of words in the region.
 
 (defun count-words-region (start end &optional arg)
   "Count the number of words in the region.


@@ -1285,13 +1365,12 @@ Return a formatted string which is displayed in the echo area
 in addition to the value printed by prin1 in functions which
 display the result of expression evaluation."
   (if (and (integerp value)
 in addition to the value printed by prin1 in functions which
 display the result of expression evaluation."
   (if (and (integerp value)

-           (or (not (memq this-command '(eval-last-sexp eval-print-last-sexp)))
-               (eq this-command last-command)
-               (if (boundp 'edebug-active) edebug-active)))
+          (or (eq standard-output t)
+              (zerop (prefix-numeric-value current-prefix-arg))))

       (let ((char-string
       (let ((char-string

-             (if (or (if (boundp 'edebug-active) edebug-active)
-                    (memq this-command '(eval-last-sexp eval-print-last-sexp)))
-                 (prin1-char value))))
+            (if (and (characterp value)
+                     (char-displayable-p value))
+                (prin1-char value))))

         (if char-string
             (format " (#o%o, #x%x, %s)" value value char-string)
           (format " (#o%o, #x%x)" value value)))))
         (if char-string
             (format " (#o%o, #x%x, %s)" value value char-string)
           (format " (#o%o, #x%x)" value value)))))


@@ -1314,14 +1393,21 @@ display the result of expression evaluation."
 ;; for the sake of completion of names like eval-region, eval-buffer.
 (defun eval-expression (exp &optional insert-value)
   "Evaluate EXP and print value in the echo area.
 ;; for the sake of completion of names like eval-region, eval-buffer.
 (defun eval-expression (exp &optional insert-value)
   "Evaluate EXP and print value in the echo area.

-When called interactively, read an Emacs Lisp expression and
-evaluate it.
+When called interactively, read an Emacs Lisp expression and evaluate it.

 Value is also consed on to front of the variable `values'.
 Value is also consed on to front of the variable `values'.

-Optional argument INSERT-VALUE non-nil (interactively,
-with prefix argument) means insert the result into the current buffer
-instead of printing it in the echo area.  Truncates long output
-according to the value of the variables `eval-expression-print-length'
-and `eval-expression-print-level'.
+Optional argument INSERT-VALUE non-nil (interactively, with prefix
+argument) means insert the result into the current buffer instead of
+printing it in the echo area.
+
+Normally, this function truncates long output according to the value
+of the variables `eval-expression-print-length' and
+`eval-expression-print-level'.  With a prefix argument of zero,
+however, there is no such truncation.  Such a prefix argument
+also causes integers to be printed in several additional formats
+\(octal, hexadecimal, and character).
+
+Runs the hook `eval-expression-minibuffer-setup-hook' on entering the
+minibuffer.

 
 If `eval-expression-debug-on-error' is non-nil, which is the default,
 this command arranges for all errors to enter the debugger."
 
 If `eval-expression-debug-on-error' is non-nil, which is the default,
 this command arranges for all errors to enter the debugger."


@@ -1342,13 +1428,19 @@ this command arranges for all errors to enter the debugger."
       (unless (eq old-value new-value)
        (setq debug-on-error new-value))))
 
       (unless (eq old-value new-value)
        (setq debug-on-error new-value))))
 

-  (let ((print-length eval-expression-print-length)
-       (print-level eval-expression-print-level)
+  (let ((print-length (and (not (zerop (prefix-numeric-value insert-value)))
+                          eval-expression-print-length))
+       (print-level (and (not (zerop (prefix-numeric-value insert-value)))
+                         eval-expression-print-level))

         (deactivate-mark))
     (if insert-value
        (with-no-warnings
         (let ((standard-output (current-buffer)))
         (deactivate-mark))
     (if insert-value
        (with-no-warnings
         (let ((standard-output (current-buffer)))

-          (prin1 (car values))))
+          (prog1
+              (prin1 (car values))
+            (when (zerop (prefix-numeric-value insert-value))
+              (let ((str (eval-expression-print-format (car values))))
+                (if str (princ str)))))))

       (prog1
           (prin1 (car values) t)
         (let ((str (eval-expression-print-format (car values))))
       (prog1
           (prin1 (car values) t)
         (let ((str (eval-expression-print-format (car values))))


@@ -1477,13 +1569,11 @@ If the value is non-nil and not a number, we wait 2 seconds."
 (defun execute-extended-command (prefixarg &optional command-name)
   ;; Based on Fexecute_extended_command in keyboard.c of Emacs.
   ;; Aaron S. Hawley <aaron.s.hawley(at)gmail.com> 2009-08-24
 (defun execute-extended-command (prefixarg &optional command-name)
   ;; Based on Fexecute_extended_command in keyboard.c of Emacs.
   ;; Aaron S. Hawley <aaron.s.hawley(at)gmail.com> 2009-08-24

-  "Read function name, then read its arguments and call it.
-
-To pass a numeric argument to the command you are invoking, specify
-the numeric argument to this command.
-
+  "Read a command name, then read the arguments and call the command.
+Interactively, to pass a prefix argument to the command you are
+invoking, give a prefix argument to `execute-extended-command'.

 Noninteractively, the argument PREFIXARG is the prefix argument to
 Noninteractively, the argument PREFIXARG is the prefix argument to

-give to the command you invoke, if it asks for an argument."
+give to the command you invoke."

   (interactive (list current-prefix-arg (read-extended-command)))
   ;; Emacs<24 calling-convention was with a single `prefixarg' argument.
   (if (null command-name)
   (interactive (list current-prefix-arg (read-extended-command)))
   ;; Emacs<24 calling-convention was with a single `prefixarg' argument.
   (if (null command-name)


@@ -1538,36 +1628,37 @@ a special event, so ignore the prefix argument and don't clear it."
                      (prog1 prefix-arg
                        (setq current-prefix-arg prefix-arg)
                        (setq prefix-arg nil)))))
                      (prog1 prefix-arg
                        (setq current-prefix-arg prefix-arg)
                        (setq prefix-arg nil)))))

-    (and (symbolp cmd)
-         (get cmd 'disabled)
-         ;; FIXME: Weird calling convention!
-         (run-hooks 'disabled-command-function))
-    (let ((final cmd))
-      (while
-          (progn
-            (setq final (indirect-function final))
-            (if (autoloadp final)
-                (setq final (autoload-do-load final cmd)))))
-      (cond
-       ((arrayp final)
-        ;; If requested, place the macro in the command history.  For
-        ;; other sorts of commands, call-interactively takes care of this.
-        (when record-flag
-          (push `(execute-kbd-macro ,final ,prefixarg) command-history)
-          ;; Don't keep command history around forever.
-          (when (and (numberp history-length) (> history-length 0))
-            (let ((cell (nthcdr history-length command-history)))
-              (if (consp cell) (setcdr cell nil)))))
-        (execute-kbd-macro final prefixarg))
-       (t
-        ;; Pass `cmd' rather than `final', for the backtrace's sake.
-        (prog1 (call-interactively cmd record-flag keys)
-          (when (and (symbolp cmd)
-                     (get cmd 'byte-obsolete-info)
-                     (not (get cmd 'command-execute-obsolete-warned)))
-            (put cmd 'command-execute-obsolete-warned t)
-            (message "%s" (macroexp--obsolete-warning
-                           cmd (get cmd 'byte-obsolete-info) "command")))))))))
+    (if (and (symbolp cmd)
+             (get cmd 'disabled)
+             disabled-command-function)
+        ;; FIXME: Weird calling convention!
+        (run-hooks 'disabled-command-function)
+      (let ((final cmd))
+        (while
+            (progn
+              (setq final (indirect-function final))
+              (if (autoloadp final)
+                  (setq final (autoload-do-load final cmd)))))
+        (cond
+         ((arrayp final)
+          ;; If requested, place the macro in the command history.  For
+          ;; other sorts of commands, call-interactively takes care of this.
+          (when record-flag
+            (push `(execute-kbd-macro ,final ,prefixarg) command-history)
+            ;; Don't keep command history around forever.
+            (when (and (numberp history-length) (> history-length 0))
+              (let ((cell (nthcdr history-length command-history)))
+                (if (consp cell) (setcdr cell nil)))))
+          (execute-kbd-macro final prefixarg))
+         (t
+          ;; Pass `cmd' rather than `final', for the backtrace's sake.
+          (prog1 (call-interactively cmd record-flag keys)
+            (when (and (symbolp cmd)
+                       (get cmd 'byte-obsolete-info)
+                       (not (get cmd 'command-execute-obsolete-warned)))
+              (put cmd 'command-execute-obsolete-warned t)
+              (message "%s" (macroexp--obsolete-warning
+                             cmd (get cmd 'byte-obsolete-info) "command"))))))))))

 \f
 (defvar minibuffer-history nil
   "Default minibuffer history list.
 \f
 (defvar minibuffer-history nil
   "Default minibuffer history list.


@@ -2052,7 +2143,12 @@ as an argument limits undo to changes within the current region."
       ;; above when checking.
       (while (eq (car list) nil)
        (setq list (cdr list)))
       ;; above when checking.
       (while (eq (car list) nil)
        (setq list (cdr list)))

-      (puthash list (if undo-in-region t pending-undo-list)
+      (puthash list
+               ;; Prevent identity mapping.  This can happen if
+               ;; consecutive nils are erroneously in undo list.
+               (if (or undo-in-region (eq list pending-undo-list))
+                   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.
               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.


@@ -2199,20 +2295,38 @@ Return what remains of the list."
            (when (let ((apos (abs pos)))
                    (or (< apos (point-min)) (> apos (point-max))))
              (error "Changes to be undone are outside visible portion of buffer"))
            (when (let ((apos (abs pos)))
                    (or (< apos (point-min)) (> apos (point-max))))
              (error "Changes to be undone are outside visible portion of buffer"))

-           (if (< pos 0)
-               (progn
-                 (goto-char (- pos))
-                 (insert string))
-             (goto-char pos)
-             ;; Now that we record marker adjustments
-             ;; (caused by deletion) for undo,
-             ;; we should always insert after markers,
-             ;; so that undoing the marker adjustments
-             ;; put the markers back in the right place.
-             (insert string)
-             (goto-char pos)))
+           (let (valid-marker-adjustments)
+             ;; Check that marker adjustments which were recorded
+             ;; with the (STRING . POS) record are still valid, ie
+             ;; the markers haven't moved.  We check their validity
+             ;; before reinserting the string so as we don't need to
+             ;; mind marker insertion-type.
+             (while (and (markerp (car-safe (car list)))
+                         (integerp (cdr-safe (car list))))
+               (let* ((marker-adj (pop list))
+                      (m (car marker-adj)))
+                 (and (eq (marker-buffer m) (current-buffer))
+                      (= pos m)
+                      (push marker-adj valid-marker-adjustments))))
+             ;; Insert string and adjust point
+             (if (< pos 0)
+                 (progn
+                   (goto-char (- pos))
+                   (insert string))
+               (goto-char pos)
+               (insert string)
+               (goto-char pos))
+             ;; Adjust the valid marker adjustments
+             (dolist (adj valid-marker-adjustments)
+               (set-marker (car adj)
+                           (- (car adj) (cdr adj))))))

           ;; (MARKER . OFFSET) means a marker MARKER was adjusted by OFFSET.
           (`(,(and marker (pred markerp)) . ,(and offset (pred integerp)))
           ;; (MARKER . OFFSET) means a marker MARKER was adjusted by OFFSET.
           (`(,(and marker (pred markerp)) . ,(and offset (pred integerp)))

+           (warn "Encountered %S entry in undo list with no matching (TEXT . POS) entry"
+                 next)
+           ;; Even though these elements are not expected in the undo
+           ;; list, adjust them to be conservative for the 24.4
+           ;; release.  (Bug#16818)

            (when (marker-buffer marker)
              (set-marker marker
                          (- marker offset)
            (when (marker-buffer marker)
              (set-marker marker
                          (- marker offset)


@@ -2251,8 +2365,6 @@ are ignored.  If BEG and END are nil, all undo elements are used."
            (undo-make-selective-list (min beg end) (max beg end))
          buffer-undo-list)))
 
            (undo-make-selective-list (min beg end) (max beg end))
          buffer-undo-list)))
 

-(defvar undo-adjusted-markers)
-

 (defun undo-make-selective-list (start end)
   "Return a list of undo elements for the region START to END.
 The elements come from `buffer-undo-list', but we keep only
 (defun undo-make-selective-list (start end)
   "Return a list of undo elements for the region START to END.
 The elements come from `buffer-undo-list', but we keep only


@@ -2261,7 +2373,6 @@ If we find an element that crosses an edge of this region,
 we stop and ignore all further elements."
   (let ((undo-list-copy (undo-copy-list buffer-undo-list))
        (undo-list (list nil))
 we stop and ignore all further elements."
   (let ((undo-list-copy (undo-copy-list buffer-undo-list))
        (undo-list (list nil))

-       undo-adjusted-markers

        some-rejected
        undo-elt temp-undo-list delta)
     (while undo-list-copy
        some-rejected
        undo-elt temp-undo-list delta)
     (while undo-list-copy


@@ -2271,15 +2382,30 @@ we stop and ignore all further elements."
                    ;; This is a "was unmodified" element.
                    ;; Keep it if we have kept everything thus far.
                    (not some-rejected))
                    ;; This is a "was unmodified" element.
                    ;; Keep it if we have kept everything thus far.
                    (not some-rejected))

+                   ;; Skip over marker adjustments, instead relying on
+                   ;; finding them after (TEXT . POS) elements
+                   ((markerp (car-safe undo-elt))
+                    nil)

                   (t
                    (undo-elt-in-region undo-elt start end)))))
        (if keep-this
            (progn
              (setq end (+ end (cdr (undo-delta undo-elt))))
              ;; Don't put two nils together in the list
                   (t
                    (undo-elt-in-region undo-elt start end)))))
        (if keep-this
            (progn
              (setq end (+ end (cdr (undo-delta undo-elt))))
              ;; Don't put two nils together in the list

-             (if (not (and (eq (car undo-list) nil)
-                           (eq undo-elt nil)))
-                 (setq undo-list (cons undo-elt undo-list))))
+             (when (not (and (eq (car undo-list) nil)
+                              (eq undo-elt nil)))
+                (setq undo-list (cons undo-elt undo-list))
+                ;; If (TEXT . POS), "keep" its subsequent (MARKER
+                ;; . ADJUSTMENT) whose markers haven't moved.
+                (when (and (stringp (car-safe undo-elt))
+                           (integerp (cdr-safe undo-elt)))
+                  (let ((list-i (cdr undo-list-copy)))
+                    (while (markerp (car-safe (car list-i)))
+                      (let* ((adj-elt (pop list-i))
+                             (m (car adj-elt)))
+                        (and (eq (marker-buffer m) (current-buffer))
+                             (= (cdr undo-elt) m)
+                             (push adj-elt undo-list))))))))

          (if (undo-elt-crosses-region undo-elt start end)
              (setq undo-list-copy nil)
            (setq some-rejected t)
          (if (undo-elt-crosses-region undo-elt start end)
              (setq undo-list-copy nil)
            (setq some-rejected t)


@@ -2327,7 +2453,12 @@ we stop and ignore all further elements."
 
 (defun undo-elt-in-region (undo-elt start end)
   "Determine whether UNDO-ELT falls inside the region START ... END.
 
 (defun undo-elt-in-region (undo-elt start end)
   "Determine whether UNDO-ELT falls inside the region START ... END.

-If it crosses the edge, we return nil."
+If it crosses the edge, we return nil.
+
+Generally this function is not useful for determining
+whether (MARKER . ADJUSTMENT) undo elements are in the region,
+because markers can be arbitrarily relocated.  Instead, pass the
+marker adjustment's corresponding (TEXT . POS) element."

   (cond ((integerp undo-elt)
         (and (>= undo-elt start)
              (<= undo-elt end)))
   (cond ((integerp undo-elt)
         (and (>= undo-elt start)
              (<= undo-elt end)))


@@ -2338,19 +2469,10 @@ If it crosses the edge, we return nil."
        ((stringp (car undo-elt))
         ;; (TEXT . POSITION)
         (and (>= (abs (cdr undo-elt)) start)
        ((stringp (car undo-elt))
         ;; (TEXT . POSITION)
         (and (>= (abs (cdr undo-elt)) start)

-             (< (abs (cdr undo-elt)) end)))
+             (<= (abs (cdr undo-elt)) end)))

        ((and (consp undo-elt) (markerp (car undo-elt)))
        ((and (consp undo-elt) (markerp (car undo-elt)))

-        ;; This is a marker-adjustment element (MARKER . ADJUSTMENT).
-        ;; See if MARKER is inside the region.
-        (let ((alist-elt (assq (car undo-elt) undo-adjusted-markers)))
-          (unless alist-elt
-            (setq alist-elt (cons (car undo-elt)
-                                  (marker-position (car undo-elt))))
-            (setq undo-adjusted-markers
-                  (cons alist-elt undo-adjusted-markers)))
-          (and (cdr alist-elt)
-               (>= (cdr alist-elt) start)
-               (<= (cdr alist-elt) end))))
+        ;; (MARKER . ADJUSTMENT)
+         (<= start (car undo-elt) end))

        ((null (car undo-elt))
         ;; (nil PROPERTY VALUE BEG . END)
         (let ((tail (nthcdr 3 undo-elt)))
        ((null (car undo-elt))
         ;; (nil PROPERTY VALUE BEG . END)
         (let ((tail (nthcdr 3 undo-elt)))


@@ -2463,6 +2585,61 @@ which is defined in the `warnings' library.\n")
     (setq buffer-undo-list nil)
     t))
 \f
     (setq buffer-undo-list nil)
     t))
 \f

+(defcustom password-word-equivalents
+  '("password" "passphrase" "pass phrase"
+    ; These are sorted according to the GNU en_US locale.
+    "암호"           ; ko
+    "パスワード"  ; ja
+    "ପ୍ରବେଶ ସଙ୍କେତ"    ; or
+    "ពាក្យសម្ងាត់"             ; km
+    "adgangskode"      ; da
+    "contraseña"      ; es
+    "contrasenya"      ; ca
+    "geslo"            ; sl
+    "hasło"           ; pl
+    "heslo"            ; cs, sk
+    "iphasiwedi"       ; zu
+    "jelszó"          ; hu
+    "lösenord"                ; sv
+    "lozinka"          ; hr, sr
+    "mật khẩu"             ; vi
+    "mot de passe"     ; fr
+    "parola"           ; tr
+    "pasahitza"                ; eu
+    "passord"          ; nb
+    "passwort"         ; de
+    "pasvorto"         ; eo
+    "salasana"         ; fi
+    "senha"            ; pt
+    "slaptažodis"     ; lt
+    "wachtwoord"       ; nl
+    "كلمة السر"                ; ar
+    "ססמה"         ; he
+    "лозинка"           ; sr
+    "пароль"             ; kk, ru, uk
+    "गुप्तशब्द"              ; mr
+    "शब्दकूट"            ; hi
+    "પાસવર્ડ"            ; gu
+    "సంకేతపదము"              ; te
+    "ਪਾਸਵਰਡ"               ; pa
+    "ಗುಪ್ತಪದ"            ; kn
+    "கடவுச்சொல்"           ; ta
+    "അടയാളവാക്ക്"                ; ml
+    "গুপ্তশব্দ"              ; as
+    "পাসওয়ার্ড"              ; bn_IN
+    "රහස්පදය"            ; si
+    "密码"           ; zh_CN
+    "密碼"           ; zh_TW
+    )
+  "List of words equivalent to \"password\".
+This is used by Shell mode and other parts of Emacs to recognize
+password prompts, including prompts in languages other than
+English.  Different case choices should not be assumed to be
+included; callers should bind `case-fold-search' to t."
+  :type '(repeat string)
+  :version "24.4"
+  :group 'processes)
+

 (defvar shell-command-history nil
   "History list for some commands that read shell commands.
 
 (defvar shell-command-history nil
   "History list for some commands that read shell commands.
 


@@ -2560,6 +2737,12 @@ to execute it asynchronously.
 The output appears in the buffer `*Async Shell Command*'.
 That buffer is in shell mode.
 
 The output appears in the buffer `*Async Shell Command*'.
 That buffer is in shell mode.
 

+You can configure `async-shell-command-buffer' to specify what to do in
+case when `*Async Shell Command*' buffer is already taken by another
+running shell command.  To run COMMAND without displaying the output
+in a window you can configure `display-buffer-alist' to use the action
+`display-buffer-no-window' for the buffer `*Async Shell Command*'.
+

 In Elisp, you will often be better served by calling `start-process'
 directly, since it offers more control and does not impose the use of a
 shell (with its need to quote arguments)."
 In Elisp, you will often be better served by calling `start-process'
 directly, since it offers more control and does not impose the use of a
 shell (with its need to quote arguments)."


@@ -2746,7 +2929,7 @@ the use of a shell (with its need to quote arguments)."
                  ;; which comint sometimes adds for prompts.
                  (let ((inhibit-read-only t))
                    (erase-buffer))
                  ;; which comint sometimes adds for prompts.
                  (let ((inhibit-read-only t))
                    (erase-buffer))

-                 (display-buffer buffer)
+                 (display-buffer buffer '(nil (allow-no-window . t)))

                  (setq default-directory directory)
                  (setq proc (start-process "Shell" buffer shell-file-name
                                            shell-command-switch command))
                  (setq default-directory directory)
                  (setq proc (start-process "Shell" buffer shell-file-name
                                            shell-command-switch command))


@@ -3035,9 +3218,9 @@ subprocess is `default-directory'.
 
 File names in INFILE and BUFFER are handled normally, but file
 names in ARGS should be relative to `default-directory', as they
 
 File names in INFILE and BUFFER are handled normally, but file
 names in ARGS should be relative to `default-directory', as they

-are passed to the process verbatim.  \(This is a difference to
+are passed to the process verbatim.  (This is a difference to

 `call-process' which does not support file handlers for INFILE
 `call-process' which does not support file handlers for INFILE

-and BUFFER.\)
+and BUFFER.)

 
 Some file handlers might not support all variants, for example
 they might behave as if DISPLAY was nil, regardless of the actual
 
 Some file handlers might not support all variants, for example
 they might behave as if DISPLAY was nil, regardless of the actual


@@ -3224,7 +3407,7 @@ see other processes running on the system, use `list-system-processes'."
   "Keymap used while processing \\[universal-argument].")
 
 (defun universal-argument--mode ()
   "Keymap used while processing \\[universal-argument].")
 
 (defun universal-argument--mode ()

-  (set-temporary-overlay-map universal-argument-map))
+  (set-transient-map universal-argument-map))

 
 (defun universal-argument ()
   "Begin a numeric argument for the following command.
 
 (defun universal-argument ()
   "Begin a numeric argument for the following command.


@@ -3319,7 +3502,6 @@ extract characters that are special to a buffer, and should not
 be copied into other buffers."
   (funcall filter-buffer-substring-function beg end delete))
 
 be copied into other buffers."
   (funcall filter-buffer-substring-function beg end delete))
 

-;; FIXME: `with-wrapper-hook' is obsolete

 (defun buffer-substring--filter (beg end &optional delete)
   (with-wrapper-hook filter-buffer-substring-functions (beg end delete)
     (cond
 (defun buffer-substring--filter (beg end &optional delete)
   (with-wrapper-hook filter-buffer-substring-functions (beg end delete)
     (cond


@@ -3417,7 +3599,7 @@ The comparison is done using `equal-including-properties'."
   :group 'killing
   :version "23.2")
 
   :group 'killing
   :version "23.2")
 

-(defun kill-new (string &optional replace yank-handler)
+(defun kill-new (string &optional replace)

   "Make STRING the latest kill in the kill ring.
 Set `kill-ring-yank-pointer' to point to it.
 If `interprogram-cut-function' is non-nil, apply it to STRING.
   "Make STRING the latest kill in the kill ring.
 Set `kill-ring-yank-pointer' to point to it.
 If `interprogram-cut-function' is non-nil, apply it to STRING.


@@ -3432,13 +3614,6 @@ 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
 argument should still be a \"useful\" string for such uses."
 argument is not used by `insert-for-yank'.  However, since Lisp code
 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
-         (put-text-property 0 (length string)
-                            'yank-handler yank-handler string))
-    (if yank-handler
-       (signal 'args-out-of-range
-               (list string "yank-handler specified for empty string"))))

   (unless (and kill-do-not-save-duplicates
               ;; Due to text properties such as 'yank-handler that
               ;; can alter the contents to yank, comparison using
   (unless (and kill-do-not-save-duplicates
               ;; Due to text properties such as 'yank-handler that
               ;; can alter the contents to yank, comparison using


@@ -3466,19 +3641,15 @@ argument should still be a \"useful\" string for such uses."
   (setq kill-ring-yank-pointer kill-ring)
   (if interprogram-cut-function
       (funcall interprogram-cut-function string)))
   (setq kill-ring-yank-pointer kill-ring)
   (if interprogram-cut-function
       (funcall interprogram-cut-function string)))

-(set-advertised-calling-convention
- 'kill-new '(string &optional replace) "23.3")

 
 

-(defun kill-append (string before-p &optional yank-handler)
+(defun kill-append (string before-p)

   "Append STRING to the end of the latest kill in the kill ring.
 If BEFORE-P is non-nil, prepend STRING to the kill.
 If `interprogram-cut-function' is set, pass the resulting kill to it."
   (let* ((cur (car kill-ring)))
     (kill-new (if before-p (concat string cur) (concat cur string))
              (or (= (length cur) 0)
   "Append STRING to the end of the latest kill in the kill ring.
 If BEFORE-P is non-nil, prepend STRING to the kill.
 If `interprogram-cut-function' is set, pass the resulting kill to it."
   (let* ((cur (car kill-ring)))
     (kill-new (if before-p (concat string cur) (concat cur string))
              (or (= (length cur) 0)

-                 (equal yank-handler (get-text-property 0 'yank-handler cur)))
-             yank-handler)))
-(set-advertised-calling-convention 'kill-append '(string before-p) "23.3")
+                 (equal nil (get-text-property 0 'yank-handler cur))))))

 
 (defcustom yank-pop-change-selection nil
   "Whether rotating the kill ring changes the window system selection.
 
 (defcustom yank-pop-change-selection nil
   "Whether rotating the kill ring changes the window system selection.


@@ -3539,7 +3710,7 @@ move the yanking point; just return the Nth kill forward."
   :type 'boolean
   :group 'killing)
 
   :type 'boolean
   :group 'killing)
 

-(defun kill-region (beg end &optional yank-handler)
+(defun kill-region (beg end &optional region)

   "Kill (\"cut\") text between point and mark.
 This deletes the text from the buffer and saves it in the kill ring.
 The command \\[yank] can retrieve it from there.
   "Kill (\"cut\") text between point and mark.
 This deletes the text from the buffer and saves it in the kill ring.
 The command \\[yank] can retrieve it from there.


@@ -3559,19 +3730,24 @@ Supply two arguments, character positions indicating the stretch of text
 Any command that calls this function is a \"kill command\".
 If the previous command was also a kill command,
 the text killed this time appends to the text killed last time
 Any command that calls this function is a \"kill command\".
 If the previous command was also a kill command,
 the text killed this time appends to the text killed last time

-to make one entry in the kill ring."
-  ;; Pass point first, then mark, because the order matters
-  ;; when calling kill-append.
-  (interactive (list (point) (mark)))
+to make one entry in the kill ring.
+
+The optional argument REGION if non-nil, indicates that we're not just killing
+some text between BEG and END, but we're killing the region."
+  ;; Pass mark first, then point, because the order matters when
+  ;; calling `kill-append'.
+  (interactive (list (mark) (point) 'region))

   (unless (and beg end)
     (error "The mark is not set now, so there is no region"))
   (condition-case nil
   (unless (and beg end)
     (error "The mark is not set now, so there is no region"))
   (condition-case nil

-      (let ((string (filter-buffer-substring beg end t)))
+      (let ((string (if region
+                        (funcall region-extract-function 'delete)
+                      (filter-buffer-substring beg end 'delete))))

        (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)
        (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)

-             (kill-append string (< end beg) yank-handler)
-           (kill-new string nil yank-handler)))
+             (kill-append string (< end beg))
+           (kill-new string nil)))

        (when (or string (eq last-command 'kill-region))
          (setq this-command 'kill-region))
        (setq deactivate-mark t)
        (when (or string (eq last-command 'kill-region))
          (setq this-command 'kill-region))
        (setq deactivate-mark t)


@@ -3582,7 +3758,7 @@ to make one entry in the kill ring."
      ;; We should beep, in case the user just isn't aware of this.
      ;; However, there's no harm in putting
      ;; the region's text in the kill ring, anyway.
      ;; We should beep, in case the user just isn't aware of this.
      ;; However, there's no harm in putting
      ;; the region's text in the kill ring, anyway.

-     (copy-region-as-kill beg end)
+     (copy-region-as-kill beg end region)

      ;; Set this-command now, so it will be set even if we get an error.
      (setq this-command 'kill-region)
      ;; This should barf, if appropriate, and give us the correct error.
      ;; Set this-command now, so it will be set even if we get an error.
      (setq this-command 'kill-region)
      ;; This should barf, if appropriate, and give us the correct error.


@@ -3592,26 +3768,34 @@ to make one entry in the kill ring."
        (barf-if-buffer-read-only)
        ;; If the buffer isn't read-only, the text is.
        (signal 'text-read-only (list (current-buffer)))))))
        (barf-if-buffer-read-only)
        ;; If the buffer isn't read-only, the text is.
        (signal 'text-read-only (list (current-buffer)))))))

-(set-advertised-calling-convention 'kill-region '(beg end) "23.3")

 
 ;; copy-region-as-kill no longer sets this-command, because it's confusing
 ;; to get two copies of the text when the user accidentally types M-w and
 ;; then corrects it with the intended C-w.
 
 ;; copy-region-as-kill no longer sets this-command, because it's confusing
 ;; to get two copies of the text when the user accidentally types M-w and
 ;; then corrects it with the intended C-w.

-(defun copy-region-as-kill (beg end)
+(defun copy-region-as-kill (beg end &optional region)

   "Save the region as if killed, but don't kill it.
 In Transient Mark mode, deactivate the mark.
 If `interprogram-cut-function' is non-nil, also save the text for a window
 system cut and paste.
 
   "Save the region as if killed, but don't kill it.
 In Transient Mark mode, deactivate the mark.
 If `interprogram-cut-function' is non-nil, also save the text for a window
 system cut and paste.
 

+The optional argument REGION if non-nil, indicates that we're not just copying
+some text between BEG and END, but we're copying the region.
+

 This command's old key binding has been given to `kill-ring-save'."
 This command's old key binding has been given to `kill-ring-save'."

-  (interactive "r")
+  ;; Pass mark first, then point, because the order matters when
+  ;; calling `kill-append'.
+  (interactive (list (mark) (point)
+                    (prefix-numeric-value current-prefix-arg)))
+  (let ((str (if region
+                 (funcall region-extract-function nil)
+               (filter-buffer-substring beg end))))

   (if (eq last-command 'kill-region)
   (if (eq last-command 'kill-region)

-      (kill-append (filter-buffer-substring beg end) (< end beg))
-    (kill-new (filter-buffer-substring beg end)))
+        (kill-append str (< end beg))
+      (kill-new str)))

   (setq deactivate-mark t)
   nil)
 
   (setq deactivate-mark t)
   nil)
 

-(defun kill-ring-save (beg end)
+(defun kill-ring-save (beg end &optional region)

   "Save the region as if killed, but don't kill it.
 In Transient Mark mode, deactivate the mark.
 If `interprogram-cut-function' is non-nil, also save the text for a window
   "Save the region as if killed, but don't kill it.
 In Transient Mark mode, deactivate the mark.
 If `interprogram-cut-function' is non-nil, also save the text for a window


@@ -3620,10 +3804,16 @@ system cut and paste.
 If you want to append the killed line to the last killed text,
 use \\[append-next-kill] before \\[kill-ring-save].
 
 If you want to append the killed line to the last killed text,
 use \\[append-next-kill] before \\[kill-ring-save].
 

+The optional argument REGION if non-nil, indicates that we're not just copying
+some text between BEG and END, but we're copying the region.
+

 This command is similar to `copy-region-as-kill', except that it gives
 visual feedback indicating the extent of the region being copied."
 This command is similar to `copy-region-as-kill', except that it gives
 visual feedback indicating the extent of the region being copied."

-  (interactive "r")
-  (copy-region-as-kill beg end)
+  ;; Pass mark first, then point, because the order matters when
+  ;; calling `kill-append'.
+  (interactive (list (mark) (point)
+                    (prefix-numeric-value current-prefix-arg)))
+  (copy-region-as-kill beg end region)

   ;; This use of called-interactively-p is correct because the code it
   ;; controls just gives the user visual feedback.
   (if (called-interactively-p 'interactive)
   ;; This use of called-interactively-p is correct because the code it
   ;; controls just gives the user visual feedback.
   (if (called-interactively-p 'interactive)


@@ -3670,7 +3860,17 @@ of this sample text; it defaults to 40."
                   (buffer-substring-no-properties mark (+ mark len))))))))
 
 (defun append-next-kill (&optional interactive)
                   (buffer-substring-no-properties mark (+ mark len))))))))
 
 (defun append-next-kill (&optional interactive)

-  "Cause following command, if it kills, to append to previous kill.
+  "Cause following command, if it kills, to add to previous kill.
+If the next command kills forward from point, the kill is
+appended to the previous killed text.  If the command kills
+backward, the kill is prepended.  Kill commands that act on the
+region, such as `kill-region', are regarded as killing forward if
+point is after mark, and killing backward if point is before
+mark.
+
+If the next command is not a kill command, `append-next-kill' has
+no effect.
+

 The argument is used for internal purposes; do not supply one."
   (interactive "p")
   ;; We don't use (interactive-p), since that breaks kbd macros.
 The argument is used for internal purposes; do not supply one."
   (interactive "p")
   ;; We don't use (interactive-p), since that breaks kbd macros.


@@ -3697,6 +3897,8 @@ end positions of the text.
 This is done prior to removing the properties specified by
 `yank-excluded-properties'."
   :group 'killing
 This is done prior to removing the properties specified by
 `yank-excluded-properties'."
   :group 'killing

+  :type '(repeat (cons (symbol :tag "property symbol")
+                       function))

   :version "24.3")
 
 ;; This is actually used in subr.el but defcustom does not work there.
   :version "24.3")
 
 ;; This is actually used in subr.el but defcustom does not work there.


@@ -3938,7 +4140,7 @@ even beep.)"
   "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.
   "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 \\[repeat] 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")
   (or arg (setq arg 1))
 If ARG is zero, kill current line but exclude the trailing newline."
   (interactive "p")
   (or arg (setq arg 1))


@@ -4089,6 +4291,7 @@ Don't call it from programs: use `insert-buffer-substring' instead!"
      (insert-buffer-substring (get-buffer buffer))
      (point)))
   nil)
      (insert-buffer-substring (get-buffer buffer))
      (point)))
   nil)

+(put 'insert-buffer 'interactive-only 'insert-buffer-substring)

 
 (defun append-to-buffer (buffer start end)
   "Append to specified buffer the text of the region.
 
 (defun append-to-buffer (buffer start end)
   "Append to specified buffer the text of the region.


@@ -4203,8 +4406,8 @@ run `deactivate-mark-hook'."
                  (or (x-selection-owner-p 'PRIMARY)
                      (null (x-selection-exists-p 'PRIMARY))))
             (x-set-selection 'PRIMARY
                  (or (x-selection-owner-p 'PRIMARY)
                      (null (x-selection-exists-p 'PRIMARY))))
             (x-set-selection 'PRIMARY

-                             (buffer-substring (region-beginning)
-                                               (region-end))))))
+                              (funcall region-extract-function nil)))))
+    (when mark-active (force-mode-line-update)) ;Refresh toolbar (bug#16382).

     (if (and (null force)
             (or (eq transient-mark-mode 'lambda)
                 (and (eq (car-safe transient-mark-mode) 'only)
     (if (and (null force)
             (or (eq transient-mark-mode 'lambda)
                 (and (eq (car-safe transient-mark-mode) 'only)


@@ -4215,15 +4418,19 @@ run `deactivate-mark-hook'."
       (if (eq (car-safe transient-mark-mode) 'only)
          (setq transient-mark-mode (cdr transient-mark-mode)))
       (setq mark-active nil)
       (if (eq (car-safe transient-mark-mode) 'only)
          (setq transient-mark-mode (cdr transient-mark-mode)))
       (setq mark-active nil)

-      (run-hooks 'deactivate-mark-hook))))
+      (run-hooks 'deactivate-mark-hook))
+    (redisplay--update-region-highlight (selected-window))))

 
 

-(defun activate-mark ()
-  "Activate the mark."
+(defun activate-mark (&optional no-tmm)
+  "Activate the mark.
+If NO-TMM is non-nil, leave `transient-mark-mode' alone."

   (when (mark t)
   (when (mark t)

-    (setq mark-active t)
-    (unless transient-mark-mode
-      (setq transient-mark-mode 'lambda))
-    (run-hooks 'activate-mark-hook)))
+    (unless (region-active-p)
+      (force-mode-line-update) ;Refresh toolbar (bug#16382).
+      (setq mark-active t)
+      (unless (or transient-mark-mode no-tmm)
+        (setq transient-mark-mode 'lambda))
+      (run-hooks 'activate-mark-hook))))

 
 (defun set-mark (pos)
   "Set this buffer's mark to POS.  Don't use this function!
 
 (defun set-mark (pos)
   "Set this buffer's mark to POS.  Don't use this function!


@@ -4241,16 +4448,17 @@ To remember a location for internal use in the Lisp program,
 store it in a Lisp variable.  Example:
 
    (let ((beg (point))) (forward-line 1) (delete-region beg (point)))."
 store it in a Lisp variable.  Example:
 
    (let ((beg (point))) (forward-line 1) (delete-region beg (point)))."

-

   (if pos
       (progn
   (if pos
       (progn

-       (setq mark-active t)
-       (run-hooks 'activate-mark-hook)
-       (set-marker (mark-marker) pos (current-buffer)))
+        (set-marker (mark-marker) pos (current-buffer))
+        (activate-mark 'no-tmm))

     ;; Normally we never clear mark-active except in Transient Mark mode.
     ;; But when we actually clear out the mark value too, we must
     ;; clear mark-active in any mode.
     (deactivate-mark t)
     ;; Normally we never clear mark-active except in Transient Mark mode.
     ;; But when we actually clear out the mark value too, we must
     ;; clear mark-active in any mode.
     (deactivate-mark t)

+    ;; `deactivate-mark' sometimes leaves mark-active non-nil, but
+    ;; it should never be nil if the mark is nil.
+    (setq mark-active nil)

     (set-marker (mark-marker) nil)))
 
 (defcustom use-empty-active-region nil
     (set-marker (mark-marker) nil)))
 
 (defcustom use-empty-active-region nil


@@ -4287,11 +4495,72 @@ Some commands act specially on the region when Transient Mark
 mode is enabled.  Usually, such commands should use
 `use-region-p' instead of this function, because `use-region-p'
 also checks the value of `use-empty-active-region'."
 mode is enabled.  Usually, such commands should use
 `use-region-p' instead of this function, because `use-region-p'
 also checks the value of `use-empty-active-region'."

-  (and transient-mark-mode mark-active))
-
-(defvar mark-ring nil
+  (and transient-mark-mode mark-active
+       ;; FIXME: Somehow we sometimes end up with mark-active non-nil but
+       ;; without the mark being set (e.g. bug#17324).  We really should fix
+       ;; that problem, but in the mean time, let's make sure we don't say the
+       ;; region is active when there's no mark.
+       (mark)))
+
+
+(defvar redisplay-unhighlight-region-function
+  (lambda (rol) (when (overlayp rol) (delete-overlay rol))))
+
+(defvar redisplay-highlight-region-function
+  (lambda (start end window rol)
+    (if (not (overlayp rol))
+        (let ((nrol (make-overlay start end)))
+          (funcall redisplay-unhighlight-region-function rol)
+          (overlay-put nrol 'window window)
+          (overlay-put nrol 'face 'region)
+          ;; Normal priority so that a large region doesn't hide all the
+          ;; overlays within it, but high secondary priority so that if it
+          ;; ends/starts in the middle of a small overlay, that small overlay
+          ;; won't hide the region's boundaries.
+          (overlay-put nrol 'priority '(nil . 100))
+          nrol)
+      (unless (and (eq (overlay-buffer rol) (current-buffer))
+                   (eq (overlay-start rol) start)
+                   (eq (overlay-end rol) end))
+        (move-overlay rol start end (current-buffer)))
+      rol)))
+
+(defun redisplay--update-region-highlight (window)
+  (with-current-buffer (window-buffer window)
+    (let ((rol (window-parameter window 'internal-region-overlay)))
+      (if (not (region-active-p))
+          (funcall redisplay-unhighlight-region-function rol)
+        (let* ((pt (window-point window))
+               (mark (mark))
+               (start (min pt mark))
+               (end   (max pt mark))
+               (new
+                (funcall redisplay-highlight-region-function
+                         start end window rol)))
+          (unless (equal new rol)
+            (set-window-parameter window 'internal-region-overlay
+                                  new)))))))
+
+(defun redisplay--update-region-highlights (windows)
+  (with-demoted-errors "redisplay--update-region-highlights: %S"
+    (if (null windows)
+        (redisplay--update-region-highlight (selected-window))
+      (unless (listp windows) (setq windows (window-list-1 nil nil t)))
+      (if highlight-nonselected-windows
+          (mapc #'redisplay--update-region-highlight windows)
+        (let ((msw (and (window-minibuffer-p) (minibuffer-selected-window))))
+          (dolist (w windows)
+            (if (or (eq w (selected-window)) (eq w msw))
+                (redisplay--update-region-highlight w)
+              (funcall redisplay-unhighlight-region-function
+                       (window-parameter w 'internal-region-overlay)))))))))
+
+(add-function :before pre-redisplay-function
+              #'redisplay--update-region-highlights)
+
+
+(defvar-local mark-ring nil

   "The list of former marks of the current buffer, most recent first.")
   "The list of former marks of the current buffer, most recent first.")

-(make-variable-buffer-local 'mark-ring)

 (put 'mark-ring 'permanent-local t)
 
 (defcustom mark-ring-max 16
 (put 'mark-ring 'permanent-local t)
 
 (defcustom mark-ring-max 16


@@ -4310,7 +4579,7 @@ Start discarding off end if gets this big."
 
 (defun pop-to-mark-command ()
   "Jump to mark, and pop a new position for mark off the ring.
 
 (defun pop-to-mark-command ()
   "Jump to mark, and pop a new position for mark off the ring.

-\(Does not affect global mark ring\)."
+\(Does not affect global mark ring)."

   (interactive)
   (if (null (mark t))
       (error "No mark set in this buffer")
   (interactive)
   (if (null (mark t))
       (error "No mark set in this buffer")


@@ -4324,11 +4593,10 @@ Start discarding off end if gets this big."
 If no prefix ARG and mark is already set there, just activate it.
 Display `Mark set' unless the optional second arg NOMSG is non-nil."
   (interactive "P")
 If no prefix ARG and mark is already set there, just activate it.
 Display `Mark set' unless the optional second arg NOMSG is non-nil."
   (interactive "P")

-  (let ((mark (marker-position (mark-marker))))
+  (let ((mark (mark t)))

     (if (or arg (null mark) (/= mark (point)))
        (push-mark nil nomsg t)
     (if (or arg (null mark) (/= mark (point)))
        (push-mark nil nomsg t)

-      (setq mark-active t)
-      (run-hooks 'activate-mark-hook)
+      (activate-mark 'no-tmm)

       (unless nomsg
        (message "Mark activated")))))
 
       (unless nomsg
        (message "Mark activated")))))
 


@@ -4357,11 +4625,11 @@ global mark ring, if the previous mark was set in another buffer.
 When Transient Mark Mode is off, immediately repeating this
 command activates `transient-mark-mode' temporarily.
 
 When Transient Mark Mode is off, immediately repeating this
 command activates `transient-mark-mode' temporarily.
 

-With prefix argument \(e.g., \\[universal-argument] \\[set-mark-command]\), \
+With prefix argument (e.g., \\[universal-argument] \\[set-mark-command]), \

 jump to the mark, and set the mark from
 jump to the mark, and set the mark from

-position popped off the local mark ring \(this does not affect the global
-mark ring\).  Use \\[pop-global-mark] to jump to a mark popped off the global
-mark ring \(see `pop-global-mark'\).
+position popped off the local mark ring (this does not affect the global
+mark ring).  Use \\[pop-global-mark] to jump to a mark popped off the global
+mark ring (see `pop-global-mark').

 
 If `set-mark-command-repeat-pop' is non-nil, repeating
 the \\[set-mark-command] command with no prefix argument pops the next position
 
 If `set-mark-command-repeat-pop' is non-nil, repeating
 the \\[set-mark-command] command with no prefix argument pops the next position


@@ -4466,7 +4734,6 @@ mode temporarily."
        (temp-highlight (eq (car-safe transient-mark-mode) 'only)))
     (if (null omark)
         (error "No mark set in this buffer"))
        (temp-highlight (eq (car-safe transient-mark-mode) 'only)))
     (if (null omark)
         (error "No mark set in this buffer"))

-    (deactivate-mark)

     (set-mark (point))
     (goto-char omark)
     (cond (temp-highlight
     (set-mark (point))
     (goto-char omark)
     (cond (temp-highlight


@@ -4638,6 +4905,7 @@ and more reliable (no dependence on goal column, etc.)."
           (signal (car err) (cdr err))))
       (line-move arg nil nil try-vscroll)))
   nil)
           (signal (car err) (cdr err))))
       (line-move arg nil nil try-vscroll)))
   nil)

+(put 'next-line 'interactive-only 'forward-line)

 
 (defun previous-line (&optional arg try-vscroll)
   "Move cursor vertically up ARG lines.
 
 (defun previous-line (&optional arg try-vscroll)
   "Move cursor vertically up ARG lines.


@@ -4677,6 +4945,8 @@ to use and more reliable (no dependence on goal column, etc.)."
         (signal (car err) (cdr err))))
     (line-move (- arg) nil nil try-vscroll))
   nil)
         (signal (car err) (cdr err))))
     (line-move (- arg) nil nil try-vscroll))
   nil)

+(put 'previous-line 'interactive-only
+     "use `forward-line' with negative argument instead.")

 
 (defcustom track-eol nil
   "Non-nil means vertical motion starting at end of line keeps to ends of lines.
 
 (defcustom track-eol nil
   "Non-nil means vertical motion starting at end of line keeps to ends of lines.


@@ -4889,6 +5159,12 @@ The value is a floating-point number."
 ;; 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)
 ;; 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)

+  "Move forward ARG lines.
+If NOERROR, don't signal an error if we can't move ARG lines.
+TO-END is unused.
+TRY-VSCROLL controls whether to vscroll tall lines: if either
+`auto-window-vscroll' or TRY-VSCROLL is nil, this function will
+not vscroll."

   (if noninteractive
       (forward-line arg)
     (unless (and auto-window-vscroll try-vscroll
   (if noninteractive
       (forward-line arg)
     (unless (and auto-window-vscroll try-vscroll


@@ -4938,6 +5214,8 @@ The value is a floating-point number."
 ;; Arg says how many lines to move.  The value is t if we can move the
 ;; specified number of lines.
 (defun line-move-visual (arg &optional noerror)
 ;; Arg says how many lines to move.  The value is t if we can move the
 ;; specified number of lines.
 (defun line-move-visual (arg &optional noerror)

+  "Move ARG lines forward.
+If NOERROR, don't signal an error if we can't move that many lines."

   (let ((opoint (point))
        (hscroll (window-hscroll))
        target-hscroll)
   (let ((opoint (point))
        (hscroll (window-hscroll))
        target-hscroll)


@@ -5150,7 +5428,7 @@ The value is a floating-point number."
        ;; the middle of a continued line.  When we get to
        ;; line-move-finish, point is at the start of a new *screen*
        ;; line but the same text line; then line-move-to-column would
        ;; the middle of a continued line.  When we get to
        ;; line-move-finish, point is at the start of a new *screen*
        ;; line but the same text line; then line-move-to-column would

-       ;; move us backwards. Test using C-n with point on the "x" in
+       ;; move us backwards.  Test using C-n with point on the "x" in

        ;;   (insert "a" (propertize "x" 'field t) (make-string 89 ?y))
        (and forward
             (< (point) old)
        ;;   (insert "a" (propertize "x" 'field t) (make-string 89 ?y))
        (and forward
             (< (point) old)


@@ -5308,9 +5586,9 @@ To ignore intangibility, bind `inhibit-point-motion-hooks' to t."
       (goto-char (previous-char-property-change (point)))
       (skip-chars-backward "^\n"))
 
       (goto-char (previous-char-property-change (point)))
       (skip-chars-backward "^\n"))
 

-    ;; Now find first visible char in the line
-    (while (and (not (eobp)) (invisible-p (point)))
-      (goto-char (next-char-property-change (point))))
+    ;; Now find first visible char in the line.
+    (while (and (< (point) orig) (invisible-p (point)))
+      (goto-char (next-char-property-change (point) orig)))

     (setq first-vis (point))
 
     ;; See if fields would stop us from reaching FIRST-VIS.
     (setq first-vis (point))
 
     ;; See if fields would stop us from reaching FIRST-VIS.


@@ -6106,8 +6384,12 @@ If called from Lisp, enable the mode if ARG is omitted or nil."
   :group 'paren-matching)
 
 (defcustom blink-matching-paren t
   :group 'paren-matching)
 
 (defcustom blink-matching-paren t

-  "Non-nil means show matching open-paren when close-paren is inserted."
-  :type 'boolean
+  "Non-nil means show matching open-paren when close-paren is inserted.
+If t, highlight the paren.  If `jump', move cursor to its position."
+  :type '(choice
+          (const :tag "Disable" nil)
+          (const :tag "Highlight" t)
+          (const :tag "Move cursor" jump))

   :group 'paren-blinking)
 
 (defcustom blink-matching-paren-on-screen t
   :group 'paren-blinking)
 
 (defcustom blink-matching-paren-on-screen t


@@ -6167,8 +6449,15 @@ position just before the opening token and END is the position right after.
 START can be nil, if it was not found.
 The function should return non-nil if the two tokens do not match.")
 
 START can be nil, if it was not found.
 The function should return non-nil if the two tokens do not match.")
 

+(defvar blink-matching--overlay
+  (let ((ol (make-overlay (point) (point) nil t)))
+    (overlay-put ol 'face 'show-paren-match)
+    (delete-overlay ol)
+    ol)
+  "Overlay used to highlight the matching paren.")
+

 (defun blink-matching-open ()
 (defun blink-matching-open ()

-  "Move cursor momentarily to the beginning of the sexp before point."
+  "Momentarily highlight the beginning of the sexp before point."

   (interactive)
   (when (and (not (bobp))
             blink-matching-paren)
   (interactive)
   (when (and (not (bobp))
             blink-matching-paren)


@@ -6210,13 +6499,21 @@ The function should return non-nil if the two tokens do not match.")
             (message "No matching parenthesis found"))))
        ((not blinkpos) nil)
        ((pos-visible-in-window-p blinkpos)
             (message "No matching parenthesis found"))))
        ((not blinkpos) nil)
        ((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.
+        ;; Matching open within window, temporarily move to or highlight
+        ;; char after blinkpos but only if `blink-matching-paren-on-screen'
+        ;; is non-nil.

         (and blink-matching-paren-on-screen
              (not show-paren-mode)
         (and blink-matching-paren-on-screen
              (not show-paren-mode)

-             (save-excursion
-               (goto-char blinkpos)
-               (sit-for blink-matching-delay))))
+             (if (eq blink-matching-paren 'jump)
+                 (save-excursion
+                   (goto-char blinkpos)
+                   (sit-for blink-matching-delay))
+               (unwind-protect
+                   (progn
+                     (move-overlay blink-matching--overlay blinkpos (1+ blinkpos)
+                                   (current-buffer))
+                     (sit-for blink-matching-delay))
+                 (delete-overlay blink-matching--overlay)))))

        (t
         (save-excursion
           (goto-char blinkpos)
        (t
         (save-excursion
           (goto-char blinkpos)


@@ -6269,10 +6566,14 @@ More precisely, a char with closeparen syntax is self-inserted.")
                                 (point))))))
     (funcall blink-paren-function)))
 
                                 (point))))))
     (funcall blink-paren-function)))
 

+(put 'blink-paren-post-self-insert-function 'priority 100)
+

 (add-hook 'post-self-insert-hook #'blink-paren-post-self-insert-function
           ;; Most likely, this hook is nil, so this arg doesn't matter,
           ;; but I use it as a reminder that this function usually
 (add-hook 'post-self-insert-hook #'blink-paren-post-self-insert-function
           ;; Most likely, this hook is nil, so this arg doesn't matter,
           ;; but I use it as a reminder that this function usually

-          ;; likes to be run after others since it does `sit-for'.
+          ;; likes to be run after others since it does
+          ;; `sit-for'. That's also the reason it get a `priority' prop
+          ;; of 100.

           'append)
 \f
 ;; This executes C-g typed while Emacs is waiting for a command.
           'append)
 \f
 ;; This executes C-g typed while Emacs is waiting for a command.


@@ -6574,7 +6875,7 @@ With a prefix argument, set VARIABLE to VALUE buffer-locally."
 
 (defvar completion-list-mode-map
   (let ((map (make-sparse-keymap)))
 
 (defvar completion-list-mode-map
   (let ((map (make-sparse-keymap)))

-    (define-key map [mouse-2] 'mouse-choose-completion)
+    (define-key map [mouse-2] 'choose-completion)

     (define-key map [follow-link] 'mouse-face)
     (define-key map [down-mouse-2] nil)
     (define-key map "\C-m" 'choose-completion)
     (define-key map [follow-link] 'mouse-face)
     (define-key map [down-mouse-2] nil)
     (define-key map "\C-m" 'choose-completion)


@@ -6668,7 +6969,8 @@ With prefix argument N, move N items (negative N means move backward)."
        (setq n (1+ n))))))
 
 (defun choose-completion (&optional event)
        (setq n (1+ n))))))
 
 (defun choose-completion (&optional event)

-  "Choose the completion at point."
+  "Choose the completion at point.
+If EVENT, use EVENT's position to determine the starting position."

   (interactive (list last-nonmenu-event))
   ;; In case this is run via the mouse, give temporary modes such as
   ;; isearch a chance to turn off.
   (interactive (list last-nonmenu-event))
   ;; In case this is run via the mouse, give temporary modes such as
   ;; isearch a chance to turn off.


@@ -6739,12 +7041,10 @@ With prefix argument N, move N items (negative N means move backward)."
 
 (defvar choose-completion-string-functions nil
   "Functions that may override the normal insertion of a completion choice.
 
 (defvar choose-completion-string-functions nil
   "Functions that may override the normal insertion of a completion choice.

-These functions are called in order with four arguments:
+These functions are called in order with three arguments:

 CHOICE - the string to insert in the buffer,
 BUFFER - the buffer in which the choice should be inserted,
 CHOICE - the string to insert in the buffer,
 BUFFER - the buffer in which the choice should be inserted,

-MINI-P - non-nil if BUFFER is a minibuffer, and
-BASE-SIZE - the number of characters in BUFFER before
-the string being completed.
+BASE-POSITION - where to insert the completion.

 
 If a function in the list returns non-nil, that function is supposed
 to have inserted the CHOICE in the BUFFER, and possibly exited
 
 If a function in the list returns non-nil, that function is supposed
 to have inserted the CHOICE in the BUFFER, and possibly exited


@@ -6824,8 +7124,7 @@ back on `completion-list-insert-choice-function' when nil."
   "Major mode for buffers showing lists of possible completions.
 Type \\<completion-list-mode-map>\\[choose-completion] in the completion list\
  to select the completion near point.
   "Major mode for buffers showing lists of possible completions.
 Type \\<completion-list-mode-map>\\[choose-completion] in the completion list\
  to select the completion near point.

-Use \\<completion-list-mode-map>\\[mouse-choose-completion] to select one\
- with the mouse.
+Or click to select one with the mouse.

 
 \\{completion-list-mode-map}"
   (set (make-local-variable 'completion-base-size) nil))
 
 \\{completion-list-mode-map}"
   (set (make-local-variable 'completion-base-size) nil))


@@ -6883,7 +7182,7 @@ Called from `temp-buffer-show-hook'."
        (goto-char (point-min))
        (if (display-mouse-p)
            (insert (substitute-command-keys
        (goto-char (point-min))
        (if (display-mouse-p)
            (insert (substitute-command-keys

-                    "Click \\[mouse-choose-completion] on a completion to select it.\n")))
+                    "Click on a completion to select it.\n")))

        (insert (substitute-command-keys
                 "In this buffer, type \\[choose-completion] to \
 select the completion near point.\n\n"))))))
        (insert (substitute-command-keys
                 "In this buffer, type \\[choose-completion] to \
 select the completion near point.\n\n"))))))


@@ -6987,17 +7286,11 @@ PREFIX is the string that represents this modifier in an event type symbol."
         (normal (nth 1 keypad-normal)))
      (put keypad 'ascii-character normal)
      (define-key function-key-map (vector keypad) (vector normal))))
         (normal (nth 1 keypad-normal)))
      (put keypad 'ascii-character normal)
      (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 ?\s)
+ ;; See also kp-keys bound in bindings.el.
+ '((kp-space ?\s)

    (kp-tab ?\t)
    (kp-enter ?\r)
    (kp-tab ?\t)
    (kp-enter ?\r)

-   (kp-multiply ?*)
-   (kp-add ?+)

    (kp-separator ?,)
    (kp-separator ?,)

-   (kp-subtract ?-)
-   (kp-decimal ?.)
-   (kp-divide ?/)

    (kp-equal ?=)
    ;; Do the same for various keys that are represented as symbols under
    ;; GUIs but naturally correspond to characters.
    (kp-equal ?=)
    ;; Do the same for various keys that are represented as symbols under
    ;; GUIs but naturally correspond to characters.


@@ -7294,7 +7587,7 @@ See also `normal-erase-is-backspace'."
             (if enabled
                 (progn
                   (define-key local-function-key-map [delete] [deletechar])
             (if enabled
                 (progn
                   (define-key local-function-key-map [delete] [deletechar])

-                  (define-key local-function-key-map [kp-delete] [?\C-d])
+                  (define-key local-function-key-map [kp-delete] [deletechar])

                   (define-key local-function-key-map [backspace] [?\C-?])
                    (dolist (b bindings)
                      ;; Not sure if input-decode-map is really right, but
                   (define-key local-function-key-map [backspace] [?\C-?])
                    (dolist (b bindings)
                      ;; Not sure if input-decode-map is really right, but


@@ -7474,10 +7767,21 @@ warning using STRING as the message.")
 ;; ;;;###autoload (push '("My impl name" . my-impl-symbol) COMMAND-alternatives
 
 (defmacro define-alternatives (command &rest customizations)
 ;; ;;;###autoload (push '("My impl name" . my-impl-symbol) COMMAND-alternatives
 
 (defmacro define-alternatives (command &rest customizations)

-  "Define new command `COMMAND'.
-The variable `COMMAND-alternatives' will contain alternative
-implementations of COMMAND, so that running `C-u M-x COMMAND'
-will allow the user to chose among them.
+  "Define the new command `COMMAND'.
+
+The argument `COMMAND' should be a symbol.
+
+Running `M-x COMMAND RET' for the first time prompts for which
+alternative to use and records the selected command as a custom
+variable.
+
+Running `C-u M-x COMMAND RET' prompts again for an alternative
+and overwrites the previous choice.
+
+The variable `COMMAND-alternatives' contains an alist with
+alternative implementations of COMMAND.  `define-alternatives'
+does not have any effect until this variable is set.
+

 CUSTOMIZATIONS, if non-nil, should be composed of alternating
 `defcustom' keywords and values to add to the declaration of
 `COMMAND-alternatives' (typically :group and :version)."
 CUSTOMIZATIONS, if non-nil, should be composed of alternating
 `defcustom' keywords and values to add to the declaration of
 `COMMAND-alternatives' (typically :group and :version)."


@@ -7497,6 +7801,7 @@ ALTFUN  - The function called to implement this alternative."
          :type '(alist :key-type string :value-type function)
          ,@customizations)
 
          :type '(alist :key-type string :value-type function)
          ,@customizations)
 

+       (put ',varalt-sym 'definition-name ',command)

        (defvar ,varimp-sym nil "Internal use only.")
 
        (defun ,command (&optional arg)
        (defvar ,varimp-sym nil "Internal use only.")
 
        (defun ,command (&optional arg)


@@ -7508,16 +7813,49 @@ contains the list of implementations currently supported for this command."
          (interactive "P")
          (when (or arg (null ,varimp-sym))
            (let ((val (completing-read
          (interactive "P")
          (when (or arg (null ,varimp-sym))
            (let ((val (completing-read

-                       ,(format "Select implementation for command `%s': " command-name)
-                       ,varalt-sym nil t)))
+                      ,(format "Select implementation for command `%s': "
+                               command-name)
+                      ,varalt-sym nil t)))

              (unless (string-equal val "")
              (unless (string-equal val "")

-               (customize-save-variable ',varimp-sym
-                                        (cdr (assoc-string val ,varalt-sym))))))
+              (when (null ,varimp-sym)
+                (message
+                 "Use `C-u M-x %s RET' to select another implementation"
+                 ,command-name)
+                (sit-for 3))
+              (customize-save-variable ',varimp-sym
+                                       (cdr (assoc-string val ,varalt-sym))))))

          (if ,varimp-sym
          (if ,varimp-sym

-             (funcall ,varimp-sym)
+             (call-interactively ,varimp-sym)

            (message ,(format "No implementation selected for command `%s'"
                              command-name)))))))
 
            (message ,(format "No implementation selected for command `%s'"
                              command-name)))))))
 

+\f
+;; This is here because files in obsolete/ are not scanned for autoloads.
+
+(defvar iswitchb-mode nil "\
+Non-nil if Iswitchb mode is enabled.
+See the command `iswitchb-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `iswitchb-mode'.")
+
+(custom-autoload 'iswitchb-mode "iswitchb" nil)
+
+(autoload 'iswitchb-mode "iswitchb" "\
+Toggle Iswitchb mode.
+With a prefix argument ARG, enable Iswitchb mode if ARG is
+positive, and disable it otherwise.  If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Iswitchb mode is a global minor mode that enables switching
+between buffers using substrings.  See `iswitchb' for details.
+
+\(fn &optional ARG)" t nil)
+
+(make-obsolete 'iswitchb-mode
+               "use `icomplete-mode' or `ido-mode' instead." "24.4")
+\f
+

 (provide 'simple)
 
 ;;; simple.el ends here
 (provide 'simple)
 
 ;;; simple.el ends here